MetaType.h

#pragma once
 
#include <QCborValue>
#include <QJsonValue>
 
#include "Formatter.h"
#include "Logging.h"
#include "Uri.h"
#include "ReturnValue.h"
 
namespace knowCore
{
  struct MetaTypeTraits
  {
    enum {
      None                = 0,
      Comparable          = 1 << 1, 
      OnlyEqualComparable = 1 << 2, 
      ToString            = 1 << 3,
      FromString          = 1 << 4,
      ToByteArray         = 1 << 5,
      FromByteArray       = 1 << 6,
      DebugStreamOperator = 1 << 7,
      NumericType         = 1 << 8 
    };
  };
 
  enum class ComparisonOperator
  {
    Equal     = 1 << 1,
    AlmostEqual = 1 << 2,
    Inferior  = 1 << 3,
    GeoOverlaps  = 1 << 4,  
    GeoWithin    = 1 << 5,  
    GeoIntersects = 1 << 6, 
    GeoContains = 1 << 7, 
    GeoTouches = 1 << 8, 
    In = 1 << 9, 
  };
  enum class ArithmeticOperator
  {
    Addition, Substraction, Division, Multiplication
  };
  Q_DECLARE_FLAGS(ComparisonOperators, ComparisonOperator)
  enum class TypeCheckingMode
  {
    Safe, 
    Force 
  };
 
  template<typename _T_>
  class MetaTypeInformation;
  class MetaTypeRegistry;
  class Value;
  template<typename _T_>
  class HasMetaTypeInformation : public std::false_type {};
  template<typename _T_>
  inline constexpr bool HasMetaTypeInformationV = HasMetaTypeInformation<_T_>::value;
 
  class MetaTypes
  {
  public:
    static Uri uri(int _type);
    static int type(const Uri& _uri);
    static bool isNumericType(const Uri& _uri);
    static bool isDefined(const Uri& _uri);
    static bool canConvert(const Uri& _from, const Uri& _to, TypeCheckingMode _checking = TypeCheckingMode::Safe);
    static QList<Uri> aliases(const knowCore::Uri& _uri);
  };
 
  class AbstractDeserialisationContext
  {
  public:
    AbstractDeserialisationContext();
    virtual ~AbstractDeserialisationContext();
  };
 
  class AbstractSerialisationContext
  {
  public:
    AbstractSerialisationContext();
    virtual ~AbstractSerialisationContext();
  };
 
  class DeserialisationContexts
  {
  public:
    DeserialisationContexts();
    DeserialisationContexts(const DeserialisationContexts& _rhs);
    DeserialisationContexts& operator=(const DeserialisationContexts& _rhs);
    ~DeserialisationContexts();
    knowCore::ReturnValue<AbstractDeserialisationContext*> getContext(const knowCore::Uri& _uri) const;
    template<typename _T_>
    knowCore::ReturnValue<_T_*> getContext(const knowCore::Uri& _uri) const;
    void addContext(const knowCore::Uri& _uri, AbstractDeserialisationContext* _context);
  private:
    struct Private;
    QExplicitlySharedDataPointer<Private> d;
  };
 
  class SerialisationContexts
  {
  public:
    SerialisationContexts();
    SerialisationContexts(const SerialisationContexts& _rhs);
    SerialisationContexts& operator=(const SerialisationContexts& _rhs);
    ~SerialisationContexts();
    knowCore::ReturnValue<AbstractSerialisationContext*> getContext(const knowCore::Uri& _uri) const;
    template<typename _T_>
    knowCore::ReturnValue<_T_*> getContext(const knowCore::Uri& _uri) const;
    void addContext(const knowCore::Uri& _uri, AbstractSerialisationContext* _context);
  private:
    struct Private;
    QExplicitlySharedDataPointer<Private> d;
  };
  
  inline static const DeserialisationContexts& defaultDeserialisationContext()
  {
    static DeserialisationContexts contexts;
    return contexts;
  }
  inline static const SerialisationContexts& defaultSerialisationContext()
  {
    static SerialisationContexts contexts;
    return contexts;
  }
 
