sascha
/
criteria
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

This commit is contained in:
Sascha Kühl 2025-10-19 10:48:56 +02:00
parent 8f4df0d1c8
commit 54d3c3e07a
38 changed files with 372 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -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)

23
include/matador/condition/between_condition_node.hpp
View File

@ -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

31
include/matador/condition/binary_condition_node.hpp
View File

@ -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

27
include/matador/condition/collection_condition_node.hpp
View File

@ -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

20
include/matador/condition/condition_node.hpp
View File

@ -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

24
include/matador/condition/condition_node_visitor.hpp
View File

@ -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

20
include/matador/condition/like_condition_node.hpp
View File

@ -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

25
include/matador/condition/logical_condition_node.hpp
View File

@ -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

18
include/matador/condition/not_condition_node.hpp
View File

@ -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

23
include/matador/criteria/between_criteria.hpp Normal file
View File

@ -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

31
include/matador/criteria/binary_criteria.hpp Normal file
View File

@ -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

27
include/matador/criteria/collection_criteria.hpp Normal file
View File

@ -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

8
include/matador/condition/column.hpp → include/matador/criteria/column.hpp
View File

@ -1,9 +1,9 @@
#ifndef CONDITION_COLUMN_HPP
#define CONDITION_COLUMN_HPP
#ifndef CRITERIA_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

24
include/matador/criteria/condition_node_visitor.hpp Normal file
View File

@ -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

30
include/matador/condition/condition_operators.hpp → include/matador/criteria/condition_operators.hpp
View File

@ -1,40 +1,40 @@
#ifndef CONDITION_CONDITION_OPERATORS_HPP
#define CONDITION_CONDITION_OPERATORS_HPP
#ifndef CRITERIA_CRITERIA_OPERATORS_HPP
#define CRITERIA_CRITERIA_OPERATORS_HPP
#include "matador/condition/binary_condition_node.hpp"
#include "matador/condition/collection_condition_node.hpp"
#include "matador/condition/column.hpp"
#include "matador/criteria/binary_criteria.hpp"
#include "matador/criteria/collection_criteria.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

20
include/matador/criteria/criteria.hpp Normal file
View File

@ -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

20
include/matador/criteria/like_criteria.hpp Normal file
View File

@ -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

25
include/matador/criteria/logical_criteria.hpp Normal file
View File

@ -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

18
include/matador/criteria/not_criteria.hpp Normal file
View File

@ -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

8
include/matador/condition/types.hpp → include/matador/criteria/types.hpp
View File

@ -1,12 +1,12 @@
#ifndef CONDITION_TYPES_HPP
#define CONDITION_TYPES_HPP
#ifndef CRITERIA_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

8
include/matador/condition/value.hpp → include/matador/criteria/value.hpp
View File

@ -1,11 +1,11 @@
#ifndef CONDITION_VALUE_HPP
#define CONDITION_VALUE_HPP
#ifndef CRITERIA_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

42
src/CMakeLists.txt
View File

@ -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)

15
src/condition/between_condition_node.cpp
View File

@ -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);
}
}

15
src/condition/binary_condition_node.cpp
View File

@ -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);
}
}

21
src/condition/collection_condition_node.cpp
View File

@ -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);
}
}

28
src/condition/condition_operators.cpp
View File

@ -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);
}
}

13
src/condition/like_condition_node.cpp
View File

@ -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);
}
}

15
src/condition/logical_condition_node.cpp
View File

@ -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);
}
}

13
src/condition/not_condition_node.cpp
View File

@ -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);
}
}

15
src/criteria/between_criteria.cpp Normal file
View File

@ -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);
}
}

15
src/criteria/binary_criteria.cpp Normal file
View File

@ -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);
}
}

21
src/criteria/collection_criteria.cpp Normal file
View File

@ -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);
}
}

4
src/condition/column.cpp → src/criteria/column.cpp
View File

@ -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)) {}

28
src/criteria/condition_operators.cpp Normal file
View File

@ -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);
}
}

13
src/criteria/like_criteria.cpp Normal file
View File

@ -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);
}
}

15
src/criteria/logical_criteria.cpp Normal file
View File

@ -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);
}
}

13
src/criteria/not_criteria.cpp Normal file
View File

@ -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);
}
}

26
src/main.cpp
View File

@ -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});