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

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 4.0)
-project(condition)
+project(criteria)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

include/matador/condition/between_condition_node.hpp

@@ -1,23 +0,0 @@
-#ifndef CONDITION_BETWEEN_CONDITION_NODE_HPP
-#define CONDITION_BETWEEN_CONDITION_NODE_HPP
-
-#include "column.hpp"
-#include "condition_node.hpp"
-#include "value.hpp"
-
-namespace matador::condition {
-
-class between_condition_node final : public condition_node {
-public:
-    between_condition_node() = delete;
-    between_condition_node(column column, value min, value max);
-
-    void accept(condition_node_visitor& visitor) const override;
-
-private:
-    column column_;
-    value min_;
-    value max_;
-};
-}
-#endif //CONDITION_BETWEEN_CONDITION_NODE_HPP

include/matador/condition/binary_condition_node.hpp

@@ -1,31 +0,0 @@
-#ifndef CONDITION_BINARY_CONDITION_NODE_HPP
-#define CONDITION_BINARY_CONDITION_NODE_HPP
-
-#include "matador/condition/condition_node.hpp"
-#include "matador/condition/column.hpp"
-#include "matador/condition/value.hpp"
-
-namespace matador::condition {
-enum class binary_operator {
-    EQUALS,
-    NOT_EQUALS,
-    GREATER_THAN,
-    GREATER_THAN_OR_EQUAL,
-    LESS_THAN,
-    LESS_THAN_OR_EQUAL,
-};
-
-class binary_condition_node final : public condition_node {
-public:
-    binary_condition_node() = delete;
-    binary_condition_node( column column, binary_operator operator_, value value );
-
-    void accept( condition_node_visitor& visitor ) const override;
-
-private:
-    column column_;
-    binary_operator operator_{};
-    value value_;
-};
-}
-#endif //CONDITION_BINARY_CONDITION_NODE_HPP

include/matador/condition/collection_condition_node.hpp

@@ -1,27 +0,0 @@
-#ifndef CONDITION_COLLECTION_CONDITION_NODE_HPP
-#define CONDITION_COLLECTION_CONDITION_NODE_HPP
-
-#include "column.hpp"
-#include "condition_node.hpp"
-#include "value.hpp"
-
-namespace matador::condition {
-enum class collection_operator {
-    IN,
-    OUT
-};
-
-class collection_condition_node final : public condition_node {
-public:
-    collection_condition_node() = delete;
-    collection_condition_node(column col, collection_operator operator_, std::vector<value> values);
-    collection_condition_node(column col, collection_operator operator_, std::initializer_list<value> values);
-
-    void accept(condition_node_visitor& visitor) const override;
-private:
-    column column_;
-    collection_operator operator_;
-    std::vector<value> values_;
-};
-}
-#endif //CONDITION_COLLECTION_CONDITION_NODE_HPP

include/matador/condition/condition_node.hpp

@@ -1,20 +0,0 @@
-#ifndef CONDITION_CONDITION_NODE_HPP
-#define CONDITION_CONDITION_NODE_HPP
-
-#include <memory>
-
-namespace matador::condition {
-
-class condition_node_visitor;
-
-class condition_node {
-public:
-    virtual ~condition_node() = default;
-
-    virtual void accept(condition_node_visitor& visitor) const = 0;
-};
-
-using condition_node_ptr = std::unique_ptr<condition_node>;
-
-}
-#endif //CONDITION_CONDITION_NODE_HPP

include/matador/condition/condition_node_visitor.hpp

@@ -1,24 +0,0 @@
-#ifndef CONDITION_CONDITION_NODE_VISITOR_HPP
-#define CONDITION_CONDITION_NODE_VISITOR_HPP
-
-namespace matador::condition {
-class between_condition_node;
-class binary_condition_node;
-class like_condition_node;
-class logical_condition_node;
-class not_condition_node;
-class collection_condition_node;
-
-class condition_node_visitor {
-public:
-    virtual ~condition_node_visitor() = default;
-
-    virtual void visit(const between_condition_node &node) = 0;
-    virtual void visit(const binary_condition_node &node) = 0;
-    virtual void visit(const collection_condition_node &node) = 0;
-    virtual void visit(const like_condition_node &node) = 0;
-    virtual void visit(const logical_condition_node &node) = 0;
-    virtual void visit(const not_condition_node &node) = 0;
-};
-}
-#endif //CONDITION_CONDITION_NODE_VISITOR_HPP

