From e1b82afbbeb92363666ecfc20f2360ccd8d0d44f Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Sun, 29 Oct 2017 16:39:51 +0100
Subject: [PATCH] Use count instead of is_element_of

---
 include/sqlpp11/cte.h                |  4 +--
 include/sqlpp11/detail/type_set.h    | 32 +++++++++++++-------
 include/sqlpp11/insert_value_list.h  |  2 +-
 include/sqlpp11/select_column_list.h |  2 +-
 include/sqlpp11/statement.h          |  2 +-
 include/sqlpp11/type_traits.h        | 44 +++++++++++++---------------
 include/sqlpp11/update_list.h        |  2 +-
 7 files changed, 49 insertions(+), 39 deletions(-)

diff --git a/include/sqlpp11/cte.h b/include/sqlpp11/cte.h
index 95cca8d3..cd1b5f11 100644
--- a/include/sqlpp11/cte.h
+++ b/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,
diff --git a/include/sqlpp11/detail/type_set.h b/include/sqlpp11/detail/type_set.h
index ebbb2293..16fdce03 100644
--- a/include/sqlpp11/detail/type_set.h
+++ b/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,
-                    "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...>;
     };
 
diff --git a/include/sqlpp11/insert_value_list.h b/include/sqlpp11/insert_value_list.h
index 1eb29bf2..6269b1cd 100644
--- a/include/sqlpp11/insert_value_list.h
+++ b/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,
diff --git a/include/sqlpp11/select_column_list.h b/include/sqlpp11/select_column_list.h
index 2f87a770..c10a3858 100644
--- a/include/sqlpp11/select_column_list.h
+++ b/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{};
diff --git a/include/sqlpp11/statement.h b/include/sqlpp11/statement.h
index 8cc4396b..89d903d8 100644
--- a/include/sqlpp11/statement.h
+++ b/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>...>;
       };
diff --git a/include/sqlpp11/type_traits.h b/include/sqlpp11/type_traits.h
index 4f0a2051..4a8384fd 100644
--- a/include/sqlpp11/type_traits.h
+++ b/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;
     };
@@ -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;
     };
diff --git a/include/sqlpp11/update_list.h b/include/sqlpp11/update_list.h
index b9b986f2..768f9d13 100644
--- a/include/sqlpp11/update_list.h
+++ b/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,