From 8ae9966f5dda402a4e8a0afaf28ff8f4d2804a6e Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Sun, 8 Nov 2015 20:07:22 +0100
Subject: [PATCH] Started to migrate integral operators.

Looks good...
---
 include/sqlpp11/basic_expression_operators.h  | 42 +++++++++
 .../data_types/boolean/expression_operators.h |  1 -
 .../integral/expression_operators.h           | 94 +++++++++----------
 include/sqlpp11/expression_return_types.h     | 60 ++++++++++++
 4 files changed, 148 insertions(+), 49 deletions(-)

diff --git a/include/sqlpp11/basic_expression_operators.h b/include/sqlpp11/basic_expression_operators.h
index 5f8e211e..36557303 100644
--- a/include/sqlpp11/basic_expression_operators.h
+++ b/include/sqlpp11/basic_expression_operators.h
@@ -239,6 +239,48 @@ namespace sqlpp
       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::_();
+      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::_();
+      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::_();
+      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::_();
+      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::_();
+      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::_();
+      return {*static_cast<const Expr*>(this)};
+    }
   };
 }
 
diff --git a/include/sqlpp11/data_types/boolean/expression_operators.h b/include/sqlpp11/data_types/boolean/expression_operators.h
index 1e890b3e..41b946bd 100644
--- a/include/sqlpp11/data_types/boolean/expression_operators.h
+++ b/include/sqlpp11/data_types/boolean/expression_operators.h
@@ -27,7 +27,6 @@
 #ifndef SQLPP_BOOLEAN_EXPRESSION_OPERATORS_H
 #define SQLPP_BOOLEAN_EXPRESSION_OPERATORS_H
 
-//#include <sqlpp11/operators.h>
 #include <sqlpp11/expression_return_types.h>
 #include <sqlpp11/operand_check.h>
 #include <sqlpp11/expression_operators.h>
diff --git a/include/sqlpp11/data_types/integral/expression_operators.h b/include/sqlpp11/data_types/integral/expression_operators.h
index 2cfe3be9..ff41a908 100644
--- a/include/sqlpp11/data_types/integral/expression_operators.h
+++ b/include/sqlpp11/data_types/integral/expression_operators.h
@@ -27,6 +27,8 @@
 #ifndef SQLPP_INTEGRAL_EXPRESSION_OPERATORS_H
 #define SQLPP_INTEGRAL_EXPRESSION_OPERATORS_H
 
+#include <sqlpp11/expression_return_types.h>
+#include <sqlpp11/operand_check.h>
 #include <sqlpp11/expression_operators.h>
 #include <sqlpp11/basic_expression_operators.h>
 #include <sqlpp11/value_type.h>
@@ -35,84 +37,80 @@
 
 namespace sqlpp
 {
-  template <typename Base>
-  struct expression_operators<Base, integral> : public basic_expression_operators<Base, integral>
+  template <typename Expression>
+  struct expression_operators<Expression, integral> : public basic_expression_operators<Expression, integral>
   {
     template <typename T>
     using _is_valid_operand = is_valid_operand<integral, T>;
 
     template <typename T>
-    plus_t<Base, value_type_t<T>, wrap_operand_t<T>> operator+(T t) const
+    modulus_t<Expression, wrap_operand_t<T>> operator%(T t) const
     {
       using rhs = wrap_operand_t<T>;
       static_assert(_is_valid_operand<rhs>::value, "invalid rhs operand");
 
-      return {*static_cast<const Base*>(this), {t}};
+      return {*static_cast<const Expression*>(this), {t}};
     }
 
     template <typename T>
-    minus_t<Base, value_type_t<T>, wrap_operand_t<T>> operator-(T t) const
+    bitwise_and_t<Expression, value_type_t<T>, wrap_operand_t<T>> operator&(T t) const
     {
       using rhs = wrap_operand_t<T>;
       static_assert(_is_valid_operand<rhs>::value, "invalid rhs operand");
 
-      return {*static_cast<const Base*>(this), {t}};
+      return {*static_cast<const Expression*>(this), {t}};
     }
 
     template <typename T>
-    multiplies_t<Base, value_type_t<T>, wrap_operand_t<T>> operator*(T t) const
+    bitwise_or_t<Expression, value_type_t<T>, wrap_operand_t<T>> operator|(T t) const
     {
       using rhs = wrap_operand_t<T>;
       static_assert(_is_valid_operand<rhs>::value, "invalid rhs operand");
 
-      return {*static_cast<const Base*>(this), {t}};
+      return {*static_cast<const Expression*>(this), {t}};
     }
+  };
 
-    template <typename T>
-    divides_t<Base, wrap_operand_t<T>> operator/(T t) const
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs operand");
+  template <typename L, typename R>
+  struct return_type_plus<L, R, binary_operand_check_t<L, is_integral_t, R, is_numeric_t>>
+  {
+    using check = consistent_t;
+    using type = plus_t<wrap_operand_t<L>, value_type_of<wrap_operand_t<R>>, wrap_operand_t<R>>;
+  };
 
-      return {*static_cast<const Base*>(this), {t}};
-    }
+  template <typename L, typename R>
+  struct return_type_minus<L, R, binary_operand_check_t<L, is_integral_t, R, is_numeric_t>>
+  {
+    using check = consistent_t;
+    using type = minus_t<wrap_operand_t<L>, value_type_of<wrap_operand_t<R>>, wrap_operand_t<R>>;
+  };
 
