.. _program_listing_file__tmp_ws_src_data_tamer_data_tamer_cpp_include_data_tamer_custom_types.hpp:

Program Listing for File custom_types.hpp
=========================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_data_tamer_data_tamer_cpp_include_data_tamer_custom_types.hpp>` (``/tmp/ws/src/data_tamer/data_tamer_cpp/include/data_tamer/custom_types.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include <mutex>
   #include <optional>
   
   #include "data_tamer/types.hpp"
   #include "data_tamer/contrib/SerializeMe.hpp"
   
   namespace DataTamer
   {
   
   template <class T>
   struct TypeDefinition
   {
     std::string typeName() const;
   
     template <class Function>
     void typeDef(const T& obj, Function& addField);
   };
   
   class CustomSerializer
   {
   public:
     using Ptr = std::shared_ptr<CustomSerializer>;
   
     virtual ~CustomSerializer() = default;
     // name of the type, to be written in the schema string.
     virtual const std::string& typeName() const = 0;
   
     // optional custom schema of the type
     virtual std::optional<CustomSchema> typeSchema() const { return std::nullopt; }
     // size in bytes of the serialized object.
     // Needed to pre-allocate memory in the buffer
     virtual size_t serializedSize(const void* instance) const = 0;
   
     // true if the method serializedSize will ALWAYS return the same value
     virtual bool isFixedSize() const = 0;
   
     // serialize an object into a buffer.
     virtual void serialize(const void* instance, SerializeMe::SpanBytes&) const = 0;
   };
   
   //------------------------------------------------------------------
   
   // This derived class is used automatically by all the types
   // that have a template specialization of TypeDefinition<T>
   template <typename T>
   class CustomSerializerT : public CustomSerializer
   {
   public:
     CustomSerializerT(const std::string& type_name = TypeDefinition<T>().typeName());
   
     const std::string& typeName() const override;
   
     size_t serializedSize(const void* src_instance) const override;
   
     bool isFixedSize() const override;
   
     void serialize(const void* src_instance,
                    SerializeMe::SpanBytes& dst_buffer) const override;
   
   private:
     std::string _name;
     size_t _fixed_size = 0;
   };
   
   class TypesRegistry
   {
   public:
     template <typename T>
     CustomSerializer::Ptr addType(const std::string& type_name,
                                   bool skip_if_present = false);
   
     template <typename T>
     [[nodiscard]] CustomSerializer::Ptr getSerializer();
   
   private:
     std::unordered_map<std::string, CustomSerializer::Ptr> _types;
     std::recursive_mutex _mutex;
   };
   
   //------------------------------------------------------------------
   //------------------------------------------------------------------
   //------------------------------------------------------------------
   
   template <template <class, class> class Container, class T, class... TArgs>
   struct TypeDefinition<Container<T, TArgs...>>
   {
     std::string typeName() const { return TypeDefinition<T>().typeName(); }
   };
   
   template <typename T, size_t N>
   struct TypeDefinition<std::array<T, N>>
   {
     std::string typeName() const { return TypeDefinition<T>().typeName(); }
   };
   
   template <class C, typename T>
   T getPointerType(T C::*v);
   
   template <class T, typename = void>
   struct has_typedef_with_object : std::false_type
   {
   };
   
   inline void DummyAddField(const char*, const void*){}
   using EmptyFunc = decltype(DummyAddField);
   
   template <class T>
   struct has_typedef_with_object<T,
                                  decltype(TypeDefinition<T>().typeDef(
                                      std::declval<const T&>(), std::declval<EmptyFunc&>()))>
     : std::true_type
   {
   };
   
   template <class T, typename = void>
   struct has_typedef_with_member : std::false_type
   {
   };
   
   template <class T>
   struct has_typedef_with_member<T, decltype(TypeDefinition<T>().typeDef(
                                         std::declval<EmptyFunc&>()))> : std::true_type
   {
   };
   
   // Recursive function to compute if a type has fixed size (at compile time).
   // Used mainly by the CustomSerializerT constructor.
   template <typename T>
   inline void GetFixedSize(bool& is_fixed_size, size_t& fixed_size)
   {
     if constexpr (IsNumericType<T>())
     {
       fixed_size += sizeof(T);
     }
     else
     {
       constexpr auto info = SerializeMe::container_info<T>();
       if constexpr (info.is_container && info.size == 0)
       {
         // vector
         is_fixed_size = false;
       }
       else if constexpr (info.is_container && info.size >= 0)
       {
         // array
         size_t obj_size;
         using Type = typename SerializeMe::container_info<T>::value_type;
         GetFixedSize<Type>(is_fixed_size, obj_size);
         fixed_size += info.size * obj_size;
       }
       else if (is_fixed_size)
       { 
         if constexpr (has_typedef_with_object<T>())
         {
           auto funcA = [&](const char*, auto const* member) {
             using MemberType = std::remove_cv_t<std::remove_reference_t<decltype(*member)>>;
             GetFixedSize<MemberType>(is_fixed_size, fixed_size);
           };
           TypeDefinition<T>().typeDef({}, funcA);
         }
         else
         {
           auto funcB = [&](const char*, auto const& member) {
             using MemberType = decltype(getPointerType(member));
             GetFixedSize<MemberType>(is_fixed_size, fixed_size);
           };
           TypeDefinition<T>().typeDef(funcB);
         }
       }
     }
   }
   
   template <typename T>
   inline CustomSerializerT<T>::CustomSerializerT(const std::string& type_name) :
     _name(type_name)
   {
     static_assert(!SerializeMe::container_info<T>().is_container, "Don't pass containers a "
                                                                   "template type");
   
     bool is_fixed_size = true;
     GetFixedSize<T>(is_fixed_size, _fixed_size);
     if (!is_fixed_size)
     {
       _fixed_size = 0;
     }
   }
   
   template <typename T>
   inline const std::string& CustomSerializerT<T>::typeName() const
   {
     return _name;
   }
   
   template <typename T>
   inline size_t CustomSerializerT<T>::serializedSize(const void* src_instance) const
   {
     if (_fixed_size != 0)
     {
       return _fixed_size;
     }
     const auto* obj = static_cast<const T*>(src_instance);
     return SerializeMe::BufferSize(*obj);
   }
   
   template <typename T>
   inline bool CustomSerializerT<T>::isFixedSize() const
   {
     return _fixed_size > 0;
   }
   
   template <typename T>
   inline void CustomSerializerT<T>::serialize(const void* src_instance,
                                               SerializeMe::SpanBytes& dst_buffer) const
   {
     const auto* obj = static_cast<const T*>(src_instance);
     SerializeMe::SerializeIntoBuffer(dst_buffer, *obj);
   }
   
   template <typename T>
   inline CustomSerializer::Ptr TypesRegistry::getSerializer()
   {
     static_assert(!IsNumericType<T>(), "You don't need to create a serializer for a "
                                        "numerical type.");
     static_assert(!SerializeMe::container_info<T>().is_container, "Don't pass containers "
                                                                   "as template type");
   
     std::scoped_lock lk(_mutex);
     const auto type_name = TypeDefinition<T>().typeName();
     auto it = _types.find(type_name);
   
     if (it == _types.end())
     {
       CustomSerializer::Ptr serializer = std::make_shared<CustomSerializerT<T>>(type_name);
       _types[type_name] = serializer;
       return serializer;
     }
     return it->second;
   }
   
   template <typename T>
   inline CustomSerializer::Ptr TypesRegistry::addType(const std::string& type_name,
                                                       bool skip_if_present)
   {
     static_assert(!IsNumericType<T>(), "You don't need to create a serializer for a "
                                        "numerical type.");
     static_assert(!SerializeMe::container_info<T>().is_container, "Don't pass containers "
                                                                   "as template type");
   
     std::scoped_lock lk(_mutex);
     if (skip_if_present && _types.count(type_name) != 0)
     {
       return {};
     }
     CustomSerializer::Ptr serializer = std::make_shared<CustomSerializerT<T>>(type_name);
     _types[type_name] = serializer;
     return serializer;
   }
   
   }   // namespace DataTamer
   
   // namespace wrapping
   // Forward DataTamer::TypeDefinition to SerializeMe::TypeDefinition
   namespace SerializeMe
   {
   
   template <class T>
   inline std::string TypeDefinition<T>::typeName() const
   {
     return DataTamer::TypeDefinition<T>().typeName();
   }
   
   template <class T>
   template <class Function>
   void TypeDefinition<T>::typeDef(const T& obj, Function& addField)
   {
     if constexpr (DataTamer::has_typedef_with_object<T>())
     {
       DataTamer::TypeDefinition<T>().typeDef(obj, addField);
     }
     else
     {
       auto func = [&obj, &addField](const char* name, const auto& member) {
         addField(name, &(obj.*member));
       };
       DataTamer::TypeDefinition<T>().typeDef(func);
     }
   }
   
   }   // namespace SerializeMe