Value.h

#pragma once
 
#include <QSharedDataPointer>
 
#include <knowCore/Forward.h>
 
#include "MetaType.h"
#include "ReturnValue.h"
 
namespace knowCore
{
  class Value
  {
    Value(const Uri& _datatype, const AbstractMetaTypeDefinition* _definition, void* _data);
    Value(const Uri& _datatype, const Uri& _maindatatype, const AbstractMetaTypeDefinition* _definition, void* _data);
  public:
    Value();
    Value(const Value& _rhs);
    Value& operator=(const Value& _rhs);
    ~Value();
 
    template<typename _T_>
    static inline Value fromValue(const _T_& _value);
    static inline ReturnValue<Value> fromValue(const QVariant& _value);
    template<typename _T_>
    static inline ReturnValue<Value> fromValue(const Uri& _datatype, const _T_& _value, TypeCheckingMode _conversion = TypeCheckingMode::Safe);
    static ReturnValue<Value> fromVariant(const Uri& _datatype, const QVariant& _value, TypeCheckingMode _conversion = TypeCheckingMode::Safe);
    static ReturnValue<Value> fromVariant(const QVariant& _variant);
    
    QVariant toVariant() const;
    Uri datatype() const;
    bool isEmpty() const;
    bool operator<(const Value& _rhs) const;
    bool operator==(const Value& _rhs) const;
    bool operator!=(const Value& _rhs) const { return not (*this == _rhs); }
    ReturnValue<bool> compare(const Value& _value, ComparisonOperators _operators) const;
    ReturnValue<Value> convert(const Uri& _uri, TypeCheckingMode _conversion = TypeCheckingMode::Safe) const;
    ReturnValue<Value> compute(const Value& _value, ArithmeticOperator _operator) const;
    template<typename _T_>
    inline ReturnValue<_T_> value(TypeCheckingMode _conversion = TypeCheckingMode::Safe) const;
    template<typename _T_>
    inline _T_ value(const _T_& _default, TypeCheckingMode _conversion = TypeCheckingMode::Safe) const;
    template<typename _T_>
    inline bool canConvert(TypeCheckingMode _conversion = TypeCheckingMode::Safe) const;
    bool canConvert(const Uri& _uri, TypeCheckingMode _conversion = TypeCheckingMode::Safe) const;
    template<typename _T_>
    inline bool is() const;
    ReturnValue<QByteArray> md5() const;
    ReturnValue<QJsonValue> toJsonValue(const SerialisationContexts& _contexts = defaultSerialisationContext()) const;
    static ReturnValue<Value> fromJsonValue(const Uri& _datatype, const QJsonValue& _value, const DeserialisationContexts& _context = defaultDeserialisationContext());
    template<typename _T_>
    static ReturnValue<_T_> fromJsonValue(const QJsonValue& _value, const DeserialisationContexts& _context = defaultDeserialisationContext());
    ReturnValue<QCborValue> toCborValue(const SerialisationContexts& _contexts = defaultSerialisationContext()) const;
    static ReturnValue<Value> fromCborValue(const Uri& _datatype, const QCborValue& _value, const DeserialisationContexts& _context = defaultDeserialisationContext());
    ReturnValue<QString> toRdfLiteral(const SerialisationContexts& _contexts = defaultSerialisationContext()) const;
    static ReturnValue<Value> fromRdfLiteral(const Uri& _datatype, const QString& _value, const DeserialisationContexts& _context = defaultDeserialisationContext());
    ReturnValue<QString> printable() const;
 
    ReturnValue<QJsonObject> toJsonObject(const SerialisationContexts& _contexts = defaultSerialisationContext()) const;
    static ReturnValue<Value> fromJsonObject(const QJsonObject& _value, const DeserialisationContexts& _context = defaultDeserialisationContext());
    ReturnValue<QCborMap> toCborMap(const SerialisationContexts& _contexts = defaultSerialisationContext()) const;
    static ReturnValue<Value> fromCborMap(const QCborMap& _value, const DeserialisationContexts& _context = defaultDeserialisationContext());
 
