Literal.h

#pragma once
 
#include <knowCore/NamedType.h>
#include <knowCore/Value.h>
 
namespace knowRDF
{
  using Lang  = knowCore::NamedType<QString, struct LangTag>;
  class Literal : public knowCore::Value
  {
    Literal(const knowCore::Uri& _datatype, const knowCore::Value& _rhs, const QString& _lang = QString());
  public:
    Literal();
    Literal(const knowCore::Value& _rhs, const QString& _lang = QString());
    Literal(const Literal& _rhs);
    Literal& operator=(const Literal& _rhs);
    ~Literal();
    template<typename _T_>
    static Literal fromValue(const _T_& _value, const Lang& _lang = Lang(QString()));
    static knowCore::ReturnValue<Literal> fromValue(const knowCore::Value& _value, const Lang& _lang);
    static knowCore::ReturnValue<Literal> fromValue(const Literal& _value, const Lang& _lang = Lang(QString()));
    static knowCore::ReturnValue<Literal> fromValue(const QVariant& _value, const Lang& _lang = Lang(QString())) { return fromVariant(_value, _lang); }
    template<typename _T_>
    static knowCore::ReturnValue<Literal> fromValue(const knowCore::Uri& _datatype, const _T_& _value, const QString& _lang = QString(), knowCore::TypeCheckingMode _conversion = knowCore::TypeCheckingMode::Safe);
    knowCore::Uri datatype() const;
    static Literal fromValue(const knowCore::Value& _rhs);
    static knowCore::ReturnValue<Literal> fromVariant(const knowCore::Uri& _datatype, const QVariant& _value, const QString& _lang = QString(), knowCore::TypeCheckingMode _conversion = knowCore::TypeCheckingMode::Safe);
    static knowCore::ReturnValue<Literal> fromVariant(const QVariant& _value, const QString& _lang = QString());
    static knowCore::ReturnValue<Literal> fromRdfLiteral(const knowCore::Uri& _datatype, const QString& _value, const QString& _lang = QString());
    QString lang() const;
    bool operator<(const Literal& _rhs) const;
    bool operator==(const Literal& _rhs) const;
    knowCore::ReturnValue<QByteArray> md5() const;
    knowCore::ReturnValue<QJsonValue> toJsonValue(const knowCore::SerialisationContexts& _contexts) const;
    static knowCore::ReturnValue<Literal> fromJsonValue(const QJsonValue& _value, const knowCore::DeserialisationContexts& _contexts);
    knowCore::ReturnValue<QCborValue> toCborValue(const knowCore::SerialisationContexts& _contexts) const;
    static knowCore::ReturnValue<Literal> fromCborValue(const QCborValue& _value, const knowCore::DeserialisationContexts& _contexts);
  private:
    struct Private;
    QSharedDataPointer<Private> d;
  };
  template<typename _T_>
  Literal Literal::fromValue(const _T_& _value, const Lang& _lang)
  {
    return Literal(knowCore::Value::fromValue(_value), _lang);
  }
  template<typename _T_>
  inline knowCore::ReturnValue<Literal> Literal::fromValue(const knowCore::Uri& _datatype, const _T_& _value, const QString& _lang, knowCore::TypeCheckingMode _conversion)
  {
    const auto [success, value, message] = Value::fromValue(_datatype, _value, _conversion);
    Q_UNUSED(message);
    if(success)
    {
      return kCrvSuccess(Literal(value, _lang));
    } else if constexpr(std::is_same_v<QString, _T_> or std::is_same_v<QByteArray, _T_>) {
      const auto [success_2, value_2, message_2] = Value::fromRdfLiteral(_datatype, _value);
      if(success_2)
      {
        KNOWCORE_ASSERT(value_2.datatype() == _datatype);
        return kCrvSuccess(Literal(value_2, _lang));
      } else {
        knowCore::Value value = Value::fromValue(_value);
        return kCrvSuccess(Literal(_datatype, value, _lang));
      }
    } else {
      return kCrvError(message);
    }
  }
  template<>
  inline knowCore::ReturnValue<Literal> Literal::fromValue<QVariant>(const knowCore::Uri& _datatype, const QVariant& _value, const QString& _lang, knowCore::TypeCheckingMode _conversion)
  {
    return fromVariant(_datatype, _value, _lang, _conversion);
  }
  uint qHash(const Literal& key, uint seed = 0);
}
 
KNOWCORE_CORE_DECLARE_FORMATTER(knowRDF::Literal)
{
  if(p.datatype() != p.Value::datatype())
  {
    if(p.lang().isEmpty())
    {
      return format_to(ctx.out(), "{}({})", p.datatype(), (const knowCore::Value&)p);
    } else {
      return format_to(ctx.out(), "{}({})@{}", p.datatype(), (const knowCore::Value&)p, p.lang());
    }
  } else if(p.lang().isEmpty())
  {
    return forward<knowCore::Value>(p, ctx);
  } else {
    return format_to(ctx.out(), "{}@{}", (const knowCore::Value&)p, p.lang());
  }
  
}
 
#include <knowCore/MetaType.h>
KNOWCORE_DECLARE_FULL_METATYPE(knowRDF, Literal)
 
inline knowRDF::Lang operator "" _kRDFlang(const char* _text, std::size_t _size)
{
  return knowRDF::Lang(QString::fromUtf8(_text, _size));
}
 
#if __cplusplus > 201703L
inline knowRDF::Lang operator "" _kRDFlang(const char8_t* _text, std::size_t _size)
{
  return knowRDF::Lang(QString::fromUtf8((const char*)_text, _size));
}
#endif