feat: make stringable class can be key of reflection map

src/ll/api/base/Concepts.h

@@ -25,8 +25,8 @@ struct is_all_same : std::bool_constant<is_all_same_v<T, Ts...>> {};
 template <class T, class... Ts>
 concept IsAllSame = is_all_same_v<T, Ts...>;
 
-template <class T, class... Ts>
-static constexpr bool is_string_v = std::convertible_to<T, std::string_view>;
+template <class T>
+static constexpr bool is_string_v = std::is_constructible_v<std::string, T>;
 
 template <class T>
 concept IsString = is_string_v<T>;
@@ -111,7 +111,7 @@ inline constexpr bool always_false = false;
 
 template <class T>
 concept Stringable = requires(T t) {
-    { t.toString() } -> std::convertible_to<std::string>;
+    { t.toString() } -> IsString;
 };
 
 } // namespace ll::concepts

src/ll/api/reflection/Deserialization.h

@@ -14,21 +14,18 @@ inline void deserialize(T&, J const&)
 
 template <class J, class T>
 inline void deserialize(T&, J const&)
-    requires(
-        !std::is_enum_v<T>
-        && (std::is_convertible_v<T, std::string_view> || std::is_floating_point_v<T> || std::is_integral_v<T>)
-    );
+    requires(!std::is_enum_v<T> && (concepts::IsString<T> || std::is_floating_point_v<T> || std::is_integral_v<T>));
 
 template <class J, concepts::Associative T>
 inline void deserialize(T&, J const&)
-    requires(std::is_convertible_v<typename T::key_type, std::string_view>);
+    requires(concepts::IsString<typename T::key_type>);
 
 template <class J, concepts::TupleLike T>
 inline void deserialize(T&, J const&);
 
 template <class J, concepts::ArrayLike T>
 inline void deserialize(T&, J const&)
-    requires(!std::is_convertible_v<T, std::string_view>);
+    requires(!concepts::IsString<T>);
 
 template <class J, concepts::IsOptional T>
 inline void deserialize(T&, J const&);
@@ -79,12 +76,9 @@ inline void deserialize(T& e, J const& j)
 
 template <class J, class T>
 inline void deserialize(T& obj, J const& j) // TODO: improve this
-    requires(
-        !std::is_enum_v<T>
-        && (std::is_convertible_v<T, std::string_view> || std::is_floating_point_v<T> || std::is_integral_v<T>)
-    )
+    requires(!std::is_enum_v<T> && (concepts::IsString<T> || std::is_floating_point_v<T> || std::is_integral_v<T>))
 {
-    if constexpr (std::is_convertible_v<T, std::string_view>) {
+    if constexpr (concepts::IsString<T>) {
         if (!j.is_string()) throw std::runtime_error("field must be a string");
     } else {
         if (!j.is_number() && !j.is_boolean()) throw std::runtime_error("field must be a number");
@@ -94,7 +88,7 @@ inline void deserialize(T& obj, J const& j) // TODO: improve this
 
 template <class J, concepts::Associative T>
 inline void deserialize(T& map, J const& j)
-    requires(std::is_convertible_v<typename T::key_type, std::string_view>)
+    requires(concepts::IsString<typename T::key_type>)
 {
     if (!j.is_object()) throw std::runtime_error("field must be an object");
     map.clear();
@@ -112,7 +106,7 @@ inline void deserialize(T& tuple, J const& j) {
 
 template <class J, concepts::ArrayLike T>
 inline void deserialize(T& arr, J const& j)
-    requires(!std::is_convertible_v<T, std::string_view>)
+    requires(!concepts::IsString<T>)
 {
     if (!j.is_array()) throw std::runtime_error("field must be an array");
 

src/ll/api/reflection/Serialization.h

@@ -19,7 +19,7 @@ inline J serialize(T const&)
 
 template <class J, concepts::Associative T>
 inline J serialize(T const&)
-    requires(std::is_convertible_v<typename T::key_type, std::string_view> && !std::convertible_to<T, J>);
+    requires(concepts::IsString<typename T::key_type> && !std::convertible_to<T, J>);
 
 
 template <class J, concepts::TupleLike T>
@@ -78,7 +78,7 @@ inline J serialize(T const& obj)
 
 template <class J, concepts::Associative T>
 inline J serialize(T const& map)
-    requires(std::is_convertible_v<typename T::key_type, std::string_view> && !std::convertible_to<T, J>)
+    requires(concepts::IsString<typename T::key_type> && !std::convertible_to<T, J>)
 {
     J res;
     for (auto& [k, v] : map) {

src/ll/test/ConfigTest.cpp

@@ -23,6 +23,8 @@
 #include "mc/server/ServerLevel.h"
 #include "mc/server/commands/standard/FillCommand.h"
 
+#include "mc/deps/core/mce/UUID.h"
+
 template <class T>
 
 class TestClass {
@@ -52,6 +54,11 @@ class TestClass {
         {"key2", {"a new thing", 42}},
         {"key3", {}                 },
     };
+    std::map<mce::UUID, int> bmap = {
+        {{0, 1}, 4454556},
+        {{2, 3}, 4366},
+        {{4, 5}, -63556654},
+    };
     std::tuple<int, bool, float>                       tuple;
     std::pair<std::string_view, MyPair>                pair;
     std::array<int, 5>                                 array{};

src/mc/deps/core/mce/UUID.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "ll/api/base/Hash.h"
 #include "mc/_HeaderOutputPredefine.h"
 
 namespace mce {
@@ -8,12 +9,27 @@ class UUID {
 public:
     uint64 a, b;
 
-    UUID(uint64 a = 0, uint64 b = 0) : a(a), b(b) {}
+    UUID(uint64 a, uint64 b) : a(a), b(b) {}
+
+    UUID() : UUID(EMPTY) {}
+
+    UUID(std::string const& str) : UUID(fromString(str)) {} // NOLINT
 
     LLNDAPI static mce::UUID random();
 
     [[nodiscard]] inline explicit operator bool() const { return !isEmpty(); }
 
+    [[nodiscard]] inline explicit operator std::string() const { return asString(); }
+
+    bool operator==(UUID const& other) const { return (a == other.a) && (b == other.b); }
+
+    std::strong_ordering operator<=>(UUID const& other) const {
+        if (a != other.a) {
+            return a <=> other.a;
+        }
+        return b <=> other.b;
+    }
+
 public:
     // NOLINTBEGIN
     // symbol: ?asString@UUID@mce@@QEBA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ
@@ -38,3 +54,15 @@ class UUID {
 };
 
 }; // namespace mce
+
+
+namespace std {
+template <>
+struct hash<mce::UUID> {
+    size_t operator()(mce::UUID id) const noexcept {
+        size_t hash = id.a;
+        ll::hash::hashCombine(id.b, hash);
+        return hash;
+    }
+};
+} // namespace std