Subject.h

#pragma once
 
#include <QSharedDataPointer>
 
#include <knowCore/ReturnValue.h>
#include <knowCore/Uris/Uris.h>
 
#include "Forward.h"
 
class QString;
 
namespace knowRDF
{
  class Subject
  {
  public:
    enum class Type
    {
      Undefined, Uri, BlankNode, Variable
    };
  public:
    Subject();
    Subject(const QString& _string, Type _type);
    Subject(const knowCore::Uri& _uri);
    Subject(const knowCore::Uri& _base, const QString& _suffix);
    Subject(const BlankNode& _blankNodeRef);
    Subject(const Subject& _rhs);
    template<typename _T_, std::enable_if_t<knowCore::Uris::IsUriDefinitionV<_T_>, int> = 0>
    Subject(const _T_& _t) : Subject(knowCore::Uri(_t)) {}
    Subject& operator=(const Subject& _rhs);
    ~Subject();
    bool operator==(const Subject& _rhs) const;
    Type type() const;
    knowCore::Uri uri() const;
    BlankNode blankNode() const;
    QString variableName() const;
    QByteArray md5() const;
    QJsonValue toJsonValue() const;
    static knowCore::ReturnValue<Subject> fromJsonValue(const QJsonValue& _value);
    QCborValue toCborValue() const;
    static knowCore::ReturnValue<Subject> fromCborValue(const QCborValue& _value);
  private:
    struct Private;
    QSharedDataPointer<Private> d;
  };
  uint qHash(const Subject& key, uint seed = 0);
}
 
KNOWCORE_CORE_DECLARE_FORMATTER(knowRDF::Subject)
{
  switch(p.type())
  {
    case knowRDF::Subject::Type::Undefined:
      break;
    case knowRDF::Subject::Type::Uri:
      return format_to(ctx.out(), "uri({})", p.uri());
    case knowRDF::Subject::Type::BlankNode:
      return format_to(ctx.out(), "blank_node({})", p.blankNode());
    case knowRDF::Subject::Type::Variable:
      return format_to(ctx.out(), "variable(?{})", p.variableName());
  }
  return forward("undefined()", ctx);
 
}