-    template <typename T>
-    modulus_t<Base, wrap_operand_t<T>> operator%(T t) const
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs operand");
+  template <typename L, typename R>
+  struct return_type_multiplies<L, R, binary_operand_check_t<L, is_integral_t, R, is_numeric_t>>
+  {
+    using check = consistent_t;
+    using type = multiplies_t<wrap_operand_t<L>, value_type_of<wrap_operand_t<R>>, wrap_operand_t<R>>;
+  };
 
-      return {*static_cast<const Base*>(this), {t}};
-    }
+  template <typename L, typename R>
+  struct return_type_divides<L, R, binary_operand_check_t<L, is_integral_t, R, is_numeric_t>>
+  {
+    using check = consistent_t;
+    using type = divides_t<wrap_operand_t<L>, wrap_operand_t<R>>;
+  };
 
-    unary_plus_t<integral, Base> operator+() const
-    {
-      return {*static_cast<const Base*>(this)};
-    }
+  template <typename T, typename Defer>
+  struct return_type_unary_plus<T, Defer, unary_operand_check_t<T, is_integral_t>>
+  {
+    using check = consistent_t;
+    using type = unary_plus_t<integral, wrap_operand_t<T>>;
+  };
 
-    unary_minus_t<integral, Base> operator-() const
-    {
-      return {*static_cast<const Base*>(this)};
-    }
-
-    template <typename T>
-    bitwise_and_t<Base, value_type_t<T>, wrap_operand_t<T>> operator&(T t) const
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs operand");
-
-      return {*static_cast<const Base*>(this), {t}};
-    }
-
-    template <typename T>
-    bitwise_or_t<Base, value_type_t<T>, wrap_operand_t<T>> operator|(T t) const
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs operand");
-
-      return {*static_cast<const Base*>(this), {t}};
-    }
+  template <typename T, typename Defer>
+  struct return_type_unary_minus<T, Defer, unary_operand_check_t<T, is_integral_t>>
+  {
+    using check = consistent_t;
+    using type = unary_minus_t<integral, wrap_operand_t<T>>;
   };
 }
 #endif
diff --git a/include/sqlpp11/expression_return_types.h b/include/sqlpp11/expression_return_types.h
index 43f31ae4..dc64eaea 100644
--- a/include/sqlpp11/expression_return_types.h
+++ b/include/sqlpp11/expression_return_types.h
@@ -60,6 +60,66 @@ namespace sqlpp
 
   template <typename T, typename Defer>
   using return_type_not_t = typename return_type_not<T, Defer>::type;
+
+  template <typename L, typename R, typename Enable = void>
+  struct return_type_plus
+  {
+    using check = assert_valid_operands;
+    using type = bad_expression<boolean>;
+  };
+
+  template <typename L, typename R>
+  using return_type_plus_t = typename return_type_plus<L, R>::type;
+
+  template <typename L, typename R, typename Enable = void>
+  struct return_type_minus
+  {
+    using check = assert_valid_operands;
+    using type = bad_expression<boolean>;
+  };
+
+  template <typename L, typename R>
+  using return_type_minus_t = typename return_type_minus<L, R>::type;
+
+  template <typename L, typename R, typename Enable = void>
+  struct return_type_multiplies
+  {
+    using check = assert_valid_operands;
+    using type = bad_expression<boolean>;
+  };
+
+  template <typename L, typename R>
+  using return_type_multiplies_t = typename return_type_multiplies<L, R>::type;
+
+  template <typename L, typename R, typename Enable = void>
+  struct return_type_divides
+  {
+    using check = assert_valid_operands;
+    using type = bad_expression<boolean>;
+  };
+
+  template <typename L, typename R>
+  using return_type_divides_t = typename return_type_divides<L, R>::type;
+
+  template <typename T, typename Defer, typename Enable = void>
+  struct return_type_unary_plus
+  {
+    using check = assert_valid_operands;
+    using type = bad_expression<boolean>;
+  };
+
+  template <typename T, typename Defer>
+  using return_type_unary_plus_t = typename return_type_unary_plus<T, Defer>::type;
+
+  template <typename T, typename Defer, typename Enable = void>
+  struct return_type_unary_minus
+  {
+    using check = assert_valid_operands;
+    using type = bad_expression<boolean>;
+  };
+
+  template <typename T, typename Defer>
+  using return_type_unary_minus_t = typename return_type_unary_minus<T, Defer>::type;
 }
 
 #endif