renamed condition_node_visitor to criteria_visitor.hpp and condition_operators to criteria_operators

include/matador/criteria/abstract_criteria.hpp

@@ -5,16 +5,16 @@
 
 namespace matador::criteria {
 
-class condition_node_visitor;
+class criteria_visitor;
 
 class abstract_criteria {
 public:
     virtual ~abstract_criteria() = default;
 
-    virtual void accept(condition_node_visitor& visitor) const = 0;
+    virtual void accept(criteria_visitor& visitor) const = 0;
 };
 
-using condition_node_ptr = std::unique_ptr<abstract_criteria>;
+using criteria_ptr = std::unique_ptr<abstract_criteria>;
 
 }
 #endif //CRITERIA_CRITERIA_NODE_HPP

include/matador/criteria/between_criteria.hpp

@@ -12,7 +12,7 @@ public:
     between_criteria() = delete;
     between_criteria(column column, value min, value max);
 
-    void accept(condition_node_visitor& visitor) const override;
+    void accept(criteria_visitor& visitor) const override;
 
 private:
     column column_;

include/matador/criteria/binary_criteria.hpp

@@ -20,7 +20,7 @@ public:
     binary_criteria() = delete;
     binary_criteria( column column, binary_operator operator_, value value );
 
-    void accept( condition_node_visitor& visitor ) const override;
+    void accept( criteria_visitor& visitor ) const override;
 
 private:
     column column_;

include/matador/criteria/collection_criteria.hpp

@@ -17,7 +17,7 @@ public:
     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;
+    void accept(criteria_visitor& visitor) const override;
 private:
     column column_;
     collection_operator operator_;

include/matador/criteria/criteria.hpp

@@ -8,6 +8,6 @@
 #include "logical_criteria.hpp"
 #include "not_criteria.hpp"
 
-#include "condition_operators.hpp"
+#include "criteria_operators.hpp"
 
 #endif //CRITERIA_CRITERIA_HPP

include/matador/criteria/criteria_operators.hpp