include/matador/condition/like_condition_node.hpp

@@ -1,20 +0,0 @@
-#ifndef CONDITION_LIKE_CONDITION_NODE_HPP
-#define CONDITION_LIKE_CONDITION_NODE_HPP
-
-#include "column.hpp"
-#include "condition_node.hpp"
-
-namespace matador::condition {
-class like_condition_node final : public condition_node {
-public:
-  like_condition_node() = delete;
-  like_condition_node(column column, std::string pattern);
-
-  void accept(condition_node_visitor &visitor) const override;
-
-private:
-  column column_;
-  std::string pattern_;
-};
-}
-#endif //CONDITION_LIKE_CONDITION_NODE_HPP

include/matador/condition/logical_condition_node.hpp

@@ -1,25 +0,0 @@
-#ifndef CONDITION_LOGICAL_CONDITION_NODE_HPP
-#define CONDITION_LOGICAL_CONDITION_NODE_HPP
-
-#include "condition_node.hpp"
-
-namespace matador::condition {
-enum class logical_operator {
-    AND,
-    OR,
-};
-
-class logical_condition_node final : public condition_node {
-public:
-    logical_condition_node() = delete;
-    logical_condition_node(condition_node_ptr left, logical_operator op, condition_node_ptr right);
-
-    void accept(condition_node_visitor& visitor) const override;
-
-private:
-    std::unique_ptr<condition_node> left_;
-    logical_operator op_;
-    std::unique_ptr<condition_node> right_;
-};
-}
-#endif //CONDITION_LOGICAL_CONDITION_NODE_HPP

include/matador/condition/not_condition_node.hpp

@@ -1,18 +0,0 @@
-#ifndef CONDITION_NOT_CONDITION_NODE_HPP
-#define CONDITION_NOT_CONDITION_NODE_HPP
-
-#include "matador/condition/condition_node.hpp"
-
-namespace matador::condition {
-class not_condition_node final : public condition_node {
-public:
-    not_condition_node(condition_node_ptr condition);
-
-    void accept(condition_node_visitor& visitor) const override;
-
-private:
-    condition_node_ptr condition_;
-};
-}
-
-#endif //CONDITION_NOT_CONDITION_NODE_HPP

include/matador/criteria/between_criteria.hpp

@@ -0,0 +1,23 @@
+#ifndef CRITERIA_BETWEEN_CRITERIA_NODE_HPP
+#define CRITERIA_BETWEEN_CRITERIA_NODE_HPP
+
+#include "column.hpp"
+#include "criteria.hpp"
+#include "value.hpp"
+
+namespace matador::criteria {
+
+class between_criteria final : public criteria {
+public:
+    between_criteria() = delete;
+    between_criteria(column column, value min, value max);
+
+    void accept(condition_node_visitor& visitor) const override;
+
+private:
+    column column_;
+    value min_;
+    value max_;
+};
+}
+#endif //CRITERIA_BETWEEN_CRITERIA_NODE_HPP

include/matador/criteria/binary_criteria.hpp

@@ -0,0 +1,31 @@
+#ifndef CRITERIA_BINARY_CRITERIA_NODE_HPP
+#define CRITERIA_BINARY_CRITERIA_NODE_HPP
+
+#include "matador/criteria/criteria.hpp"
+#include "matador/criteria/column.hpp"
+#include "matador/criteria/value.hpp"
+
+namespace matador::criteria {
+enum class binary_operator {
+    EQUALS,
+    NOT_EQUALS,
+    GREATER_THAN,
+    GREATER_THAN_OR_EQUAL,
+    LESS_THAN,
+    LESS_THAN_OR_EQUAL,
+};
+
+class binary_criteria final : public criteria {
+public:
+    binary_criteria() = delete;
+    binary_criteria( column column, binary_operator operator_, value value );
+
+    void accept( condition_node_visitor& visitor ) const override;
+
+private:
+    column column_;
+    binary_operator operator_{};
+    value value_;
+};
+}
+#endif //CRITERIA_BINARY_CRITERIA_NODE_HPP

include/matador/criteria/collection_criteria.hpp

