we are no longer need to call zm::assign explicitly because we have operator=()

Author: SergeyMakeev

Zmeya/Zmeya.h

@@ -341,6 +341,19 @@ class String
         return !isEqual(other.c_str());
     }
 
+    // Assignment operators for automatic conversion
+    String& operator=(const std::string& other)
+    {
+        assign(*this, other);
+        return *this;
+    }
+
+    String& operator=(const char* other)
+    {
+        assign(*this, other);
+        return *this;
+    }
+
     // friend class BlobBuilder;
 
     // Friend declarations for new Builder API
@@ -424,6 +437,14 @@ template <typename T> class Array
 
     ZMEYA_NODISCARD bool empty() const noexcept { return size() == 0; }
 
+    // Assignment operators for automatic conversion
+    template<typename F>
+    Array<T>& operator=(const std::vector<F>& other)
+    {
+        assign(*this, other);
+        return *this;
+    }
+
     // friend class BlobBuilder;
 
     // Friend declarations for new Builder API
@@ -539,6 +560,15 @@ template <typename Key> class HashSet
     }
 
     ZMEYA_NODISCARD bool contains(const Key& key) const noexcept { return containsImpl<Key, HashKeyAdapterGeneric<Key>>(key); }
+
+    // Assignment operators for automatic conversion
+    template<typename F>
+    HashSet<Key>& operator=(const std::unordered_set<F>& other)
+    {
+        assign(*this, other);
+        return *this;
+    }
+
     // friend class BlobBuilder;
 
     // Friend declarations for new Builder API
@@ -703,6 +733,14 @@ template <typename Key, typename Value> class HashMap
         return valueIfNotFound;
     }
 
+    // Assignment operators for automatic conversion
+    template<typename FK, typename FV>
+    HashMap<Key, Value>& operator=(const std::unordered_map<FK, FV>& other)
+    {
+        assign(*this, other);
+        return *this;
+    }
+
     // friend class BlobBuilder;
 
     // Friend declarations for new Builder API
@@ -2014,30 +2052,9 @@ template <typename T, typename F> void assign(Array<T>& _to, const std::vector<F
 
     for (size_t i = 0; i < from.size(); ++i)
     {
-        // deep-copy elements
-        // TODO: add range check for offset to make sure it within the valid range (goffset_t)
+        // deep-copy elements using the universal deep_copy function
         zm::goffset_t elementOffset = zm::goffset_t(arrayDataOffset + i * sizeOfT);
-        
-        // Use placement constructor and then assign
-        T* element = reinterpret_cast<T*>(builder->get_ptr_unsafe_to_store(elementOffset));
-        BuilderBase::placementCtor<T>(element);
-        
-        // For fundamental types, direct assignment
-        if constexpr (std::is_fundamental_v<F> && std::is_fundamental_v<T>) {
-            *element = static_cast<T>(from[i]);
-        }
-        // For string conversion
-        else if constexpr (std::is_same_v<F, std::string> && std::is_same_v<T, String>) {
-            assign(*element, from[i]);
-        }
-        // For vector to array conversion (nested arrays)
-        else if constexpr (std::is_same_v<std::decay_t<F>, std::vector<typename std::decay_t<F>::value_type, typename std::decay_t<F>::allocator_type>>) {
-            assign(*element, from[i]);
-        }
-        // For other complex types, this shouldn't happen in practice
-        else {
-            static_assert(sizeof(F) == 0, "Unsupported type conversion in deep_copy");
-        }
+        deep_copy<F, T>(from[i], elementOffset);
     }
 }
 
@@ -2114,14 +2131,8 @@ template <typename Key, typename F> void assign(HashSet<Key>& _to, const std::un
         Key* element = &items[bucket.endIndex];
         BuilderBase::placementCtor<Key>(element);
 
-        // Assign the item using the same logic as Array assign
-        if constexpr (std::is_fundamental_v<F> && std::is_fundamental_v<Key>) {
-            *element = static_cast<Key>(item);
-        } else if constexpr (std::is_same_v<F, std::string> && std::is_same_v<Key, String>) {
-            assign(*element, item);
-        } else {
-            assign(*element, item);
-        }
+        // Assign the item using operator= (automatic conversion)
+        *element = item;
 
         bucket.endIndex++;
     }
@@ -2254,23 +2265,9 @@ void assign(HashMap<Key, Value>& _to, const std::unordered_map<FK, FV>& from)
         BuilderBase::placementCtor<Key>(mutableKey);
         BuilderBase::placementCtor<Value>(&element->second);
 
