Changeset 143:5d6130e3f43c in rrlib_rtti

Timestamp:

28.03.2020 21:13:36 (3 years ago)

Author:

Max Reichardt <mreichardt@…>

Branch:

17.03

Children:

144:bd3582809830, 145:ae5a7c09b179

Phase:

public

Message:

Adds additional generic rtti-based XML serialization implemenentations for container types (that use the default rrlib_serialization template functions) - together with unit tests. This results in a significant reduction of binary sizes. Furthemore, adds support for XML deserialization of multi-line strings.

Files:

• detail/tDataTypeInfo.h (modified) (1 diff)
• tTypedPointer.cpp (modified) (4 diffs)
• tests/rtti.cpp (modified) (5 diffs)

detail/tDataTypeInfo.h

@@ -79 +79 @@
                   (!(SupportsBitwiseCopy<T>::value && IsDefaultConstructionZeroMemory<T>::value) ? eTLF_BINARY_OPS : 0) |
                   (serialization::IsBinarySerializable<T>::value ? eTLF_BINARY_SERIALIZATION : 0) |
-                  ((serialization::IsXMLSerializable<T>::value || serialization::IsStringSerializable<T>::value) && (!(IsStdPair<T>::value || IsStdTuple<T>::value)) ? eTLF_OTHER_SERIALIZATION : 0))
+                  ((serialization::IsXMLSerializable<T>::value || serialization::IsStringSerializable<T>::value) && (!(IsStdPair<T>::value || IsStdTuple<T>::value || ((IsStdVector<T>::value || IsStdArray<T>::value) && serialization::IsXMLSerializationDefaultImplementation<T>::value && (!std::is_same<T, std::vector<bool>>::value)))) ? eTLF_OTHER_SERIALIZATION : 0))
        };
 };

tTypedPointer.cpp

@@ -37 +37 @@
 // Internal includes with ""
 //----------------------------------------------------------------------
+#include "rrlib/rtti/rtti.h"
 
 //----------------------------------------------------------------------
@@ -62 +63 @@
 // Const values
 //----------------------------------------------------------------------
+static tType cSTRING_TYPE = tDataType<std::string>();
+static tType cBOOL_VECTOR_TYPE = tDataType<std::vector<bool>>();
 
 //----------------------------------------------------------------------
@@ -101 +104 @@
       }
     }
+    else if (type.GetTypeClassification() == tTypeClassification::LIST && type != cBOOL_VECTOR_TYPE)
+    {
+      size_t child_count = 0;
+      for (auto it = node.ChildrenBegin(); it != node.ChildrenEnd(); ++it)
+      {
+        child_count++;
+      }
+      this->ResizeVector(child_count);
+      size_t i = 0;
+      for (auto it = node.ChildrenBegin(); it != node.ChildrenEnd(); ++it, ++i)
+      {
+        this->GetVectorElement(i).Deserialize(*it);
+      }
+    }
+    else if (type.GetTypeClassification() == tTypeClassification::ARRAY)
+    {
+      const size_t array_size = this->GetType().GetArraySize();
+      const size_t element_size = this->GetType().GetSize() / array_size;
+      rrlib::rtti::tType element_type = this->GetType().GetElementType();
+      assert(element_type.GetSize() == element_size);
+      size_t i = 0;
+      for (auto it = node.ChildrenBegin(); it != node.ChildrenEnd() && i < array_size; ++it, ++i)
+      {
+        tTypedPointer element(static_cast<char*>(this->GetRawDataPointer()) + element_size * i, element_type);
+        element.Deserialize(*it);
+      }
+    }
+    else if (type == cSTRING_TYPE)
+    {
+      *this->Get<std::string>() = node.GetTextContent();
+    }
     else if (type.GetTypeTraits() & trait_flags::cIS_STRING_SERIALIZABLE)
     {
@@ -171 +205 @@
       }
     }