  class AbstractMetaTypeDefinition
  {
    friend class MetaTypeRegistry;
    friend class MetaTypes;
    friend class Value;
    template<typename>
    friend class MetaTypeInformation;
  protected:
    virtual ~AbstractMetaTypeDefinition();
    virtual knowCore::Uri uri() const = 0;
    virtual int qMetaTypeId() const = 0;
    virtual void* allocate() const = 0;
    virtual void* duplicate(const void*) const = 0;
    virtual void release(void* _value) const = 0;
    virtual bool compareEquals(const void* _lhs, const void* _rhs) const = 0;
    virtual ReturnValue<QByteArray> md5(const void* _value) const = 0;
    virtual ReturnValue<QJsonValue> toJsonValue(const void* _value, const SerialisationContexts& _contexts) const = 0;
    virtual ReturnVoid fromJsonValue(void* _value, const QJsonValue& _json_value, const DeserialisationContexts& _contexts) const = 0;
    virtual ReturnValue<QCborValue> toCborValue(const void* _value, const SerialisationContexts& _contexts) const = 0;
    virtual ReturnVoid fromCborValue(void* _value, const QCborValue& _cbor_value, const DeserialisationContexts& _contexts) const = 0;
    virtual ReturnValue<QString> printable(const void* _value) const = 0;
    virtual ReturnValue<QString> toRdfLiteral(const void* _value, const SerialisationContexts& _contexts) const = 0;
    virtual ReturnVoid fromRdfLiteral(void* _value, const QString& _serialised, const DeserialisationContexts& _contexts) const = 0;
  };
 
  class AbstractTypeConversion
  {
  public:
    virtual ~AbstractTypeConversion();
    virtual knowCore::Uri from() const = 0;
    virtual knowCore::Uri to() const = 0;
    virtual ReturnVoid convert(const void* _from, void* _to) const = 0;
  };
  class AbstractTypeComparator
  {
  public:
    virtual ~AbstractTypeComparator();
    virtual ComparisonOperator comparisonOperator() const = 0;
    virtual knowCore::Uri left() const = 0;
    virtual knowCore::Uri right() const = 0;
    virtual ReturnValue<bool> compare(const void* _left, const void* _right) const = 0;
  };
  class AbstractArithmeticOperator
  {
  public:
    virtual ~AbstractArithmeticOperator() = 0;
    virtual ArithmeticOperator arithmeticOperator() const = 0;
    virtual knowCore::Uri left() const = 0;
    virtual knowCore::Uri right() const = 0;
    virtual ReturnValue<knowCore::Value> compute(const void* _left, const void* _right) const = 0;
  };
 
  class AbstractToVariantMarshal;
 
  template<typename _T_>
  void registerMetaType();
 
  void registerMetaTypeAliases(const QList<Uri>& _aliases, const Uri& _to);
 
  template<typename _TFrom_, typename _TTo_>
  void registerConverter(TypeCheckingMode _conversionMode, const std::function<ReturnVoid(const _TFrom_*, _TTo_*)>& _converter);
  template<typename _TFrom_, typename _TTo_>
  void registerConverter();
  template<ComparisonOperator _operator_, typename _TLeft_, typename _TRight_>
  void registerComparator(const std::function<ReturnValue<bool>(const _TLeft_&, const _TRight_&)>& _comparator);
  template<ComparisonOperator _operator_, typename _TLeft_, typename _TRight_>
  void registerComparator();
  template<ArithmeticOperator _operator_, typename _TLeft_, typename _TRight_>
  void registerArithmeticOperator();
 
  template<typename _T_>
  void registerNumericType();
 
