runtimeValue.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
******************************************************************************/


#ifndef runtimeValue_H_
#define runtimeValue_H_

#include "lgrUtil.h"
#include <lgrUtil/absoluteTime.h>
#include "base64Data.h"

#include <vlutil/vlString.h>
#include <vlutil/vlSmartPointers.h>

#include <ctype.h>
#include <cstring>
#include <cstdio>
#include <string>
#include <vector>

namespace MAKLogger
{
   class DT_DLL_LGRUTIL DtAnyValue
   {
   public:


      DtAnyValue() {}

      virtual ~DtAnyValue() {}

      virtual DtAnyValue*     clone() const = 0;

      virtual bool            sameType(const DtAnyValue* const base) const
      { return this->typeId() == base->typeId(); }

      virtual const DtString& type() const = 0;
      virtual DtString        serialize() const = 0;

      virtual int             typeId() const = 0;
   };

   typedef std::shared_ptr<DtAnyValue> DtAnyValueSP;

   template <typename T>
   class DtValue : public DtAnyValue
   {
   public:

      DtValue(const T& value);

      virtual ~DtValue();

      virtual DtAnyValue* clone() const;

      static DtValue<T>* cast(DtAnyValue* base);

      static const DtValue<T>* cast(const DtAnyValue* base);

      static bool isType(const DtAnyValue* base);

      static DtValue<T>* deserialize(const DtString& value);

      operator       T();

      operator const T() const;

      virtual int typeId() const;

      virtual const DtString& type() const;

      virtual DtString  serialize() const;

      static int theTypeId();

      static const DtString& theType();

      DT_DLL_LGRUTIL static DtString (*theSerializeFunction)(const T&);

      DT_DLL_LGRUTIL static T (*theDeserializeFunction)(const DtString&);

      T myValue;

   };


   DT_DLL_LGRUTIL std::vector<DtString> deserializeList(const DtString&);

   template <typename T>
   class DtValueList
   {
   public:

      static DtValue<std::vector<T> > deserialize(const DtString&);

      static std::vector<T> deserializeMembers(const std::vector<DtString>& values);

      static DtValue<std::vector<T> >* deserializeMembersToPtr(const std::vector<DtString>& values);

      static std::vector<T> deserializeListMembers(const DtString&);

      static DtString serializeList(const std::vector<T>& list);
   };

   template <typename T>
   DtAnyValue* DtWrapValue(const T& input)
   {
      return new DtValue<T>(input);
   }


   DT_DLL_LGRUTIL unsigned int hash( const char *k);

   #define DT_UNIQUE_INT (hash(__FILE__)+__LINE__)



   #define DtDeclareRuntimeType(type)\
   template<>                                                \
   DT_DLL_LGRUTIL int DtValue< type >::theTypeId();          \
   template<>                                                \
   DT_DLL_LGRUTIL const DtString& DtValue< type >::theType();\
   template<>                                                             \
   DT_DLL_LGRUTIL int DtValue< std::vector<type> >::theTypeId();          \
   template<>                                                             \
   DT_DLL_LGRUTIL const DtString& DtValue< std::vector<type> >::theType();


   #define DtDefineRuntimeType(type)                                    \
   template<>                                                           \
   int DtValue<type>::theTypeId()                                       \
   {                                                                    \
      static int id = DT_UNIQUE_INT; return id;                         \
   }                                                                    \
                                                                        \
   template<>                                                           \
   const DtString& DtValue<type>::theType()                             \
   {                                                                    \
      static DtString typeName(#type);                                  \
      return typeName;                                                  \
   }                                                                    \
                                                                        \
   template<>                                                           \
   DtString (*DtValue<type>::theSerializeFunction)(const type&) = 0;    \
   template<>                                                           \
   type (*DtValue<type>::theDeserializeFunction)(const DtString&) = 0;  \
                                                                        \
   template<>                                                           \
   int DtValue<std::vector<type> >::theTypeId()                         \
   {                                                                    \
      static int id = DT_UNIQUE_INT; return id;                         \
   }                                                                    \
                                                                        \
   template<>                                                           \
   const DtString& DtValue<std::vector<type> >::theType()               \
   {                                                                    \
      static DtString typeName("std::vector<" #type ">");               \
      return typeName;                                                  \
   }                                                                    \
                                                                        \
   template<>                                                           \
   DtString (*DtValue<std::vector<type> >::theSerializeFunction)(       \
   const std::vector<type>&) = 0;                                       \
                                                                        \
   template<>                                                           \
   std::vector<type> (*DtValue<std::vector<type> >::theDeserializeFunction) \
   (const DtString&) = 0;


   #define DtDefineSerializableRuntimeType(type)                     \
   template<>                                                        \
   int DtValue<type>::theTypeId()                                    \
   {                                                                 \
      static int id = DT_UNIQUE_INT; return id;                      \
   }                                                                 \
                                                                     \
   template<>                                                        \
   const DtString& DtValue<type>::theType()                          \
   {                                                                 \
      static DtString typeName(#type);                               \
      return typeName;                                               \
   }                                                                 \
   template<>                                                        \
   int DtValue<std::vector<type> >::theTypeId()                      \
   {                                                                 \
      static int id = DT_UNIQUE_INT; return id;                      \
   }                                                                 \
                                                                     \
   template<>                                                        \
   const DtString& DtValue<std::vector<type> >::theType()            \
   {                                                                 \
      static DtString typeName("std::vector<" #type ">" );           \
      return typeName;                                               \
   }                                                                 \
                                                                     \
   DtString serializeList##type(const std::vector<type>& input)      \
   {                                                                 \
      return DtValueList<type>::serializeList(input);                \
   }                                                                 \
                                                                     \
                                                                     \
   std::vector<type> deserializeList##type(const DtString& input)    \
   {                                                                 \
      return DtValueList<type>::deserializeListMembers(input);       \
   }                                                                 \
                                                                     \
template<>                                                           \
DtString (*DtValue<std::vector<type> >::theSerializeFunction)(       \
const std::vector<type>&) = serializeList##type;                     \
                                                                     \
template<>                                                           \
std::vector<type> (*DtValue<std::vector<type> >::theDeserializeFunction) \
(const DtString&) = deserializeList##type;


   DtDeclareRuntimeType(unsigned char)


   #define runtimeValue_INC_
   #include "runtimeValue.inl"
   #undef runtimeValue_INC_

}

#endif