changed condition to criteria (namespace, class names, include guard and cmake names)

src/CMakeLists.txt

@@ -1,28 +1,28 @@
 SET(SOURCE
-    ../include/matador/condition/collection_condition_node.hpp
-    ../include/matador/condition/column.hpp
-    ../include/matador/condition/condition_node.hpp
-    ../include/matador/condition/condition_node_visitor.hpp
-    ../include/matador/condition/condition_operators.hpp
-    ../include/matador/condition/logical_condition_node.hpp
-    ../include/matador/condition/types.hpp
-    ../include/matador/condition/value.hpp
-    condition/binary_condition_node.cpp
-    condition/collection_condition_node.cpp
-    condition/column.cpp
-    condition/condition_operators.cpp
-    condition/not_condition_node.cpp
-    condition/logical_condition_node.cpp
-        ../include/matador/condition/between_condition_node.hpp
-        condition/between_condition_node.cpp
-  ../include/matador/condition/like_condition_node.hpp
-  condition/like_condition_node.cpp
+  ../include/matador/criteria/between_criteria.hpp
+  ../include/matador/criteria/collection_criteria.hpp
+  ../include/matador/criteria/column.hpp
+  ../include/matador/criteria/condition_node_visitor.hpp
+  ../include/matador/criteria/condition_operators.hpp
+  ../include/matador/criteria/criteria.hpp
+  ../include/matador/criteria/like_criteria.hpp
+  ../include/matador/criteria/logical_criteria.hpp
+  ../include/matador/criteria/types.hpp
+  ../include/matador/criteria/value.hpp
+  criteria/between_criteria.cpp
+  criteria/binary_criteria.cpp
+  criteria/collection_criteria.cpp
+  criteria/column.cpp
+  criteria/condition_operators.cpp
+  criteria/like_criteria.cpp
+  criteria/logical_criteria.cpp
+  criteria/not_criteria.cpp
 )
 
-add_library(matador-condition STATIC ${SOURCE})
+add_library(matador-criteria STATIC ${SOURCE})
 
-target_include_directories(matador-condition PUBLIC ../include)
+target_include_directories(matador-criteria PUBLIC ../include)
 
 add_executable(main main.cpp)
 target_include_directories(main PUBLIC ../include)
-target_link_libraries(main matador-condition)
+target_link_libraries(main matador-criteria)

src/condition/between_condition_node.cpp

@@ -1,15 +0,0 @@
-#include "matador/condition/between_condition_node.hpp"
-
-#include "matador/condition/condition_node_visitor.hpp"
-
-namespace matador::condition {
-between_condition_node::between_condition_node( column column, value min, value max )
-: column_(std::move(column))
-, min_(std::move(min))
-, max_(std::move(max))
-{}
-
-void between_condition_node::accept( condition_node_visitor& visitor ) const {
-    visitor.visit(*this);
-}
-}

src/condition/binary_condition_node.cpp

@@ -1,15 +0,0 @@
-#include "matador/condition/binary_condition_node.hpp"
-
-#include "matador/condition/condition_node_visitor.hpp"
-
-namespace matador::condition {
-binary_condition_node::binary_condition_node( column column, const binary_operator operator_, value value )
-: column_(std::move(column))
-, operator_(operator_)
-, value_(std::move(value))
-{}
-
-void binary_condition_node::accept( condition_node_visitor& visitor ) const {
-    visitor.visit(*this);
-}
-}

src/condition/collection_condition_node.cpp

@@ -1,21 +0,0 @@
-#include "matador/condition/collection_condition_node.hpp"
-
-#include "matador/condition/condition_node_visitor.hpp"
-
-namespace matador::condition {
-collection_condition_node::collection_condition_node( column col, collection_operator operator_, std::vector<value> values )
-: column_(std::move(col))
-, operator_(operator_)
-, values_(std::move(values))
-{}
-
-collection_condition_node::collection_condition_node(column col, const collection_operator operator_, const std::initializer_list<value> values )
-: column_(std::move(col))
-, operator_(operator_)
-, values_(values)
-{}
-
-void collection_condition_node::accept( condition_node_visitor& visitor ) const {
-    visitor.visit(*this);
-}
-}

src/condition/condition_operators.cpp

