Use count instead of is_element_of

include/sqlpp11/cte.h

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

include/sqlpp11/detail/type_set.h

@@ -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,
+      template <typename T>
-                    "use make_type_set to construct a typeset");
+      static constexpr bool count()
+      {
+        return std::is_base_of<_base<T>, _impl>::value;
+      }
 
       template <typename T>
       struct insert
       {
-        using type =
+        using type = typename std::conditional<count<T>(), type_set, type_set<T, Elements...>>::type;
-            typename std::conditional<not is_element_of<T, type_set>::value, type_set<T, Elements...>, type_set>::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,
+        using type =
-                                               type_set<Elements..., T>,
+            typename std::conditional<Predicate<T>::value and not count<T>(), type_set<Elements..., T>, type_set>::type;
-                                               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,
+      using is_in_both = ::sqlpp::logic::all_t<type_set<LhsElements...>::template count<E>(),
-                                               is_element_of<E, type_set<RhsElements...>>::value>;
+                                               type_set<RhsElements...>::template count<E>()>;
       using type = make_type_set_if_t<is_in_both, LhsElements...>;
     };
 

include/sqlpp11/insert_value_list.h

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

include/sqlpp11/select_column_list.h

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

include/sqlpp11/statement.h

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

include/sqlpp11/type_traits.h

@@ -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;
     };
@@ -145,9 +145,7 @@ namespace sqlpp
       using type = std::false_type;                                                                      \
     };                                                                                                   \
     template <typename T>                                                                                \
-    struct name##_impl<                                                                                     \
+    struct name##_impl<T, typename std::enable_if<T::_traits::_tags::template count<tag::name>()>::type> \
-        T,                                                                                                  \
-        typename std::enable_if<detail::is_element_of<tag::name, typename T::_traits::_tags>::value>::type> \
     {                                                                                                    \
       using type = std::true_type;                                                                       \
     };                                                                                                   \
@@ -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;
     };

include/sqlpp11/update_list.h

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