    ReturnValue<ValueList> toList() const;
    ReturnValue<ValueHash> toHash() const;
  private:
    const AbstractMetaTypeDefinition* definition() const;
  private:
    // Access to metatype stuff
    template<typename _T_>
    static const AbstractMetaTypeDefinition* getDefinition()
    { return MetaTypeInformation<_T_>::definition(); }
    static const AbstractMetaTypeDefinition* getDefinition(const Uri& _datatype);
    static const AbstractMetaTypeDefinition* getDefinition(int _id);
    const void* data() const;
    template<typename _T_>
    const AbstractTypeConversion* converterTo(TypeCheckingMode _conversion) const
    { return converterTo(MetaTypeInformation<_T_>::uri(), _conversion); }
    const AbstractTypeConversion* converterTo(const Uri& _datatype, TypeCheckingMode _conversion) const;
    template<typename _T_>
    const AbstractTypeConversion* converterFrom(TypeCheckingMode _conversion) const
    { return converterFrom(MetaTypeInformation<_T_>::uri()); }
    const AbstractTypeConversion* converterFrom(const Uri& _datatype, TypeCheckingMode _conversion) const;
    template<typename _TFrom_, typename _TTo_>
    static const AbstractTypeConversion *converterBetween(TypeCheckingMode _conversion)
    { return converterBetween(MetaTypeInformation<_TFrom_>::uri(), MetaTypeInformation<_TTo_>::uri(), _conversion);}
    static const AbstractTypeConversion* converterBetween(const Uri& _from, const Uri& _to, TypeCheckingMode _conversion);
 
    static const AbstractTypeConversion* converter(const Uri& _from, const Uri& _to, TypeCheckingMode _conversion);
  private:
    struct Private;
    QSharedDataPointer<Private> d;
  };
  uint qHash(const Value& key, uint seed = 0);
 
  template<typename _T_>
  inline Value Value::fromValue(const _T_& _value)
  {
    const AbstractMetaTypeDefinition* def = getDefinition<_T_>();
    KNOWCORE_ASSERT(def);
    return Value(def->uri(), def, def->duplicate(&_value));
  }
  template<typename _T_>
  inline ReturnValue<Value> Value::fromValue(const Uri& _datatype, const _T_& _value, TypeCheckingMode _conversion)
  {
    const AbstractMetaTypeDefinition* def_1 = getDefinition<_T_>();
    const AbstractMetaTypeDefinition* def_2 = getDefinition(_datatype);
    if(def_1 != def_2)
    {
      const AbstractTypeConversion* converter = Value::converter(MetaTypeInformation<_T_>::uri(), _datatype, _conversion);
      if(converter)
      {
        void* data = def_2->allocate();
        KNOWCORE_RETURN_VALUE_TRY_VOID(converter->convert(&_value, data));
        return kCrvSuccess(Value(_datatype, def_2, data));
      }
      return kCrvError("{0} is not alias of type '{1}' with uri '{2}' and no conversion from '{2}' to '{0}'.", _datatype, prettyTypename<_T_>(), MetaTypeInformation<_T_>::uri());
    }
    if(def_1)
    {
      return kCrvSuccess(Value(_datatype, def_1, def_1->duplicate(&_value)));
    } else {
      return kCrvError("Type '{}' with datatype '{}' is not defined!", prettyTypename<_T_>(), _datatype);
    }
  }
  template<>
  inline ReturnValue<Value> Value::fromValue<knowCore::Value>(const Uri& _datatype, const knowCore::Value& _value, TypeCheckingMode _conversion)
  {
    return _value.convert(_datatype, _conversion);
  }
  inline ReturnValue<Value> Value::fromValue(const QVariant& _value)
  {
    return fromVariant(_value);
  }
  template<>
  inline ReturnValue<Value> Value::fromValue<QVariant>(const Uri& _datatype, const QVariant& _value, TypeCheckingMode _conversion)
  {
    return fromVariant(_datatype, _value, _conversion);
  }
 
