@ugo-studio/jspp 0.3.1 → 0.3.3

package/src/prelude/utils/assignment_operators.hpp

@@ -4,52 +4,98 @@
 #include "any_value.hpp"
 #include "utils/operators.hpp"
 
-namespace jspp {
+namespace jspp
+{
 
     // --- FRIEND IMPLEMENTATIONS ---
 
-    inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs) {
+    inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs)
+    {
         lhs = jspp::add(lhs, rhs);
         return lhs;
     }
 
-    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs) {
+    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs)
+    {
         lhs = jspp::sub(lhs, rhs);
         return lhs;
     }
 
-    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs) {
+    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs)
+    {
         lhs = jspp::mul(lhs, rhs);
         return lhs;
     }
 
-    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs) {
+    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs)
+    {
         lhs = jspp::div(lhs, rhs);
         return lhs;
     }
 
-    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs) {
+    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs)
+    {
         lhs = jspp::mod(lhs, rhs);
         return lhs;
     }
 
-    inline AnyValue &operator++(AnyValue &val) {
+    inline AnyValue &operator&=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::bitwise_and(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator|=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::bitwise_or(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator^=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::bitwise_xor(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator<<=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::left_shift(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator>>=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::right_shift(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &unsigned_right_shift_assign(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::unsigned_right_shift(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator++(AnyValue &val)
+    {
         val = jspp::add(val, 1.0);
         return val;
     }
 
-    inline AnyValue operator++(AnyValue &val, int) {
+    inline AnyValue operator++(AnyValue &val, int)
+    {
         AnyValue temp = val;
         val = jspp::add(val, 1.0);
         return temp;
     }
 
-    inline AnyValue &operator--(AnyValue &val) {
+    inline AnyValue &operator--(AnyValue &val)
+    {
         val = jspp::sub(val, 1.0);
         return val;
     }
 
-    inline AnyValue operator--(AnyValue &val, int) {
+    inline AnyValue operator--(AnyValue &val, int)
+    {
         AnyValue temp = val;
         val = jspp::sub(val, 1.0);
         return temp;
@@ -57,43 +103,113 @@ namespace jspp {
 
     // --- OVERLOADS FOR PRIMITIVES ---
 
-    inline AnyValue &operator+=(AnyValue &lhs, const double &rhs) {
+    inline AnyValue &operator+=(AnyValue &lhs, const double &rhs)
+    {
         lhs = jspp::add(lhs, rhs);
         return lhs;
     }
-    inline AnyValue &operator+=(AnyValue &lhs, const int &rhs) {
+    inline AnyValue &operator+=(AnyValue &lhs, const int &rhs)
+    {
         return lhs += static_cast<double>(rhs);
     }
 
-    inline AnyValue &operator-=(AnyValue &lhs, const double &rhs) {
+    inline AnyValue &operator-=(AnyValue &lhs, const double &rhs)
+    {
         lhs = jspp::sub(lhs, rhs);
         return lhs;
     }
-    inline AnyValue &operator-=(AnyValue &lhs, const int &rhs) {
+    inline AnyValue &operator-=(AnyValue &lhs, const int &rhs)
+    {
         return lhs -= static_cast<double>(rhs);
     }
 
-    inline AnyValue &operator*=(AnyValue &lhs, const double &rhs) {
+    inline AnyValue &operator*=(AnyValue &lhs, const double &rhs)
+    {
         lhs = jspp::mul(lhs, rhs);
         return lhs;
     }
-    inline AnyValue &operator*=(AnyValue &lhs, const int &rhs) {
+    inline AnyValue &operator*=(AnyValue &lhs, const int &rhs)
+    {
         return lhs *= static_cast<double>(rhs);
     }
 
-    inline AnyValue &operator/=(AnyValue &lhs, const double &rhs) {
+    inline AnyValue &operator/=(AnyValue &lhs, const double &rhs)
+    {
         lhs = jspp::div(lhs, rhs);
         return lhs;
     }
-    inline AnyValue &operator/=(AnyValue &lhs, const int &rhs) {
+    inline AnyValue &operator/=(AnyValue &lhs, const int &rhs)
+    {
         return lhs /= static_cast<double>(rhs);
     }
 
-    inline AnyValue &operator%=(AnyValue &lhs, const double &rhs) {
+    inline AnyValue &operator%=(AnyValue &lhs, const double &rhs)
+    {
         lhs = jspp::mod(lhs, rhs);
         return lhs;
     }
-    inline AnyValue &operator%=(AnyValue &lhs, const int &rhs) {
+    inline AnyValue &operator%=(AnyValue &lhs, const int &rhs)
+    {
         return lhs %= static_cast<double>(rhs);
     }
+
+    inline AnyValue &operator&=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::bitwise_and(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator&=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs &= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator|=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::bitwise_or(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator|=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs |= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator^=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::bitwise_xor(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator^=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs ^= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator<<=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::left_shift(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator<<=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs <<= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator>>=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::right_shift(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator>>=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs >>= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &unsigned_right_shift_assign(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::unsigned_right_shift(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &unsigned_right_shift_assign(AnyValue &lhs, const int &rhs)
+    {
+        return unsigned_right_shift_assign(lhs, static_cast<double>(rhs));
+    }
 }

package/src/prelude/utils/log_any_value/log_any_value.hpp

@@ -26,7 +26,7 @@ namespace jspp
         inline std::string to_log_string(const AnyValue &val, std::unordered_set<const void *> &visited, int depth)
         {
             // 1. Try Primitives
-            auto primitiveStr = format_primitive(val, depth);
+            auto primitiveStr = format_native(val, depth);
             if (primitiveStr.has_value())
             {
                 return primitiveStr.value();

package/src/prelude/utils/log_any_value/primitives.hpp

@@ -11,7 +11,7 @@ namespace jspp
 {
     namespace LogAnyValue
     {
-        inline std::optional<std::string> format_primitive(const AnyValue &val, int depth)
+        inline std::optional<std::string> format_native(const AnyValue &val, int depth)
         {
             if (val.is_uninitialized())
             {