Added the "unary minus" operator

fnc12 · Jul 23, 2024 · dd2040e · dd2040e
1 parent 766861e
commit dd2040e
Show file tree

Hide file tree

Showing 10 changed files with 120 additions and 17 deletions.
diff --git a/dev/column_result.h b/dev/column_result.h
@@ -149,6 +149,11 @@ namespace sqlite_orm {
             using type = std::string;
         };
 
+        template<class DBOs, class T>
+        struct column_result_t<DBOs, unary_minus_t<T>, void> {
+            using type = double;
+        };
+
         template<class DBOs, class L, class R>
         struct column_result_t<DBOs, add_t<L, R>, void> {
             using type = double;

diff --git a/dev/core_functions.h b/dev/core_functions.h
@@ -2041,6 +2041,14 @@ namespace sqlite_orm {
     // Intentionally place operators for types classified as arithmetic or general operator arguments in the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
+        template<
+            class T,
+            std::enable_if_t<polyfill::disjunction<std::is_base_of<arithmetic_t, T>, is_operator_argument<T>>::value,
+                             bool> = true>
+        constexpr unary_minus_t<unwrap_expression_t<T>> operator-(T arg) {
+            return {get_from_expression(std::forward<T>(arg))};
+        }
+
         template<class L,
                  class R,
                  std::enable_if_t<polyfill::disjunction<std::is_base_of<arithmetic_t, L>,

diff --git a/dev/node_tuple.h b/dev/node_tuple.h
@@ -199,6 +199,9 @@ namespace sqlite_orm {
         template<class C>
         struct node_tuple<negated_condition_t<C>, void> : node_tuple<C> {};
 
+        template<class T>
+        struct node_tuple<unary_minus_t<T>, void> : node_tuple<T> {};
+
         template<class T>
         struct node_tuple<bitwise_not_t<T>, void> : node_tuple<T> {};
 

diff --git a/dev/operators.h b/dev/operators.h
@@ -41,6 +41,24 @@ namespace sqlite_orm {
         template<class L, class R>
         using conc_t = binary_operator<L, R, conc_string>;
 
+        struct unary_minus_string {
+            serialize_result_type serialize() const {
+                return "-";
+            }
+        };
+
+        /**
+         *  Result of unary minus - operator
+         */
+        template<class T>
+        struct unary_minus_t : unary_minus_string, arithmetic_t, negatable_t {
+            using argument_type = T;
+
+            argument_type argument;
+
+            unary_minus_t(argument_type argument_) : argument(std::move(argument_)) {}
+        };
+
         struct add_string {
             serialize_result_type serialize() const {
                 return "+";
@@ -60,7 +78,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Result of substitute - operator
+         *  Result of substraction - operator
          */
         template<class L, class R>
         using sub_t = binary_operator<L, R, sub_string, arithmetic_t, negatable_t>;
@@ -201,6 +219,11 @@ namespace sqlite_orm {
         return {std::move(l), std::move(r)};
     }
 
+    template<class T>
+    constexpr internal::unary_minus_t<T> minus(T t) {
+        return {std::move(t)};
+    }
+
     /**
      *  Public interface for + operator. Example: `select(add(&User::age, 100));` => SELECT age + 100 FROM users
      */

diff --git a/dev/statement_serializer.h b/dev/statement_serializer.h
@@ -718,8 +718,11 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct statement_serializer<bitwise_not_t<T>, void> {
-            using statement_type = bitwise_not_t<T>;
+        struct statement_serializer<
+            T,
+            std::enable_if_t<polyfill::disjunction<polyfill::is_specialization_of<T, unary_minus_t>,
+                                                   polyfill::is_specialization_of<T, bitwise_not_t>>::value>> {
+            using statement_type = T;
 
             template<class Ctx>
             std::string operator()(const statement_type& expression, const Ctx& context) const {

diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
@@ -4168,6 +4168,24 @@ namespace sqlite_orm {
         template<class L, class R>
         using conc_t = binary_operator<L, R, conc_string>;
 
+        struct unary_minus_string {
+            serialize_result_type serialize() const {
+                return "-";
+            }
+        };
+
+        /**
+         *  Result of unary minus - operator
+         */
+        template<class T>
+        struct unary_minus_t : unary_minus_string, arithmetic_t, negatable_t {
+            using argument_type = T;
+
+            argument_type argument;
+
+            unary_minus_t(argument_type argument_) : argument(std::move(argument_)) {}
+        };
+
         struct add_string {
             serialize_result_type serialize() const {
                 return "+";
@@ -4187,7 +4205,7 @@ namespace sqlite_orm {
         };
 
         /**
-         *  Result of substitute - operator
+         *  Result of substraction - operator
          */
         template<class L, class R>
         using sub_t = binary_operator<L, R, sub_string, arithmetic_t, negatable_t>;
@@ -4328,6 +4346,11 @@ namespace sqlite_orm {
         return {std::move(l), std::move(r)};
     }
 
+    template<class T>
+    constexpr internal::unary_minus_t<T> minus(T t) {
+        return {std::move(t)};
+    }
+
     /**
      *  Public interface for + operator. Example: `select(add(&User::age, 100));` => SELECT age + 100 FROM users
      */
@@ -8091,6 +8114,14 @@ namespace sqlite_orm {
     // Intentionally place operators for types classified as arithmetic or general operator arguments in the internal namespace
     // to facilitate ADL (Argument Dependent Lookup)
     namespace internal {
+        template<
+            class T,
+            std::enable_if_t<polyfill::disjunction<std::is_base_of<arithmetic_t, T>, is_operator_argument<T>>::value,
+                             bool> = true>
+        constexpr unary_minus_t<unwrap_expression_t<T>> operator-(T arg) {
+            return {get_from_expression(std::forward<T>(arg))};
+        }
+
         template<class L,
                  class R,
                  std::enable_if_t<polyfill::disjunction<std::is_base_of<arithmetic_t, L>,
@@ -11474,6 +11505,11 @@ namespace sqlite_orm {
             using type = std::string;
         };
 
+        template<class DBOs, class T>
+        struct column_result_t<DBOs, unary_minus_t<T>, void> {
+            using type = double;
+        };
+
         template<class DBOs, class L, class R>
         struct column_result_t<DBOs, add_t<L, R>, void> {
             using type = double;
@@ -19941,8 +19977,11 @@ namespace sqlite_orm {
         };
 
         template<class T>
-        struct statement_serializer<bitwise_not_t<T>, void> {
-            using statement_type = bitwise_not_t<T>;
+        struct statement_serializer<
+            T,
+            std::enable_if_t<polyfill::disjunction<polyfill::is_specialization_of<T, unary_minus_t>,
+                                                   polyfill::is_specialization_of<T, bitwise_not_t>>::value>> {
+            using statement_type = T;
 
             template<class Ctx>
             std::string operator()(const statement_type& expression, const Ctx& context) const {
@@ -24287,6 +24326,9 @@ namespace sqlite_orm {
         template<class C>
         struct node_tuple<negated_condition_t<C>, void> : node_tuple<C> {};
 
+        template<class T>
+        struct node_tuple<unary_minus_t<T>, void> : node_tuple<T> {};
+
         template<class T>
         struct node_tuple<bitwise_not_t<T>, void> : node_tuple<T> {};
 

diff --git a/tests/statement_serializer_tests/arithmetic_operators.cpp b/tests/statement_serializer_tests/arithmetic_operators.cpp
@@ -8,6 +8,15 @@ TEST_CASE("statement_serializer arithmetic operators") {
     internal::serializer_context<internal::db_objects_tuple<>> context{storage};
     std::string value;
     decltype(value) expected;
+    SECTION("unary minus") {
+        SECTION("func") {
+            value = serialize(minus(20), context);
+        }
+        SECTION("operator") {
+            value = serialize(-c(20), context);
+        }
+        expected = "-20";
+    }
     SECTION("add") {
         SECTION("func") {
             value = serialize(add(3, 5), context);
@@ -55,12 +64,12 @@ TEST_CASE("statement_serializer arithmetic operators") {
     }
     SECTION("parentheses keeping order of precedence") {
         SECTION("1") {
-            value = serialize(c(4) + 5 + 3, context);
-            expected = "(4 + 5) + 3";
+            value = serialize(c(4) + 5 + -c(3), context);
+            expected = "(4 + 5) + -3";
         }
         SECTION("2") {
-            value = serialize(4 + (c(5) + 3), context);
-            expected = "4 + (5 + 3)";
+            value = serialize(4 + -(c(5) + 3), context);
+            expected = "4 + -(5 + 3)";
         }
         SECTION("3") {
             value = serialize(4 + c(5) * 3 + 1, context);

diff --git a/tests/static_tests/column_result_t.cpp b/tests/static_tests/column_result_t.cpp
@@ -95,6 +95,8 @@ TEST_CASE("column_result_of_t") {
     runTest<db_objects_t, std::string>(all(&User::name));
     runTest<db_objects_t, std::string>(conc(&User::name, &User::id));
     runTest<db_objects_t, std::string>(c(&User::name) || &User::id);
+    runTest<db_objects_t, double>(minus(&User::id));
+    runTest<db_objects_t, double>(-c(&User::id));
     runTest<db_objects_t, double>(add(&User::id, 5));
     runTest<db_objects_t, double>(c(&User::id) + 5);
     runTest<db_objects_t, double>(sub(&User::id, 5));

diff --git a/tests/static_tests/node_tuple.cpp b/tests/static_tests/node_tuple.cpp
@@ -189,25 +189,28 @@ TEST_CASE("Node tuple") {
         using namespace internal;
 
         using CondTuple = node_tuple_t<conc_t<std::string, decltype(&User::name)>>;
-        static_assert(is_same<CondTuple, tuple<std::string, decltype(&User::name)>>::value, "conc_t");
+        STATIC_REQUIRE(is_same<CondTuple, tuple<std::string, decltype(&User::name)>>::value);
+
+        using MinusTuple = node_tuple_t<unary_minus_t<decltype(&User::id)>>;
+        STATIC_REQUIRE(is_same<MinusTuple, tuple<decltype(&User::id)>>::value);
 
         using AddTuple = node_tuple_t<add_t<int, decltype(&User::id)>>;
-        static_assert(is_same<AddTuple, tuple<int, decltype(&User::id)>>::value, "add_t");
+        STATIC_REQUIRE(is_same<AddTuple, tuple<int, decltype(&User::id)>>::value);
 
         using SubTuple = node_tuple_t<sub_t<float, double>>;
-        static_assert(is_same<SubTuple, tuple<float, double>>::value, "sub_t");
+        STATIC_REQUIRE(is_same<SubTuple, tuple<float, double>>::value);
 
         using MulTuple = node_tuple_t<mul_t<double, decltype(&User::id)>>;
-        static_assert(is_same<MulTuple, tuple<double, decltype(&User::id)>>::value, "mul_t");
+        STATIC_REQUIRE(is_same<MulTuple, tuple<double, decltype(&User::id)>>::value);
 
         using DivTuple = node_tuple_t<sqlite_orm::internal::div_t<int, float>>;
-        static_assert(is_same<DivTuple, tuple<int, float>>::value, "div_t");
+        STATIC_REQUIRE(is_same<DivTuple, tuple<int, float>>::value);
 
         using ModTuple = node_tuple_t<mod_t<decltype(&User::id), int>>;
-        static_assert(is_same<ModTuple, tuple<decltype(&User::id), int>>::value, "mod_t");
+        STATIC_REQUIRE(is_same<ModTuple, tuple<decltype(&User::id), int>>::value);
 
         using AssignTuple = node_tuple_t<assign_t<decltype(&User::name), std::string>>;
-        static_assert(is_same<AssignTuple, tuple<decltype(&User::name), std::string>>::value, "assign_t");
+        STATIC_REQUIRE(is_same<AssignTuple, tuple<decltype(&User::name), std::string>>::value);
     }
     SECTION("bitwise operator") {
         using namespace internal;

diff --git a/tests/static_tests/operators_adl.cpp b/tests/static_tests/operators_adl.cpp
@@ -28,6 +28,7 @@ using sqlite_orm::internal::less_or_equal_t;
 using sqlite_orm::internal::less_than_t;
 using sqlite_orm::internal::negated_condition_t;
 using sqlite_orm::internal::or_condition_t;
+using sqlite_orm::internal::unary_minus_t;
 using sqlite_orm::polyfill::is_specialization_of_v;
 
 template<class E>
@@ -68,6 +69,10 @@ void runTests(E expression) {
     STATIC_REQUIRE(is_specialization_of_v<decltype(42 || (expression || 42)), binary_operator>);
     STATIC_REQUIRE(is_specialization_of_v<decltype(c(42) || (expression || 42)), binary_operator>);
 
+    STATIC_REQUIRE(is_specialization_of_v<decltype(-expression), unary_minus_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(-(expression + expression)), unary_minus_t>);
+    STATIC_REQUIRE(is_specialization_of_v<decltype(-expression + expression), binary_operator>);
+
     STATIC_REQUIRE(is_specialization_of_v<decltype(expression + 42), binary_operator>);
     STATIC_REQUIRE(is_specialization_of_v<decltype(42 + expression), binary_operator>);
     STATIC_REQUIRE(is_specialization_of_v<decltype(expression + expression), binary_operator>);