using structs to define type conversions

include/spdlog/details/log_attr.h

@@ -11,100 +11,60 @@ namespace details {
 // template<typename T>
 // concept composable = std::same_as<T, bool> || std::integral<T> || std::floating_point<T> || std::convertible_to<T, std::string_view>;
 
-struct attr
+
+struct Key 
 {
-    std::string key;
+    std::string _key;
-    std::string value;
 
-public:
+    Key(string_view_t k) {
-    // string overloads
+        scramble(_key, k);
-    attr(string_view_t k, string_view_t v)
-    {
-        scramble(key, k);
-        scramble(value, v);
     }
+    Key(std::string&& k) {
+        scramble(_key, k);
+    }
+    Key(const char* k) {
+        scramble(_key, k);
+    }
+};
 
-    // does not convert to string_view when using initializer list constructors...
+struct Value
-    // so we have an overload for raw c-strings
+{
-    attr(const char* k, const char* v)
+    std::string _value;
-        : attr{string_view_t{k}, string_view_t{v}}
-    {}
-
-    attr(std::string const& k, std::string const& v)
-        : attr{string_view_t{k}, string_view_t{v}}
-    {}
-    
-    attr(std::string&& k, std::string&& v)
-        : attr{string_view_t{k}, string_view_t{v}}
-    {}
 
-    // integer overloads
+    Value(string_view_t v) {
-    attr(string_view_t k, long v)
+        scramble(_value, v);
-        : value{std::to_string(v)}
-    {
-        scramble(key, k);
     }
-    attr(string_view_t k, long long v)
+    Value(std::string&& v) {
-        : value{std::to_string(v)}
+        scramble(_value, v);
-    {
-        scramble(key, k);
     }
-    attr(string_view_t k, unsigned long v)
+    Value(const char* v) {
-        : value{std::to_string(v)}
+        scramble(_value, v);
-    {
-        scramble(key, k);
     }
-    attr(string_view_t k, unsigned long long v)
+    Value(long v) {
-        : value{std::to_string(v)}
+        _value = std::to_string(v);
-    {
-        scramble(key, k);
     }
-    
+    Value(long long v) {
-    attr(string_view_t k, bool v)
+        _value = std::to_string(v);
-        : value{v ? "true" : "false"}
-    {
-        scramble(key, k);
     }
-    
+    Value(unsigned long v) {
-    attr(std::string const& k, long v)
+        _value = std::to_string(v);
-        : attr{string_view_t{k}, v}
+    }
-    {}
+    Value(unsigned long long v) {
-
+        _value = std::to_string(v);
-    attr(std::string const& k, long long v)
+    }
-        : attr{string_view_t{k}, v}
+    Value(bool v) {
-    {}
+        _value = v ? "true" : "false";
-
+    }
-    attr(std::string const& k, unsigned long v)
+};
-        : attr{string_view_t{k}, v}
-    {}
-
-    attr(std::string const& k, unsigned long long v)
-        : attr{string_view_t{k}, v}
-    {}
-
-    attr(std::string const& k, bool v)
-        : attr{string_view_t{k}, v}
-    {}
-
-    attr(std::string&& k, long v)
-        : attr{string_view_t{k}, v}
-    {}
-
-    attr(std::string&& k, long long v)
-        : attr{string_view_t{k}, v}
-    {}
-
-    attr(std::string&& k, unsigned long v)
-        : attr{string_view_t{k}, v}
-    {}
 
-    attr(std::string&& k, unsigned long long v)
+struct attr
-        : attr{string_view_t{k}, v}
+{
-    {}
+    std::string key;
+    std::string value;
 
-    attr(std::string&& k, bool v)
+public:
-        : attr{string_view_t{k}, v}
+    attr(Key&& k, Value&& v) : key(std::move(k._key)), value(std::move(v._value)) {}
-    {}
+    attr(Key const& k, Value const& v) : key(k._key), value(v._value) {}
 };
 
 } // namespace details