From ac500e238de06294e6f31258396066e61a050b2b Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Sat, 28 Apr 2018 10:15:26 +0200
Subject: [PATCH] Fix triggering static asserts multiple operators

---
 include/sqlpp11/basic_expression_operators.h  | 40 +++++++++----------
 include/sqlpp11/consistent.h                  |  1 -
 .../data_types/blob/expression_operators.h    |  4 +-
 .../data_types/text/expression_operators.h    |  2 +-
 4 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/include/sqlpp11/basic_expression_operators.h b/include/sqlpp11/basic_expression_operators.h
index f4665b73..c924f964 100644
--- a/include/sqlpp11/basic_expression_operators.h
+++ b/include/sqlpp11/basic_expression_operators.h
@@ -127,7 +127,7 @@ namespace sqlpp
     auto operator==(T t) const -> _new_binary_expression_t<equal_to_t, T>
     {
       using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::_();
+      check_comparison_t<Expr, rhs>{};
 
       return {*static_cast<const Expr*>(this), rhs{t}};
     }
@@ -136,7 +136,7 @@ namespace sqlpp
     auto operator!=(T t) const -> _new_binary_expression_t<not_equal_to_t, T>
     {
       using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::_();
+      check_comparison_t<Expr, rhs>{};
 
       return {*static_cast<const Expr*>(this), rhs{t}};
     }
@@ -145,7 +145,7 @@ namespace sqlpp
     auto operator<(T t) const -> _new_binary_expression_t<less_than_t, T>
     {
       using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::_();
+      check_comparison_t<Expr, rhs>{};
 
       return {*static_cast<const Expr*>(this), rhs{t}};
     }
@@ -154,7 +154,7 @@ namespace sqlpp
     auto operator<=(T t) const -> _new_binary_expression_t<less_equal_t, T>
     {
       using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::_();
+      check_comparison_t<Expr, rhs>{};
 
       return {*static_cast<const Expr*>(this), rhs{t}};
     }
@@ -163,7 +163,7 @@ namespace sqlpp
     auto operator>(T t) const -> _new_binary_expression_t<greater_than_t, T>
     {
       using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::_();
+      check_comparison_t<Expr, rhs>{};
 
       return {*static_cast<const Expr*>(this), rhs{t}};
     }
@@ -172,7 +172,7 @@ namespace sqlpp
     auto operator>=(T t) const -> _new_binary_expression_t<greater_equal_t, T>
     {
       using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::_();
+      check_comparison_t<Expr, rhs>{};
 
       return {*static_cast<const Expr*>(this), rhs{t}};
     }