@@ -0,0 +1,27 @@
+#ifndef CRITERIA_COLLECTION_CRITERIA_NODE_HPP
+#define CRITERIA_COLLECTION_CRITERIA_NODE_HPP
+
+#include "column.hpp"
+#include "criteria.hpp"
+#include "value.hpp"
+
+namespace matador::criteria {
+enum class collection_operator {
+    IN,
+    OUT
+};
+
+class collection_criteria final : public criteria {
+public:
+    collection_criteria() = delete;
+    collection_criteria(column col, collection_operator operator_, std::vector<value> values);
+    collection_criteria(column col, collection_operator operator_, std::initializer_list<value> values);
+
+    void accept(condition_node_visitor& visitor) const override;
+private:
+    column column_;
+    collection_operator operator_;
+    std::vector<value> values_;
+};
+}
+#endif //CRITERIA_COLLECTION_CRITERIA_NODE_HPP

include/matador/criteria/column.hpp

@@ -1,9 +1,9 @@
-#ifndef CONDITION_COLUMN_HPP
+#ifndef CRITERIA_COLUMN_HPP
-#define CONDITION_COLUMN_HPP
+#define CRITERIA_COLUMN_HPP
 
 #include <string>
 
-namespace matador::condition {
+namespace matador::criteria {
 class column {
 public:
     explicit column(std::string name);
@@ -20,4 +20,4 @@ private:
 column operator ""_col(const char *name, size_t len);
 
 }
-#endif //CONDITION_COLUMN_HPP
+#endif //CRITERIA_COLUMN_HPP

include/matador/criteria/condition_node_visitor.hpp

@@ -0,0 +1,24 @@
+#ifndef CRITERIA_CRITERIA_NODE_VISITOR_HPP
+#define CRITERIA_CRITERIA_NODE_VISITOR_HPP
+
+namespace matador::criteria {
+class between_criteria;
+class binary_criteria;
+class like_criteria;
+class logical_criteria;
+class not_criteria;
+class collection_criteria;
+
+class condition_node_visitor {
+public:
+    virtual ~condition_node_visitor() = default;
+
+    virtual void visit(const between_criteria &node) = 0;
+    virtual void visit(const binary_criteria &node) = 0;
+    virtual void visit(const collection_criteria &node) = 0;
+    virtual void visit(const like_criteria &node) = 0;
+    virtual void visit(const logical_criteria &node) = 0;
+    virtual void visit(const not_criteria &node) = 0;
+};
+}
+#endif //CRITERIA_CRITERIA_NODE_VISITOR_HPP

include/matador/criteria/condition_operators.hpp

@@ -1,40 +1,40 @@
-#ifndef CONDITION_CONDITION_OPERATORS_HPP
+#ifndef CRITERIA_CRITERIA_OPERATORS_HPP
-#define CONDITION_CONDITION_OPERATORS_HPP
+#define CRITERIA_CRITERIA_OPERATORS_HPP
 
-#include "matador/condition/binary_condition_node.hpp"
+#include "matador/criteria/binary_criteria.hpp"
-#include "matador/condition/collection_condition_node.hpp"
+#include "matador/criteria/collection_criteria.hpp"
-#include "matador/condition/column.hpp"
+#include "matador/criteria/column.hpp"
 
-namespace matador::condition {
+namespace matador::criteria {
 
 template<class Type>
 condition_node_ptr operator==(const column &col, Type val) {
-    return std::make_unique<binary_condition_node>(col, binary_operator::EQUALS, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, val);
 }
 
 template<class Type>
 condition_node_ptr operator!=(const column &col, Type val) {
-    return std::make_unique<binary_condition_node>(col, binary_operator::NOT_EQUALS, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, val);
 }
 
 template<class Type>
 condition_node_ptr operator>(const column &col, Type val) {
-    return std::make_unique<binary_condition_node>(col, binary_operator::GREATER_THAN, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN, val);
 }
 
 template<class Type>
 condition_node_ptr operator>=(const column &col, Type val) {
-    return std::make_unique<binary_condition_node>(col, binary_operator::GREATER_THAN_OR_EQUAL, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, val);
 }
 
 template<class Type>
 condition_node_ptr operator<(const column &col, Type val) {
-    return std::make_unique<binary_condition_node>(col, binary_operator::LESS_THAN, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, val);
 }
 
 template<class Type>
 condition_node_ptr operator<=(const column &col, Type val) {
-    return std::make_unique<binary_condition_node>(col, binary_operator::LESS_THAN_OR_EQUAL, val);
+    return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, val);
 }
 
 condition_node_ptr operator&&(condition_node_ptr left, condition_node_ptr right);
@@ -49,7 +49,7 @@ condition_node_ptr in(const column &col, std::initializer_list<Type> args) {
     for ( auto &&arg : args ) {
         values.emplace_back(std::move(arg));
     }
-    return std::make_unique<collection_condition_node>(col, collection_operator::IN, std::move(values));
+    return std::make_unique<collection_criteria>(col, collection_operator::IN, std::move(values));
 }
 
 template < class V >
@@ -58,7 +58,7 @@ condition_node_ptr out(const column &col, std::initializer_list<V> args) {
     for ( auto &&arg : args ) {
         values.emplace_back(std::move(arg));
     }
-    return std::make_unique<collection_condition_node>(col, collection_operator::OUT, values);
+    return std::make_unique<collection_criteria>(col, collection_operator::OUT, values);
 }
 
 condition_node_ptr between(const column &col, value min, value max);
@@ -66,4 +66,4 @@ condition_node_ptr between(const column &col, value min, value max);
 condition_node_ptr like(const column &col, const std::string &pattern);
 
 }
-#endif //CONDITION_CONDITION_OPERATORS_HPP
+#endif //CRITERIA_CRITERIA_OPERATORS_HPP

include/matador/criteria/criteria.hpp

@@ -0,0 +1,20 @@
+#ifndef CRITERIA_CRITERIA_NODE_HPP
+#define CRITERIA_CRITERIA_NODE_HPP
+
+#include <memory>
+
+namespace matador::criteria {
+
+class condition_node_visitor;
+
+class criteria {
+public:
+    virtual ~criteria() = default;
+
+    virtual void accept(condition_node_visitor& visitor) const = 0;
+};
+
+using condition_node_ptr = std::unique_ptr<criteria>;
+
+}
+#endif //CRITERIA_CRITERIA_NODE_HPP

include/matador/criteria/like_criteria.hpp

@@ -0,0 +1,20 @@
+#ifndef CRITERIA_LIKE_CRITERIA_NODE_HPP
+#define CRITERIA_LIKE_CRITERIA_NODE_HPP
+
+#include "column.hpp"
+#include "criteria.hpp"
+
+namespace matador::criteria {
+class like_criteria final : public criteria {
+public:
+  like_criteria() = delete;
+  like_criteria(column column, std::string pattern);
+
+  void accept(condition_node_visitor &visitor) const override;
+
+private:
+  column column_;
+  std::string pattern_;
+};
+}
+#endif //CRITERIA_LIKE_CRITERIA_NODE_HPP

include/matador/criteria/logical_criteria.hpp

@@ -0,0 +1,25 @@
+#ifndef CRITERIA_LOGICAL_CRITERIA_NODE_HPP
+#define CRITERIA_LOGICAL_CRITERIA_NODE_HPP
+
+#include "criteria.hpp"
+
+namespace matador::criteria {
+enum class logical_operator {
+    AND,
+    OR,
+};
+
+class logical_criteria final : public criteria {
+public:
+    logical_criteria() = delete;
+    logical_criteria(condition_node_ptr left, logical_operator op, condition_node_ptr right);
+
+    void accept(condition_node_visitor& visitor) const override;
+
+private:
+    std::unique_ptr<criteria> left_;
+    logical_operator op_;
+    std::unique_ptr<criteria> right_;
+};
+}
+#endif //CRITERIA_LOGICAL_CRITERIA_NODE_HPP

include/matador/criteria/not_criteria.hpp

@@ -0,0 +1,18 @@
+#ifndef CRITERIA_NOT_CRITERIA_NODE_HPP
+#define CRITERIA_NOT_CRITERIA_NODE_HPP
+
+#include "matador/criteria/criteria.hpp"
+
+namespace matador::criteria {
+class not_criteria final : public criteria {
+public:
+    not_criteria(condition_node_ptr condition);
+
+    void accept(condition_node_visitor& visitor) const override;
+
+private:
+    condition_node_ptr condition_;
+};
+}
+
+#endif //CRITERIA_NOT_CRITERIA_NODE_HPP

include/matador/criteria/types.hpp

@@ -1,12 +1,12 @@
-#ifndef CONDITION_TYPES_HPP
+#ifndef CRITERIA_TYPES_HPP
-#define CONDITION_TYPES_HPP
+#define CRITERIA_TYPES_HPP
 
 #include <cstdint>
 #include <variant>
 #include <string>
 #include <vector>
 
-namespace matador::condition {
+namespace matador::criteria {
 
 using byte = unsigned char;
 using blob = std::vector<byte>;
@@ -21,4 +21,4 @@ using basic_types = std::variant<
     blob,
     nullptr_t>;
 }
-#endif //CONDITION_TYPES_HPP
+#endif //CRITERIA_TYPES_HPP

include/matador/criteria/value.hpp

@@ -1,11 +1,11 @@
-#ifndef CONDITION_VALUE_HPP
+#ifndef CRITERIA_VALUE_HPP
-#define CONDITION_VALUE_HPP
+#define CRITERIA_VALUE_HPP
 
 #include "types.hpp"
 
 #include <optional>
 
-namespace matador::condition {
+namespace matador::criteria {
 
 class value final {
 public:
@@ -38,4 +38,4 @@ private:
 };
 
 }
-#endif //CONDITION_VALUE_HPP
+#endif //CRITERIA_VALUE_HPP

src/CMakeLists.txt

@@ -1,28 +1,28 @@
 SET(SOURCE
-    ../include/matador/condition/collection_condition_node.hpp
+  ../include/matador/criteria/between_criteria.hpp
-    ../include/matador/condition/column.hpp
+  ../include/matador/criteria/collection_criteria.hpp
-    ../include/matador/condition/condition_node.hpp
+  ../include/matador/criteria/column.hpp
-    ../include/matador/condition/condition_node_visitor.hpp
+  ../include/matador/criteria/condition_node_visitor.hpp
-    ../include/matador/condition/condition_operators.hpp
+  ../include/matador/criteria/condition_operators.hpp
-    ../include/matador/condition/logical_condition_node.hpp
+  ../include/matador/criteria/criteria.hpp
-    ../include/matador/condition/types.hpp
+  ../include/matador/criteria/like_criteria.hpp
-    ../include/matador/condition/value.hpp
+  ../include/matador/criteria/logical_criteria.hpp
-    condition/binary_condition_node.cpp
+  ../include/matador/criteria/types.hpp
-    condition/collection_condition_node.cpp
+  ../include/matador/criteria/value.hpp
-    condition/column.cpp
+  criteria/between_criteria.cpp
-    condition/condition_operators.cpp
+  criteria/binary_criteria.cpp
-    condition/not_condition_node.cpp
+  criteria/collection_criteria.cpp
-    condition/logical_condition_node.cpp
+  criteria/column.cpp
-        ../include/matador/condition/between_condition_node.hpp
+  criteria/condition_operators.cpp
-        condition/between_condition_node.cpp
+  criteria/like_criteria.cpp
-  ../include/matador/condition/like_condition_node.hpp
+  criteria/logical_criteria.cpp
-  condition/like_condition_node.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/criteria/column.hpp"
-#include "matador/condition/condition_operators.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;
+    auto clause = "age"_col != 7 && "age"_col == 7;
-    cond = !("person.age"_col == 7);
+    clause = !("person.age"_col == 7);
-    cond = "age"_col > 7;
+    clause = "age"_col > 7;
-    cond = "age"_col < 7;
+    clause = "age"_col < 7;
-    cond = "age"_col >= 7;
+    clause = "age"_col >= 7;
-    cond = "age"_col <= 7;
+    clause = "age"_col <= 7;
-    cond = in("age"_col, {34, 35, 78});
+    clause = in("age"_col, {34, 35, 78});
-    cond = out("age"_col, {34, 35, 78});
+    clause = out("age"_col, {34, 35, 78});
-    cond = between("age"_col, 34, 78);
+    clause = between("age"_col, 34, 78);
-    cond = like("name"_col, "John");
+    clause = like("name"_col, "John");
 
 
     // "age"_col != 7 && in("age"_col,  {7,5,5,8});