  class MetaTypeRegistry
  {
    template<typename _T_>
    friend class MetaTypeInformation;
    template<typename _T_>
    friend void registerMetaType();
    template<typename _TTo_, typename _TFrom_>
    friend void registerConverter(TypeCheckingMode _mode, const std::function<_TTo_(const _TFrom_&)>& _converter);
    template<typename _TFrom_, typename _TTo_>
    friend void registerConverter();
    template<ComparisonOperator _operator_, typename _TLeft_, typename _TRight_>
    friend void registerComparator(const std::function<ReturnValue<bool>(const _TLeft_&, const _TRight_&)>& _comparator);
    template<ComparisonOperator _operator_, typename _TLeft_, typename _TRight_>
    void friend registerComparator();
    friend void registerMetaTypeAliases(const QList<Uri>& _aliases, const Uri& _to);
    template<typename _T_>
    friend void registerNumericType();
    template<ArithmeticOperator _operator_, typename _TLeft_, typename _TRight_>
    friend void registerArithmeticOperator();
  private:
    static void registerType(AbstractMetaTypeDefinition* _definition);
    static void registerConverter(TypeCheckingMode _conversionMode, AbstractTypeConversion* _conversion);
    static void registerComparator(AbstractTypeComparator* _conversion);
    static void registerArithmeticOperator(AbstractArithmeticOperator* _operator);
    static bool canConvert(const knowCore::Uri& _from, const knowCore::Uri& _to, TypeCheckingMode _conversion = TypeCheckingMode::Safe);
    static void registerMetaTypeAliases(const QList<Uri>& _aliases, const Uri& _to);
    static void registerNumericType(const knowCore::Uri& _uri);
    static void registerToVariant(const knowCore::Uri& _uri, AbstractToVariantMarshal* _marshal);
  };
 
  template<typename _T_, class _Enabled_>
  class MetaTypeDefinition;
 
 
}
 
#define __KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS(__TYPE__, __DEFINITION__)              \
  namespace knowCore                                                    \
  {                                                                     \
    template<>                                                          \
    class HasMetaTypeInformation<__TYPE__> : public std::true_type {};  \
    template<>                                                          \
    class MetaTypeInformation<__TYPE__> {                               \
    public:                                                             \
      MetaTypeInformation();                                            \
      static knowCore::Uri uri();                                       \
      __DEFINITION__                                                    \
      static QList<knowCore::Uri> aliases()                             \
      {                                                                 \
        return knowCore::MetaTypes::aliases(uri());                     \
      }                                                                 \
      static bool isNumericType()                                       \
      {                                                                 \
        return MetaTypes::isNumericType(uri());                         \
      }                                                                 \
      template<typename _TOther_>                                       \
      static bool canConvertTo()                                        \
      {                                                                 \
        return knowCore::MetaTypeRegistry::canConvert(uri(),            \
                      MetaTypeInformation<_TOther_>::uri());            \
      }                                                                 \
      template<typename _TOther_>                                       \
      static bool canConvertFrom()                                      \
      {                                                                 \
        return knowCore::MetaTypeRegistry::canConvert(                  \
                      MetaTypeInformation<_TOther_>::uri(),             \
                      uri());                                           \
      }                                                                 \
      inline static int id() { return s_instance.m_id; }                \
    private:                                                            \
      void init_knowCoreMetaType();                                     \
      int m_id;                                                         \
      static MetaTypeInformation<__TYPE__> s_instance;                  \
    };                                                                  \
  }
 
