Object.h

#pragma once
 
#include <knowCore/Uris/Uris.h>
 
#include "BlankNode.h"
#include "Literal.h"
 
namespace knowRDF
{
  class Object
  {
  public:
    enum class Type
    {
      Undefined, Uri, BlankNode, Literal, Variable
    };
  public:
    Object();
    Object(const QString& _string, Type _type);
    Object(const knowCore::Uri& _uri);
    Object(const BlankNode& _blankNodeRef);
    Object(const Literal& _literal);
    template<typename _T_, std::enable_if_t<knowCore::Uris::IsUriDefinitionV<_T_>, int> = 0>
    Object(const _T_& _t) : Object(knowCore::Uri(_t)) {}
    template<typename _T_>
    static Object fromValue(const _T_& _value, const Lang& _lang = Lang(QString()));
    template<typename _T_>
    static knowCore::ReturnValue<Object> fromValue(const knowCore::Uri& _dataTypeUri, const _T_& _value, const QString& _lang = QString(), knowCore::TypeCheckingMode _conversion = knowCore::TypeCheckingMode::Safe);
    //       Object(const knowCore::Uri& _uri, const char* _value, const QString& _lang = QString());
    Object(const Object& _rhs);
    Object& operator=(const Object& _rhs);
    ~Object();
    bool operator==(const Object& _rhs) const;
    Type type() const;
    knowCore::Uri uri() const;
    BlankNode blankNode() const;
    Literal literal() const;
    QString variableName() const;
    knowCore::ReturnValue<QByteArray> md5() const;
    knowCore::ReturnValue<QJsonValue> toJsonValue(const knowCore::SerialisationContexts&) const;
    static knowCore::ReturnValue<Object> fromJsonValue(const QJsonValue& _value, const knowCore::DeserialisationContexts& _context);
    knowCore::ReturnValue<QCborValue> toCborValue(const knowCore::SerialisationContexts&) const;
    static knowCore::ReturnValue<Object> fromCborValue(const QCborValue& _value, const knowCore::DeserialisationContexts& _context);
  private:
    struct Private;
    QSharedDataPointer<Private> d;
  };
  template<typename _T_>
  Object Object::fromValue(const _T_& _value, const Lang& _lang)
  {
    return Literal::fromValue<_T_>(_value, _lang);
  }
  template<typename _T_>
  knowCore::ReturnValue<Object> Object::fromValue(const knowCore::Uri& _dataTypeUri, const _T_& _value, const QString& _lang, knowCore::TypeCheckingMode _conversion)
  {
    const auto [success, literal, message] = Literal::fromValue(_dataTypeUri, _value, _lang, _conversion);
    if(success)
    {
      return kCrvSuccess(Object(literal));
    } else {
      return kCrvError(message);
    }
  }
  uint qHash(const Object& key, uint seed = 0);
}
 
 
KNOWCORE_CORE_DECLARE_FORMATTER(knowRDF::Object)
{
  switch(p.type())
  {
    case knowRDF::Object::Type::Undefined:
      break;
    case knowRDF::Object::Type::Uri:
      return format_to(ctx.out(), "uri({})", p.uri());
    case knowRDF::Object::Type::BlankNode:
      return format_to(ctx.out(), "blank_node({})", p.blankNode());
    case knowRDF::Object::Type::Literal:
      return format_to(ctx.out(), "literal({})", p.literal());
    case knowRDF::Object::Type::Variable:
      return format_to(ctx.out(), "variable(?{})", p.variableName());
  }
  return forward("undefined()", ctx);
  
}
 
KNOWCORE_CORE_DECLARE_FORMATTER_ENUM(knowRDF::Object::Type, Undefined, Uri, BlankNode, Literal, Variable);
 
#include <knowCore/MetaType.h>
KNOWCORE_DECLARE_FULL_METATYPE(knowRDF, Object)