+    else if (type.GetTypeClassification() == tTypeClassification::LIST && type != cBOOL_VECTOR_TYPE)
+    {
+      const size_t size = this->GetVectorSize();
+      for (size_t i = 0; i < size; i++)
+      {
+        this->GetVectorElement(i).Serialize(node.AddChildNode("element"));
+      }
+    }
+    else if (type.GetTypeClassification() == tTypeClassification::ARRAY)
+    {
+      const size_t array_size = this->GetType().GetArraySize();
+      const size_t element_size = this->GetType().GetSize() / array_size;
+      rrlib::rtti::tType element_type = this->GetType().GetElementType();
+      assert(element_type.GetSize() == element_size);
+      for (size_t i = 0; i < array_size; i++)
+      {
+        tTypedConstPointer element(static_cast<const char*>(this->GetRawDataPointer()) + element_size * i, element_type);
+        element.Serialize(node.AddChildNode("element"));
+      }
+    }
+    else if (type == cSTRING_TYPE)
+    {
+      node.SetContent(*this->Get<std::string>());
+    }
     else if (type.GetTypeTraits() & trait_flags::cIS_STRING_SERIALIZABLE)
     {

tests/rtti.cpp

@@ -82 +82 @@
 static_assert(std::is_same<typename rrlib::rtti::NormalizedType<unsigned long>::type, typename std::conditional<sizeof(unsigned long) == 8, unsigned long long, unsigned int>::type>::value, "Invalid trait implementation");
 static_assert(IsImplicitlyConvertible<double, bool>::value, "Trait not implemented correctly");
+#ifdef _LIB_RRLIB_XML_PRESENT_
+static_assert(serialization::IsXMLSerializationDefaultImplementation<std::vector<std::string>>::value, "Trait not implemented correctly");
+static_assert(serialization::IsXMLSerializable<std::vector<std::string>>::value, "Trait not implemented correctly");
+static_assert((detail::TableLayoutFlags<std::vector<std::string>>::value & detail::eTLF_OTHER_SERIALIZATION) == 0, "Trait not implemented correctly");
+static_assert((detail::TableLayoutFlags<std::vector<bool>>::value & detail::eTLF_OTHER_SERIALIZATION) != 0, "Trait not implemented correctly");
+static_assert((detail::TableLayoutFlags<std::array<std::string, 3>>::value & detail::eTLF_OTHER_SERIALIZATION) == 0, "Trait not implemented correctly");
+static_assert((detail::TableLayoutFlags<std::array<bool, 3>>::value & detail::eTLF_OTHER_SERIALIZATION) == 0, "Trait not implemented correctly");
+#endif
 
 //----------------------------------------------------------------------
@@ -184 +192 @@
 
   template <typename T>
-  void TestGenericOperations(T& t)
+  void TestGenericOperationsBinary(T& t)
   {
     static_assert(rrlib::serialization::IsBinarySerializable<T>::value, "Trait not correctly implemented");
@@ -192 +200 @@
     copy->DeepCopyFrom(wrapper);
     RRLIB_UNIT_TESTS_EQUALITY_MESSAGE(std::string("Objects must be equal (type: ") + util::Demangle(typeid(T).name()) + ")", copy->Equals(wrapper), true);
+  }
+
+  template <typename T>
+  void TestGenericOperations(T& t)
+  {
+    TestGenericOperationsBinary(t);
+
+#ifdef _LIB_RRLIB_XML_PRESENT_
+
+    // Serialize to XML - and compare dumps
+    static_assert(rrlib::serialization::IsXMLSerializable<T>::value, "Trait not correctly implemented");
+    rrlib::xml::tDocument doc1, doc2;
+    doc1.AddRootNode("Test") << t;
+    tTypedConstPointer generic_t(&t);
+    generic_t.Serialize(doc2.AddRootNode("Test"));
+    std::string xml_dump = doc1.RootNode().GetXMLDump();
+    assert(xml_dump.length() > 12);
+    //std::cout << xml_dump << '\n' << doc2.RootNode().GetXMLDump() << '\n';
+    RRLIB_UNIT_TESTS_EQUALITY(xml_dump, doc2.RootNode().GetXMLDump());
+
+    // Deserialize from XML
+    std::unique_ptr<tGenericObject> copy(generic_t.GetType().CreateGenericObject());
+    copy->Deserialize(doc1.RootNode());
+    RRLIB_UNIT_TESTS_ASSERT(copy->GetData<T>() == t);
+#endif
   }
 
@@ -209 +242 @@
     std::array<std::vector<bool>, 2> test_vector_bool_array = { test_vector_bool, test_vector_bool };
     TestGenericOperations(test_vector_bool_array);
+    std::vector<std::string> test_string_vector = { "First String", "2nd String" };
+    TestGenericOperations(test_string_vector);
+    using serialization::tDataEncoding;
+    std::array<std::tuple<tDataEncoding, uint8_t, std::pair<double, std::string>>, 2> test_tuple_array = { std::make_tuple(tDataEncoding::XML, static_cast<uint8_t>(45), std::make_pair(4., "Txt")), std::make_tuple(tDataEncoding::STRING, static_cast<uint8_t>(141), std::make_pair(-0.1, "www")) };
+    TestGenericOperations(test_tuple_array);
 
     tBuffer buffer;
@@ -217 +255 @@
     }
     stream.Close();
-    TestGenericOperations(buffer);
+    TestGenericOperationsBinary(buffer);
   }