#define __KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS_DEFINITION(__TYPE__)                                                                                                     \
  static AbstractMetaTypeDefinition* definition();                                                                                                                          \
  inline static ReturnValue<QByteArray> md5(const __TYPE__& _value)                                                                                                         \
  { return definition()->md5(&_value); }                                                                                                                                    \
  inline static ReturnValue<QJsonValue> toJsonValue(const __TYPE__& _value, const SerialisationContexts& _contexts = defaultSerialisationContext())                         \
  { return definition()->toJsonValue(&_value, _contexts); }                                                                                                                 \
  inline static ReturnValue<__TYPE__> fromJsonValue(const QJsonValue& _json_value, const DeserialisationContexts& _contexts = defaultDeserialisationContext())              \
  {                                                                                                                                                                         \
    __TYPE__ r;                                                                                                                                                             \
    KNOWCORE_RETURN_VALUE_TRY_VOID(definition()->fromJsonValue(&r, _json_value, _contexts));                                                                                \
    return kCrvSuccess(r);                                                                                                                                                  \
  }                                                                                                                                                                         \
  inline static ReturnValue<QCborValue> toCborValue(const __TYPE__& _value, const SerialisationContexts& _contexts = defaultSerialisationContext())                         \
  { return definition()->toCborValue(&_value, _contexts); }                                                                                                                 \
  inline static ReturnValue<__TYPE__> fromCborValue(const QCborValue& _cbor_value, const DeserialisationContexts& _contexts = defaultDeserialisationContext())              \
  {                                                                                                                                                                         \
    __TYPE__ r;                                                                                                                                                             \
    KNOWCORE_RETURN_VALUE_TRY_VOID(definition()->fromCborValue(&r, _cbor_value, _contexts));                                                                                \
    return kCrvSuccess(r);                                                                                                                                                  \
  }                                                                                                                                                                         \
  inline static ReturnValue<QString> printable(const __TYPE__& _value)                                                                                                      \
  { return definition()->printable(&_value); }                                                                                                                              \
  inline static ReturnValue<QString> toRdfLiteral(const __TYPE__& _value, const SerialisationContexts& _contexts = defaultSerialisationContext())                           \
  { return definition()->toRdfLiteral(&_value, _contexts); }                                                                                                                \
  inline static ReturnValue<__TYPE__> fromRdfLiteral(const QString& _serialised, const DeserialisationContexts& _contexts = defaultDeserialisationContext())                \
  {                                                                                                                                                                         \
    __TYPE__ r;                                                                                                                                                             \
    KNOWCORE_RETURN_VALUE_TRY_VOID(definition()->fromRdfLiteral(&r, _serialised, _contexts));                                                                               \
    return kCrvSuccess(r);                                                                                                                                                  \
  }
 
#define KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS(__TYPE__)                                                                                                                    \
  __KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS(__TYPE__, __KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS_DEFINITION(__TYPE__))
 
#define KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS_NO_DEFINITION(__TYPE__)              \
  __KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS(__TYPE__, )
 
#define KNOWCORE_DECLARE_KNOWCORE_METATYPE_NO_DEFINITION(_NS_, _TYPE_)              \
  KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS_NO_DEFINITION(_NS_::_TYPE_)              \
  namespace _NS_                                                                    \
  {                                                                                 \
    using _TYPE_ ## MetaTypeInformation = knowCore::MetaTypeInformation<_TYPE_>;    \
  }
 
#define KNOWCORE_DECLARE_KNOWCORE_METATYPE(_NS_, _TYPE_)                            \
  KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS(_NS_::_TYPE_)                            \
  namespace _NS_                                                                    \
  {                                                                                 \
    using _TYPE_ ## MetaTypeInformation = knowCore::MetaTypeInformation<_TYPE_>;    \
  }
 
#define KNOWCORE_DECLARE_FULL_METATYPE(_NS_, _TYPE_)                \
  Q_DECLARE_METATYPE(_NS_::_TYPE_)                                  \
  KNOWCORE_DECLARE_KNOWCORE_METATYPE(_NS_, _TYPE_)
 
#define KNOWCORE_DECLARE_FULL_METATYPE_NO_DEFINITION(_NS_, _TYPE_)  \
  Q_DECLARE_METATYPE(_NS_::_TYPE_)                                  \
  KNOWCORE_DECLARE_KNOWCORE_METATYPE_NO_DEFINITION(_NS_, _TYPE_)
 
KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS(QString)
KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS(QStringList)
KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS(QByteArray)
KNOWCORE_DECLARE_KNOWCORE_METATYPE_KLASS(QList<QByteArray>)
KNOWCORE_DECLARE_KNOWCORE_METATYPE(knowCore, Uri) // <- this has to be here and not Uri.h, because of circular dependenct between Uri.h and MetaType.h
KNOWCORE_CORE_DECLARE_FORMATTER_ENUM(knowCore::ComparisonOperator, Equal, Inferior, GeoOverlaps, GeoIntersects, GeoWithin, GeoContains, GeoTouches, In)
KNOWCORE_CORE_DECLARE_FORMATTER_ENUM(knowCore::ArithmeticOperator, Addition, Substraction, Multiplication, Division)