@@ -205,98 +205,98 @@ namespace sqlpp
     template <typename... T>
     auto in(T... t) const -> typename _new_nary_expression<in_t, T...>::type
     {
-      check_in_t<Expr, wrap_operand_t<T>...>::_();
+      check_in_t<Expr, wrap_operand_t<T>...>{};
       return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...};
     }
 
     template <typename... T>
     auto not_in(T... t) const -> typename _new_nary_expression<not_in_t, T...>::type
     {
-      check_in_t<Expr, wrap_operand_t<T>...>::_();
+      check_in_t<Expr, wrap_operand_t<T>...>{};
       return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...};
     }
 
     template <typename Defer = void>
     auto operator not() const -> return_type_not_t<Expr, Defer>
     {
-      return_type_not<Expr, Defer>::check::_();
+      typename return_type_not<Expr, Defer>::check{};
       return {*static_cast<const Expr*>(this)};
     }
 
     template <typename R>
     auto operator and(const R& r) const -> return_type_and_t<Expr, R>
     {
-      return_type_and<Expr, R>::check::_();
+      typename return_type_and<Expr, R>::check{};
       return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
     }
 
     template <typename R>
     auto operator&(const R& r) const -> return_type_bitwise_and_t<Expr, R>
     {
-      return_type_bitwise_and<Expr, R>::check::_();
+      typename return_type_bitwise_and<Expr, R>::check{};
       return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
     }
 
     template <typename R>
     auto operator|(const R& r) const -> return_type_bitwise_or_t<Expr, R>
     {
-      return_type_bitwise_or<Expr, R>::check::_();
+      typename return_type_bitwise_or<Expr, R>::check{};
       return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
     }
 
     template <typename R>
     auto operator or(const R& r) const -> return_type_or_t<Expr, R>
     {
-      return_type_or<Expr, R>::check::_();
+      typename return_type_or<Expr, R>::check{};
       return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
     }
 
     template <typename R>
     auto operator+(const R& r) const -> return_type_plus_t<Expr, R>
     {
-      return_type_plus<Expr, R>::check::_();
+      typename return_type_plus<Expr, R>::check{};
       return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
     }
 
     template <typename R>
     auto operator-(const R& r) const -> return_type_minus_t<Expr, R>
     {
-      return_type_minus<Expr, R>::check::_();
+      typename return_type_minus<Expr, R>::check{};
       return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
     }
 
     template <typename R>
     auto operator*(const R& r) const -> return_type_multiplies_t<Expr, R>
     {
-      return_type_multiplies<Expr, R>::check::_();
+      typename return_type_multiplies<Expr, R>::check{};
       return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
     }
 
     template <typename R>
     auto operator/(const R& r) const -> return_type_divides_t<Expr, R>
     {
-      return_type_divides<Expr, R>::check::_();
+      typename return_type_divides<Expr, R>::check{};
       return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
     }
 
     template <typename R>
     auto operator%(const R& r) const -> return_type_modulus_t<Expr, R>
     {
-      return_type_modulus<Expr, R>::check::_();
+      typename return_type_modulus<Expr, R>::check{};
       return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
     }
 
     template <typename Defer = void>
     auto operator+() const -> return_type_unary_plus_t<Expr, Defer>
     {
-      return_type_unary_plus<Expr, Defer>::check::_();
+      typename return_type_unary_plus<Expr, Defer>::check{};
       return {*static_cast<const Expr*>(this)};
     }
 
     template <typename Defer = void>
     auto operator-() const -> return_type_unary_minus_t<Expr, Defer>
     {
-      return_type_unary_minus<Expr, Defer>::check::_();
+      typename return_type_unary_minus<Expr, Defer>::check{};
       return {*static_cast<const Expr*>(this)};
     }
   };
diff --git a/include/sqlpp11/consistent.h b/include/sqlpp11/consistent.h
index 6dbc8eb9..0b38593c 100644
--- a/include/sqlpp11/consistent.h
+++ b/include/sqlpp11/consistent.h
@@ -33,7 +33,6 @@ namespace sqlpp
 {
   struct consistent_t : std::true_type
   {
-    static void _(){};
   };
 }  // namespace sqlpp
 
diff --git a/include/sqlpp11/data_types/blob/expression_operators.h b/include/sqlpp11/data_types/blob/expression_operators.h
index 8065ca4e..210c57f6 100644
--- a/include/sqlpp11/data_types/blob/expression_operators.h
+++ b/include/sqlpp11/data_types/blob/expression_operators.h
@@ -62,9 +62,9 @@ namespace sqlpp
     template <typename R>
     auto like(const R& r) const -> return_type_like_t<Expression, R>
     {
-      return_type_like<Expression, R>::check::_();
+      typename return_type_like<Expression, R>::check{};
       return {*static_cast<const Expression*>(this), wrap_operand_t<R>{r}};
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/text/expression_operators.h b/include/sqlpp11/data_types/text/expression_operators.h
index ea40f697..440ce546 100644
--- a/include/sqlpp11/data_types/text/expression_operators.h
+++ b/include/sqlpp11/data_types/text/expression_operators.h
@@ -57,7 +57,7 @@ namespace sqlpp
     template <typename R>
     auto like(const R& r) const -> return_type_like_t<Expression, R>
     {
-      return_type_like<Expression, R>::check::_();
+      typename return_type_like<Expression, R>::check{};
       return {*static_cast<const Expression*>(this), wrap_operand_t<R>{r}};
     }
   };