@@ -1,28 +0,0 @@
-#include "matador/condition/condition_operators.hpp"
-
-#include "matador/condition/between_condition_node.hpp"
-#include "matador/condition/like_condition_node.hpp"
-#include "matador/condition/logical_condition_node.hpp"
-#include "matador/condition/not_condition_node.hpp"
-
-namespace matador::condition {
-condition_node_ptr operator&&(condition_node_ptr left, condition_node_ptr right) {
-    return std::make_unique<logical_condition_node>(std::move(left), logical_operator::AND, std::move(right));
-}
-
-condition_node_ptr operator||(condition_node_ptr left, condition_node_ptr right) {
-    return std::make_unique<logical_condition_node>(std::move(left), logical_operator::OR, std::move(right));
-}
-
-condition_node_ptr operator!(condition_node_ptr cond) {
-    return std::make_unique<not_condition_node>(std::move(cond));
-}
-
-condition_node_ptr between(const column &col, value min, value max) {
-    return std::make_unique<between_condition_node>(col, std::move(min), std::move(max));
-}
-
-condition_node_ptr like(const column &col, const std::string &pattern) {
-    return std::make_unique<like_condition_node>(col, pattern);
-}
-}

src/condition/like_condition_node.cpp

@@ -1,13 +0,0 @@
-#include "matador/condition/like_condition_node.hpp"
-
-#include "matador/condition/condition_node_visitor.hpp"
-
-namespace matador::condition {
-like_condition_node::like_condition_node(column column, std::string pattern)
-: column_(std::move(column))
-, pattern_(std::move(pattern)){}
-
-void like_condition_node::accept(condition_node_visitor &visitor) const {
-  visitor.visit(*this);
-}
-}

src/condition/logical_condition_node.cpp

@@ -1,15 +0,0 @@
-#include "matador/condition/logical_condition_node.hpp"
-
-#include "matador/condition/condition_node_visitor.hpp"
-
-namespace matador::condition {
-logical_condition_node::logical_condition_node( condition_node_ptr left, const logical_operator op, condition_node_ptr right )
-: left_(std::move(left))
-, op_(op)
-, right_(std::move(right))
-{}
-
-void logical_condition_node::accept(condition_node_visitor& visitor) const {
-    visitor.visit(*this);
-}
-}

src/condition/not_condition_node.cpp

@@ -1,13 +0,0 @@
-#include "matador/condition/not_condition_node.hpp"
-
-#include "matador/condition/condition_node_visitor.hpp"
-
-namespace matador::condition {
-not_condition_node::not_condition_node(condition_node_ptr condition)
-: condition_(std::move(condition))
-{}
-
-void not_condition_node::accept( condition_node_visitor& visitor ) const {
-    visitor.visit(*this);
-}
-}

src/criteria/between_criteria.cpp

@@ -0,0 +1,15 @@
+#include "matador/criteria/between_criteria.hpp"
+
+#include "matador/criteria/condition_node_visitor.hpp"
+
+namespace matador::criteria {
+between_criteria::between_criteria( column column, value min, value max )
+: column_(std::move(column))
+, min_(std::move(min))
+, max_(std::move(max))
+{}
+
+void between_criteria::accept( condition_node_visitor& visitor ) const {
+    visitor.visit(*this);
+}
+}

src/criteria/binary_criteria.cpp

@@ -0,0 +1,15 @@
+#include "matador/criteria/binary_criteria.hpp"
+
+#include "matador/criteria/condition_node_visitor.hpp"
+
+namespace matador::criteria {
+binary_criteria::binary_criteria( column column, const binary_operator operator_, value value )
+: column_(std::move(column))
+, operator_(operator_)
+, value_(std::move(value))
+{}
+
+void binary_criteria::accept( condition_node_visitor& visitor ) const {
+    visitor.visit(*this);
+}
+}

src/criteria/collection_criteria.cpp

@@ -0,0 +1,21 @@
+#include "matador/criteria/collection_criteria.hpp"
+
+#include "matador/criteria/condition_node_visitor.hpp"
+
+namespace matador::criteria {
+collection_criteria::collection_criteria( column col, collection_operator operator_, std::vector<value> values )
+: column_(std::move(col))
+, operator_(operator_)
+, values_(std::move(values))
+{}
+
+collection_criteria::collection_criteria(column col, const collection_operator operator_, const std::initializer_list<value> values )
+: column_(std::move(col))
+, operator_(operator_)
+, values_(values)
+{}
+
+void collection_criteria::accept( condition_node_visitor& visitor ) const {
+    visitor.visit(*this);
+}
+}

src/criteria/column.cpp