-        // Assign key
-        if constexpr (std::is_fundamental_v<FK> && std::is_fundamental_v<Key>) {
-            *mutableKey = static_cast<Key>(key);
-        } else if constexpr (std::is_same_v<FK, std::string> && std::is_same_v<Key, String>) {
-            assign(*mutableKey, key);
-        } else {
-            assign(*mutableKey, key);
-        }
-        
-        // Assign value
-        if constexpr (std::is_fundamental_v<FV> && std::is_fundamental_v<Value>) {
-            element->second = static_cast<Value>(value);
-        } else if constexpr (std::is_same_v<FV, std::string> && std::is_same_v<Value, String>) {
-            assign(element->second, value);
-        } else {
-            assign(element->second, value);
-        }
+        // Assign key and value using operator= (automatic conversion)
+        *mutableKey = key;
+        element->second = value;
 
         bucket.endIndex++;
     }
@@ -2322,67 +2319,14 @@ void assign(HashMap<Key, Value>& _to, const std::unordered_map<FK, FV>& from)
 
 // Deep-copy adapter implementations
 
-// Generic copy for fundamental types only (int, float, etc.)
-template <typename F, typename T> 
-std::enable_if_t<std::is_fundamental_v<std::decay_t<F>> && std::is_fundamental_v<std::decay_t<T>> && std::is_convertible_v<F, T>>
-deep_copy(const F& from, zm::goffset_t to_ofs)
+// Universal deep_copy - works for all types thanks to operator= overloads
+template <typename F, typename T> void deep_copy(const F& from, zm::goffset_t to_ofs)
 {
     BuilderBase* builder = detail::get_global_builder();
     ZMEYA_ASSERT(builder != nullptr);
     T* p_to = reinterpret_cast<T*>(builder->get_ptr_unsafe_to_store(to_ofs));
-    *p_to = static_cast<T>(from);
-}
-
-// Specialized overloads for std::* -> zm::* conversions
-inline void deep_copy(const std::string& from, zm::goffset_t to_ofs) 
-{ 
-    BuilderBase* builder = detail::get_global_builder();
-    ZMEYA_ASSERT(builder != nullptr);
-    String* p_to = reinterpret_cast<String*>(builder->get_ptr_unsafe_to_store(to_ofs));
-    assign(*p_to, from); 
-}
-
-inline void deep_copy(const char* from, zm::goffset_t to_ofs) 
-{ 
-    BuilderBase* builder = detail::get_global_builder();
-    ZMEYA_ASSERT(builder != nullptr);
-    String* p_to = reinterpret_cast<String*>(builder->get_ptr_unsafe_to_store(to_ofs));
-    assign(*p_to, from); 
-}
-
-template <typename F, typename T> void deep_copy(const std::vector<F>& from, zm::goffset_t to_ofs) 
-{ 
-    BuilderBase* builder = detail::get_global_builder();
-    ZMEYA_ASSERT(builder != nullptr);
-    Array<T>* p_to = reinterpret_cast<Array<T>*>(builder->get_ptr_unsafe_to_store(to_ofs));
-    assign(*p_to, from); 
-}
-
-template <typename F, typename Key> void deep_copy(const std::unordered_set<F>& from, zm::goffset_t to_ofs) 
-{ 
-    BuilderBase* builder = detail::get_global_builder();
-    ZMEYA_ASSERT(builder != nullptr);
-    HashSet<Key>* p_to = reinterpret_cast<HashSet<Key>*>(builder->get_ptr_unsafe_to_store(to_ofs));
-    assign(*p_to, from); 
-}
-
-template <typename FK, typename FV, typename Key, typename Value>
-void deep_copy(const std::unordered_map<FK, FV>& from, zm::goffset_t to_ofs)
-{
-    BuilderBase* builder = detail::get_global_builder();
-    ZMEYA_ASSERT(builder != nullptr);
-    HashMap<Key, Value>* p_to = reinterpret_cast<HashMap<Key, Value>*>(builder->get_ptr_unsafe_to_store(to_ofs));
-    assign(*p_to, from);
-}
-
-// Pair conversions
-template <typename F1, typename F2, typename T1, typename T2> void deep_copy(const Pair<F1, F2>& from, zm::goffset_t to_ofs)
-{
-    BuilderBase* builder = detail::get_global_builder();
-    ZMEYA_ASSERT(builder != nullptr);
-    Pair<T1, T2>* p_to = reinterpret_cast<Pair<T1, T2>*>(builder->get_ptr_unsafe_to_store(to_ofs));
-    deep_copy(from.first, builder->get_global_offset(&p_to->first));
-    deep_copy(from.second, builder->get_global_offset(&p_to->second));
+    BuilderBase::placementCtor<T>(p_to);
+    *p_to = from; // This will call the appropriate operator= automatically!
 }
 
 /*

ZmeyaTest01.cpp

@@ -124,6 +124,16 @@ struct Desc
     zm::String name;
     float v1;
     uint32_t v2;
+    
+    // Assignment operator for automatic conversion from TempDesc
+    template<typename TempType>
+    Desc& operator=(const TempType& temp)
+    {
+        name = temp.name;
+        v1 = temp.v1;
+        v2 = temp.v2;
+        return *this;
+    }
 };
 
 struct TestRoot
@@ -172,19 +182,19 @@ TEST(ZmeyaTestSuite, SimpleTest2)
             tempDescs.push_back(desc);
         }
 
-        // For complex struct conversion, we need to add a deep_copy specialization
-        // For now, let's create a simple vector of strings to demonstrate the new API
-        std::vector<std::string> nameStrings(names.begin(), names.end());
-        
-        // TODO: Once we have deep_copy<TempDesc, Desc> specialization, we can use:
-        // zm::assign(root->arr, tempDescs);
+        root->arr = tempDescs;
 
-        // For now, let's just test that the root object works and skip the complex array
-        // The array will remain empty, which is fine for testing the basic API
-        
-        EXPECT_EQ(root->arr.size(), 0); // Array is empty for now
-        
-        // TODO: Add array validation once deep_copy<TempDesc, Desc> is implemented
+        EXPECT_EQ(root->arr.size(), names.size());
+
+        // Validate data during build
+        for (size_t i = 0; i < names.size(); i++)
+        {
+            const char* s1 = root->arr[i].name.c_str();
+            const char* s2 = names[i].c_str();
+            EXPECT_STREQ(s1, s2);
+            EXPECT_FLOAT_EQ(root->arr[i].v1, (float)(i));
+            EXPECT_EQ(root->arr[i].v2, (uint32_t)(i));
+        }
 
         zm::Span<char> bytes = builder->finalize();
         blob = std::vector<char>(bytes.data, bytes.data + bytes.size);
@@ -198,9 +208,15 @@ TEST(ZmeyaTestSuite, SimpleTest2)
 
     // validate
     const TestRoot* rootCopy = (const TestRoot*)(blob.data());
-    EXPECT_EQ(rootCopy->arr.size(), 0); // Array is empty for now
-    
-    // TODO: Add validation once complex struct conversion is implemented
+    EXPECT_EQ(rootCopy->arr.size(), names.size());
+
+    for (size_t i = 0; i < names.size(); i++)
+    {
+        const Desc& desc = rootCopy->arr[i];
+        EXPECT_STREQ(desc.name.c_str(), names[i].c_str());
+        EXPECT_FLOAT_EQ(desc.v1, (float)(i));
+        EXPECT_EQ(desc.v2, (uint32_t)(i));
+    }
 
 /*
     EXPECT_EQ(Memory::mallocCount, Memory::freeCount);

ZmeyaTestNewAPI.cpp

@@ -65,23 +65,23 @@ TEST(ZmeyaTestSuite, NewBuilderAPI_BasicTypes)
 
     // Test basic string assignment
     std::string srcDesc = "Test description";
-    zm::assign(root->description, srcDesc);
+    root->description = srcDesc;
 
     // Test array of primitives
     std::vector<int32_t> srcInts = {1, 2, 3, 4, 5};
-    zm::assign(root->intArray, srcInts);
+    root->intArray =  srcInts;
 
     // Test array of strings
     std::vector<std::string> srcStrings = {"hello", "world", "test"};
-    zm::assign(root->stringArray, srcStrings);
+    root->stringArray =  srcStrings;
 
     // Test HashMap
     std::unordered_map<std::string, int32_t> srcMap = {{"one", 1}, {"two", 2}, {"three", 3}};
-    zm::assign(root->hashMap, srcMap);
+    root->hashMap =  srcMap;
 
     // Test HashSet
     std::unordered_set<std::string> srcSet = {"alpha", "beta", "gamma"};
-    zm::assign(root->hashSet, srcSet);
+    root->hashSet =  srcSet;
 
     // Get result
     zm::Span<char> bytes = builder->finalize();
@@ -120,7 +120,7 @@ TEST(ZmeyaTestSuite, NewBuilderAPI_NestedTypes)
 
     // Test nested array conversion
     std::vector<std::vector<std::string>> srcNested = {{"a", "b", "c"}, {"x", "y"}, {"hello", "world", "nested", "test"}};
-    zm::assign(root->nestedArray, srcNested);
+    root->nestedArray = srcNested;
 
     // Get result
     zm::Span<char> bytes = builder->finalize();