3party/sqlpp11
0
0
Fork 0
mirror of https://github.com/rbock/sqlpp11.git synced 2024-11-15 20:31:16 +08:00
Code Issues Projects Releases Wiki Activity

Use count instead of is_element_of

Browse Source
This commit is contained in:
rbock 2017-10-29 16:39:51 +01:00
parent f3b915cdc9
commit e1b82afbbe
7 changed files with 49 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/sqlpp11/cte.h
View File

@ -167,7 +167,7 @@ namespace sqlpp
using _parameters = parameters_of<Statement>;
using _alias_t = typename AliasProvider::_alias_t;
constexpr static bool _is_recursive = detail::is_element_of<AliasProvider, required_ctes_of<Statement>>::value;
constexpr static bool _is_recursive = required_ctes_of<Statement>::template count<AliasProvider>();
using _column_tuple_t = std::tuple<column_t<AliasProvider, cte_column_spec_t<FieldSpecs>>...>;
@ -261,7 +261,7 @@ namespace sqlpp
{
static_assert(required_tables_of<Statement>::size::value == 0,
"common table expression must not use unknown tables");
static_assert(not detail::is_element_of<AliasProvider, required_ctes_of<Statement>>::value,
static_assert(not required_ctes_of<Statement>::template count<AliasProvider>(),
"common table expression must not self-reference in the first part, use union_all/union_distinct "
"for recursion");
static_assert(is_static_result_row_t<get_result_row_t<Statement>>::value,

32
include/sqlpp11/detail/type_set.h
View File

@ -45,29 +45,41 @@ namespace sqlpp
template <typename E, typename SET>
struct is_element_of;
template <typename T>
struct _base
{
};
// A type set
template <typename... Elements>
struct type_set
{
private:
struct _impl : _base<Elements>...
{
};
public:
using size = std::integral_constant<size_t, sizeof...(Elements)>;
using _is_type_set = std::true_type;
static_assert(std::is_same<type_set, make_type_set_t<Elements...>>::value,
"use make_type_set to construct a typeset");
template <typename T>
static constexpr bool count()
{
return std::is_base_of<_base<T>, _impl>::value;
}
template <typename T>
struct insert
{
using type =
typename std::conditional<not is_element_of<T, type_set>::value, type_set<T, Elements...>, type_set>::type;
using type = typename std::conditional<count<T>(), type_set, type_set<T, Elements...>>::type;
};
template <template <typename A> class Predicate, typename T>
struct insert_if
{
using type = typename std::conditional<Predicate<T>::value and not is_element_of<T, type_set>::value,
type_set<Elements..., T>,
type_set>::type;
using type =
typename std::conditional<Predicate<T>::value and not count<T>(), type_set<Elements..., T>, type_set>::type;
};
};
@ -80,7 +92,7 @@ namespace sqlpp
template <typename E, typename... Elements>
struct is_element_of<E, type_set<Elements...>>
{
static constexpr bool value = ::sqlpp::logic::any_t<std::is_same<E, Elements>::value...>::value;
static constexpr bool value = type_set<Elements...>::template count<E>();
};
template <typename L, typename R>
@ -224,8 +236,8 @@ namespace sqlpp
struct make_intersect_set<type_set<LhsElements...>, type_set<RhsElements...>>
{
template <typename E>
using is_in_both = ::sqlpp::logic::all_t<is_element_of<E, type_set<LhsElements...>>::value,
is_element_of<E, type_set<RhsElements...>>::value>;
using is_in_both = ::sqlpp::logic::all_t<type_set<LhsElements...>::template count<E>(),
type_set<RhsElements...>::template count<E>()>;
using type = make_type_set_if_t<is_in_both, LhsElements...>;
};

2
include/sqlpp11/insert_value_list.h
View File

@ -256,7 +256,7 @@ namespace sqlpp
static_assert(_is_dynamic::value, "add must not be called for static from()");
static_assert(is_assignment_t<Assignment>::value, "add() arguments require to be assigments");
using _assigned_columns = detail::make_type_set_t<lhs_t<Assignments>...>;
static_assert(not detail::is_element_of<lhs_t<Assignment>, _assigned_columns>::value,
static_assert(not _assigned_columns::template count<lhs_t<Assignment>>(),
"Must not assign value to column twice");
static_assert(not must_not_insert_t<lhs_t<Assignment>>::value, "add() argument must not be used in insert");
static_assert(Policies::template _no_unknown_tables<Assignment>::value,

2
include/sqlpp11/select_column_list.h
View File

@ -132,7 +132,7 @@ namespace sqlpp
static_assert(Policies::template _no_unknown_tables<named_expression>::value,
"named expression uses tables unknown to this statement in selected_columns::add()");
using column_names = detail::make_type_set_t<typename Columns::_alias_t...>;
static_assert(not detail::is_element_of<typename named_expression::_alias_t, column_names>::value,
static_assert(not column_names::template count<typename named_expression::_alias_t>(),
"a column of this name is present in the select already");
using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, named_expression>;
_serialize_check{};

2
include/sqlpp11/statement.h
View File

@ -69,7 +69,7 @@ namespace sqlpp
template <typename Needle, typename Replacement>
struct _policies_update_t
{
static_assert(detail::is_element_of<Needle, make_type_set_t<Policies...>>::value,
static_assert(make_type_set_t<Policies...>::template count<Needle>(),
"policies update for non-policy class detected");
using type = statement_t<Db, policy_update_t<Policies, Needle, Replacement>...>;
};

44
include/sqlpp11/type_traits.h
View File

@ -124,7 +124,7 @@ namespace sqlpp
template <typename T>
struct column_spec_can_be_null_impl<
T,
typename std::enable_if<detail::is_element_of<tag::can_be_null, typename T::_traits::_tags>::value>::type>
typename std::enable_if<T::_traits::_tags::template count<tag::can_be_null>()>::type>
{
using type = std::true_type;
};
@ -132,27 +132,25 @@ namespace sqlpp
template <typename T>
using column_spec_can_be_null_t = typename detail::column_spec_can_be_null_impl<T>::type;
#define SQLPP_VALUE_TRAIT_GENERATOR(name) \
namespace tag \
{ \
struct name; \
} \
namespace detail \
{ \
template <typename T, typename Enable = void> \
struct name##_impl \
{ \
using type = std::false_type; \
}; \
template <typename T> \
struct name##_impl< \
T, \
typename std::enable_if<detail::is_element_of<tag::name, typename T::_traits::_tags>::value>::type> \
{ \
using type = std::true_type; \
}; \
} \
template <typename T> \
#define SQLPP_VALUE_TRAIT_GENERATOR(name) \
namespace tag \
{ \
struct name; \
} \
namespace detail \
{ \
template <typename T, typename Enable = void> \
struct name##_impl \
{ \
using type = std::false_type; \
}; \
template <typename T> \
struct name##_impl<T, typename std::enable_if<T::_traits::_tags::template count<tag::name>()>::type> \
{ \
using type = std::true_type; \
}; \
} \
template <typename T> \
using name##_t = typename detail::name##_impl<T>::type;
SQLPP_VALUE_TRAIT_GENERATOR(is_sql_null)
@ -326,7 +324,7 @@ namespace sqlpp
template <typename KnownAggregates, typename T>
struct is_aggregate_expression_impl<KnownAggregates,
T,
typename std::enable_if<detail::is_element_of<T, KnownAggregates>::value>::type>
typename std::enable_if<KnownAggregates::template count<T>()>::type>
{
using type = std::true_type;
};

2
include/sqlpp11/update_list.h
View File

@ -83,7 +83,7 @@ namespace sqlpp
static_assert(_is_dynamic::value, "add must not be called for static from()");
static_assert(is_assignment_t<Assignment>::value, "invalid assignment argument in add()");
using _assigned_columns = detail::make_type_set_t<lhs_t<Assignments>...>;
static_assert(not detail::is_element_of<lhs_t<Assignment>, _assigned_columns>::value,
static_assert(not _assigned_columns::template count<lhs_t<Assignment>>(),
"Must not assign value to column twice");
static_assert(logic::not_t<must_not_update_t, lhs_t<Assignment>>::value, "add() argument must not be updated");
static_assert(Policies::template _no_unknown_tables<Assignment>::value,