  template<typename _T_>
  inline ReturnValue<_T_> Value::value(TypeCheckingMode _conversion) const
  {
    if(MetaTypeInformation<_T_>::uri() == datatype() or getDefinition<_T_>() == definition())
    {
      return kCrvSuccess(_T_(*reinterpret_cast<const _T_*>(data())));
    }
    // First: try to convert directly
    if(const AbstractTypeConversion* converter = converterTo<_T_>(_conversion))
    {
      _T_ r;
      converter->convert(data(), &r);
      return kCrvSuccess(r);
    } // Second: some types can be converted to a value (mostly usefull for knowRDF::Literal) and then from that value to _T_
    else if(const AbstractTypeConversion* converter = converterTo<Value>(_conversion))
    {
      Value val;
      KNOWCORE_RETURN_VALUE_TRY_VOID(converter->convert(data(), &val));
      return val.value<_T_>();
    }
    // Third some types have custom converters from Value (mostly knowRDF::Literal)
    else if(const AbstractTypeConversion* converter = converterBetween<knowCore::Value, _T_>(_conversion))
    {
      _T_ val;
      KNOWCORE_RETURN_VALUE_TRY_VOID(converter->convert(this, &val));
      return kCrvSuccess(val);
    }
    return kCrvError("cannot convert from '{}' to '{}'", datatype(), MetaTypeInformation<_T_>::uri());
  }
  template<typename _T_>
  inline _T_ Value::value(const _T_& _default, TypeCheckingMode _conversion) const
  {
    auto const& [s, v, m] = value<_T_>(_conversion);
    return s ? v : _default;
  }
  template<typename _T_>
  inline bool Value::canConvert(TypeCheckingMode _conversion) const
  {
    return canConvert(MetaTypeInformation<_T_>::uri(), _conversion);
  }
  template<typename _T_>
  inline bool Value::is() const
  {
    return definition()->uri() == MetaTypeInformation<_T_>::uri();
  }
  template<typename _T_>
  inline ReturnValue<_T_> Value::fromJsonValue(const QJsonValue& _value, const DeserialisationContexts& _context)
  {
    KNOWCORE_RETURN_VALUE_TRY(val, fromJsonValue(MetaTypeInformation<_T_>::uri(), _value, _context));
    return val.template value<_T_>();
  }
 
  template<typename _T_>
  class ValueCast
  {
  public:
    ValueCast(const knowCore::Value& _val, TypeCheckingMode _conversion = TypeCheckingMode::Safe)
    {
      auto const& [s, t, m] = _val.value<_T_>(_conversion);
      m_success = s;
      m_t = t;
    }
    operator bool() { return m_success; }
    const _T_& value() const {
      KNOWCORE_ASSERT(m_success);
      return m_t;
    }
    _T_& value() {
      KNOWCORE_ASSERT(m_success);
      return m_t;
    }
    operator const _T_&() const {
      return value();
    }
    _T_* operator->() { return &value(); }
    _T_* operator->() const { return &value(); }
  private:
    bool m_success;
    _T_ m_t;
  };
  template<typename _T_>
  class ValueIs
  {
  public:
    ValueIs(const knowCore::Value& _val)
    {
      if(_val.datatype() == MetaTypeInformation<_T_>::uri())
      {
        m_success = true;
        m_t = _val.value<_T_>().expectSuccess();
      } else {
        m_success = false;
      }
    }
    operator bool() { return m_success; }
    const _T_& value() const {
      KNOWCORE_ASSERT(m_success);
      return m_t;
    }
    _T_& value() {
      KNOWCORE_ASSERT(m_success);
      return m_t;
    }
    operator const _T_&() const {
      return value();
    }
    _T_* operator->() { return &value(); }
    _T_* operator->() const { return &value(); }
  private:
    bool m_success;
    _T_ m_t;
  };
}
 
KNOWCORE_CORE_DECLARE_FORMATTER(knowCore::Value)
{
  auto const [success, value, message] = p.printable();
  if(success)
  {
    return format_to(ctx.out(),
                    "{}({})",
                    p.datatype(),
                    value);
  } else {
    return format_to(ctx.out(),
                    "{}(error: '{}')", p.datatype(), message);
  }
}
 
#include <knowCore/MetaType.h>
KNOWCORE_DECLARE_FULL_METATYPE_NO_DEFINITION(knowCore, Value)