@@ -8,43 +8,43 @@
 namespace matador::criteria {
 
 template<class Type>
-condition_node_ptr operator==(const column &col, Type val) {
+criteria_ptr operator==(const column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, val);
 }
 
 template<class Type>
-condition_node_ptr operator!=(const column &col, Type val) {
+criteria_ptr operator!=(const column &col, Type 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) {
+criteria_ptr operator>(const column &col, Type 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) {
+criteria_ptr operator>=(const column &col, Type 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) {
+criteria_ptr operator<(const column &col, Type 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) {
+criteria_ptr operator<=(const column &col, Type 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);
+criteria_ptr operator&&(criteria_ptr left, criteria_ptr right);
 
-condition_node_ptr operator||(condition_node_ptr left, condition_node_ptr right);
+criteria_ptr operator||(criteria_ptr left, criteria_ptr right);
 
-condition_node_ptr operator!(condition_node_ptr cond);
+criteria_ptr operator!(criteria_ptr clause);
 
 template < class Type >
-condition_node_ptr in(const column &col, std::initializer_list<Type> args) {
+criteria_ptr in(const column &col, std::initializer_list<Type> args) {
     std::vector<value> values;
     for ( auto &&arg : args ) {
         values.emplace_back(std::move(arg));
@@ -53,7 +53,7 @@ condition_node_ptr in(const column &col, std::initializer_list<Type> args) {
 }
 
 template < class V >
-condition_node_ptr out(const column &col, std::initializer_list<V> args) {
+criteria_ptr out(const column &col, std::initializer_list<V> args) {
     std::vector<value> values;
     for ( auto &&arg : args ) {
         values.emplace_back(std::move(arg));
@@ -61,9 +61,9 @@ condition_node_ptr out(const column &col, std::initializer_list<V> args) {
     return std::make_unique<collection_criteria>(col, collection_operator::OUT, values);
 }
 
-condition_node_ptr between(const column &col, value min, value max);
+criteria_ptr between(const column &col, value min, value max);
 
-condition_node_ptr like(const column &col, const std::string &pattern);
+criteria_ptr like(const column &col, const std::string &pattern);
 
 }
 #endif //CRITERIA_CRITERIA_OPERATORS_HPP

include/matador/criteria/criteria_visitor.hpp

@@ -9,9 +9,9 @@ class logical_criteria;
 class not_criteria;
 class collection_criteria;
 
-class condition_node_visitor {
+class criteria_visitor {
 public:
-    virtual ~condition_node_visitor() = default;
+    virtual ~criteria_visitor() = default;
 
     virtual void visit(const between_criteria &node) = 0;
     virtual void visit(const binary_criteria &node) = 0;

include/matador/criteria/like_criteria.hpp

@@ -10,7 +10,7 @@ public:
   like_criteria() = delete;
   like_criteria(column column, std::string pattern);
 
-  void accept(condition_node_visitor &visitor) const override;
+  void accept(criteria_visitor &visitor) const override;
 
 private:
   column column_;

include/matador/criteria/logical_criteria.hpp

@@ -12,14 +12,14 @@ enum class logical_operator {
 class logical_criteria final : public abstract_criteria {
 public:
     logical_criteria() = delete;
-    logical_criteria(condition_node_ptr left, logical_operator op, condition_node_ptr right);
+    logical_criteria(criteria_ptr left, logical_operator op, criteria_ptr right);
 
-    void accept(condition_node_visitor& visitor) const override;
+    void accept(criteria_visitor& visitor) const override;
 
 private:
-    std::unique_ptr<abstract_criteria> left_;
+    std::unique_ptr<abstract_criteria> left_criteria_;
-    logical_operator op_;
+    logical_operator operand_;
-    std::unique_ptr<abstract_criteria> right_;
+    std::unique_ptr<abstract_criteria> right_criteria_;
 };
 }
 #endif //CRITERIA_LOGICAL_CRITERIA_NODE_HPP

include/matador/criteria/not_criteria.hpp

@@ -6,12 +6,12 @@
 namespace matador::criteria {
 class not_criteria final : public abstract_criteria {
 public:
-    not_criteria(condition_node_ptr condition);
+    explicit not_criteria(criteria_ptr clause);
 
-    void accept(condition_node_visitor& visitor) const override;
+    void accept(criteria_visitor& visitor) const override;
 
 private:
-    condition_node_ptr condition_;
+    criteria_ptr criteria_;
 };
 }
 

src/CMakeLists.txt

@@ -1,10 +1,11 @@
 SET(SOURCE
+  ../include/matador/criteria/abstract_criteria.hpp
   ../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/criteria.hpp
-  ../include/matador/criteria/condition_operators.hpp
+  ../include/matador/criteria/criteria_operators.hpp
-  ../include/matador/criteria/abstract_criteria.hpp
+  ../include/matador/criteria/criteria_visitor.hpp
   ../include/matador/criteria/like_criteria.hpp
   ../include/matador/criteria/logical_criteria.hpp
   ../include/matador/criteria/types.hpp
@@ -13,11 +14,10 @@ SET(SOURCE
   criteria/binary_criteria.cpp
   criteria/collection_criteria.cpp
   criteria/column.cpp
-  criteria/condition_operators.cpp
+  criteria/criteria_operators.cpp
   criteria/like_criteria.cpp
   criteria/logical_criteria.cpp
   criteria/not_criteria.cpp
-  ../include/matador/criteria/criteria.hpp
 )
 
 add_library(matador-criteria STATIC ${SOURCE})

src/criteria/between_criteria.cpp

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

src/criteria/binary_criteria.cpp

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

src/criteria/collection_criteria.cpp

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

src/criteria/criteria_operators.cpp

@@ -1,4 +1,4 @@
-#include "matador/criteria/condition_operators.hpp"
+#include "matador/criteria/criteria_operators.hpp"
 
 #include "matador/criteria/between_criteria.hpp"
 #include "matador/criteria/like_criteria.hpp"
@@ -6,23 +6,23 @@
 #include "matador/criteria/not_criteria.hpp"
 
 namespace matador::criteria {
-condition_node_ptr operator&&(condition_node_ptr left, condition_node_ptr right) {
+criteria_ptr operator&&(criteria_ptr left, criteria_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) {
+criteria_ptr operator||(criteria_ptr left, criteria_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) {
+criteria_ptr operator!(criteria_ptr clause) {
-    return std::make_unique<not_criteria>(std::move(cond));
+    return std::make_unique<not_criteria>(std::move(clause));
 }
 
-condition_node_ptr between(const column &col, value min, value max) {
+criteria_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) {
+criteria_ptr like(const column &col, const std::string &pattern) {
     return std::make_unique<like_criteria>(col, pattern);
 }
 }

src/criteria/like_criteria.cpp

@@ -1,13 +1,13 @@
 #include "matador/criteria/like_criteria.hpp"
 
-#include "matador/criteria/condition_node_visitor.hpp"
+#include "matador/criteria/criteria_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 {
+void like_criteria::accept(criteria_visitor &visitor) const {
   visitor.visit(*this);
 }
 }

src/criteria/logical_criteria.cpp

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

src/criteria/not_criteria.cpp

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