@@ -1,8 +1,8 @@
-#include "matador/condition/column.hpp"
+#include "matador/criteria/column.hpp"
 
 #include <stdexcept>
 
-namespace matador::condition {
+namespace matador::criteria {
 
 column::column( std::string name )
 : name_(std::move(name)) {}

src/criteria/condition_operators.cpp

@@ -0,0 +1,28 @@
+#include "matador/criteria/condition_operators.hpp"
+
+#include "matador/criteria/between_criteria.hpp"
+#include "matador/criteria/like_criteria.hpp"
+#include "matador/criteria/logical_criteria.hpp"
+#include "matador/criteria/not_criteria.hpp"
+
+namespace matador::criteria {
+condition_node_ptr operator&&(condition_node_ptr left, condition_node_ptr right) {
+    return std::make_unique<logical_criteria>(std::move(left), logical_operator::AND, std::move(right));
+}
+
+condition_node_ptr operator||(condition_node_ptr left, condition_node_ptr right) {
+    return std::make_unique<logical_criteria>(std::move(left), logical_operator::OR, std::move(right));
+}
+
+condition_node_ptr operator!(condition_node_ptr cond) {
+    return std::make_unique<not_criteria>(std::move(cond));
+}
+
+condition_node_ptr between(const column &col, value min, value max) {
+    return std::make_unique<between_criteria>(col, std::move(min), std::move(max));
+}
+
+condition_node_ptr like(const column &col, const std::string &pattern) {
+    return std::make_unique<like_criteria>(col, pattern);
+}
+}

src/criteria/like_criteria.cpp

@@ -0,0 +1,13 @@
+#include "matador/criteria/like_criteria.hpp"
+
+#include "matador/criteria/condition_node_visitor.hpp"
+
+namespace matador::criteria {
+like_criteria::like_criteria(column column, std::string pattern)
+: column_(std::move(column))
+, pattern_(std::move(pattern)){}
+
+void like_criteria::accept(condition_node_visitor &visitor) const {
+  visitor.visit(*this);
+}
+}

src/criteria/logical_criteria.cpp

@@ -0,0 +1,15 @@
+#include "matador/criteria/logical_criteria.hpp"
+
+#include "matador/criteria/condition_node_visitor.hpp"
+
+namespace matador::criteria {
+logical_criteria::logical_criteria( condition_node_ptr left, const logical_operator op, condition_node_ptr right )
+: left_(std::move(left))
+, op_(op)
+, right_(std::move(right))
+{}
+
+void logical_criteria::accept(condition_node_visitor& visitor) const {
+    visitor.visit(*this);
+}
+}

src/criteria/not_criteria.cpp

@@ -0,0 +1,13 @@
+#include "matador/criteria/not_criteria.hpp"
+
+#include "matador/criteria/condition_node_visitor.hpp"
+
+namespace matador::criteria {
+not_criteria::not_criteria(condition_node_ptr condition)
+: condition_(std::move(condition))
+{}
+
+void not_criteria::accept( condition_node_visitor& visitor ) const {
+    visitor.visit(*this);
+}
+}

src/main.cpp

@@ -1,19 +1,19 @@
-#include "matador/condition/column.hpp"
-#include "matador/condition/condition_operators.hpp"
+#include "matador/criteria/column.hpp"
+#include "matador/criteria/condition_operators.hpp"
 
-using namespace matador::condition;
+using namespace matador::criteria;
 
 int main() {
-    auto cond = "age"_col != 7 && "age"_col == 7;
-    cond = !("person.age"_col == 7);
-    cond = "age"_col > 7;
-    cond = "age"_col < 7;
-    cond = "age"_col >= 7;
-    cond = "age"_col <= 7;
-    cond = in("age"_col, {34, 35, 78});
-    cond = out("age"_col, {34, 35, 78});
-    cond = between("age"_col, 34, 78);
-    cond = like("name"_col, "John");
+    auto clause = "age"_col != 7 && "age"_col == 7;
+    clause = !("person.age"_col == 7);
+    clause = "age"_col > 7;
+    clause = "age"_col < 7;
+    clause = "age"_col >= 7;
+    clause = "age"_col <= 7;
+    clause = in("age"_col, {34, 35, 78});
+    clause = out("age"_col, {34, 35, 78});
+    clause = between("age"_col, 34, 78);
+    clause = like("name"_col, "John");
 
 
     // "age"_col != 7 && in("age"_col,  {7,5,5,8});