83 lines
2.3 KiB
C++
83 lines
2.3 KiB
C++
#pragma once
|
|
|
|
#include <tuple>
|
|
#include <utility> // std::move, std::forward
|
|
#include "functional/cxx_optional.h"
|
|
|
|
#include "functional/cxx_universal.h"
|
|
#include "operators.h"
|
|
|
|
namespace sqlite_orm {
|
|
|
|
namespace internal {
|
|
|
|
template<class L, class R>
|
|
struct and_condition_t;
|
|
|
|
template<class L, class R>
|
|
struct or_condition_t;
|
|
|
|
/**
|
|
* Is not an operator but a result of c(...) function. Has operator= overloaded which returns assign_t
|
|
*/
|
|
template<class T>
|
|
struct expression_t : condition_t {
|
|
T value;
|
|
|
|
expression_t(T value_) : value(std::move(value_)) {}
|
|
|
|
template<class R>
|
|
assign_t<T, R> operator=(R r) const {
|
|
return {this->value, std::move(r)};
|
|
}
|
|
|
|
assign_t<T, nullptr_t> operator=(nullptr_t) const {
|
|
return {this->value, nullptr};
|
|
}
|
|
#ifdef SQLITE_ORM_OPTIONAL_SUPPORTED
|
|
assign_t<T, std::nullopt_t> operator=(std::nullopt_t) const {
|
|
return {this->value, std::nullopt};
|
|
}
|
|
#endif
|
|
template<class... Args>
|
|
in_t<T, Args...> in(Args... args) const {
|
|
return {this->value, std::make_tuple(std::forward<Args>(args)...), false};
|
|
}
|
|
|
|
template<class... Args>
|
|
in_t<T, Args...> not_in(Args... args) const {
|
|
return {this->value, std::make_tuple(std::forward<Args>(args)...), true};
|
|
}
|
|
|
|
template<class R>
|
|
and_condition_t<T, R> and_(R right) const {
|
|
return {this->value, std::move(right)};
|
|
}
|
|
|
|
template<class R>
|
|
or_condition_t<T, R> or_(R right) const {
|
|
return {this->value, std::move(right)};
|
|
}
|
|
};
|
|
|
|
template<class T>
|
|
T get_from_expression(T value) {
|
|
return std::move(value);
|
|
}
|
|
|
|
template<class T>
|
|
T get_from_expression(expression_t<T> expression) {
|
|
return std::move(expression.value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Public interface for syntax sugar for columns. Example: `where(c(&User::id) == 5)` or
|
|
* `storage.update(set(c(&User::name) = "Dua Lipa"));
|
|
*/
|
|
template<class T>
|
|
internal::expression_t<T> c(T value) {
|
|
return {std::move(value)};
|
|
}
|
|
}
|