QuantityValue.h

#pragma once
 
#include <QCryptographicHash>
#include <QJsonObject>
#include <QCborMap>
 
#include "BigNumber.h"
#include "NamedTypes.h"
#include "Unit.h"
#include "Value.h"
 
namespace knowCore
{
  template<typename _T_>
  class QuantityValue
  {
    template<typename _TOther_, typename _Enabled_ = void>
    struct Constructor;
  public:
    QuantityValue() {}
    QuantityValue(const _T_& _value, const Unit& _unit);
    ~QuantityValue() {}
    template<typename _TOther_, typename _TUri_, std::enable_if_t<not std::is_base_of_v<Value, _TOther_>, bool> = true>
    static std::enable_if_t<knowCore::Uris::IsUriDefinitionV<_TUri_>, ReturnValue<QuantityValue>> create(const _TOther_& _value, const _TUri_& _unit_uri) { return create(_value, knowCore::Uri(_unit_uri)); }
    template<typename _TOther_, std::enable_if_t<not std::is_base_of_v<Value, _TOther_>, bool> = true>
    static ReturnValue<QuantityValue> create(const _TOther_& _value, const knowCore::Uri& _unit_uri);
    static ReturnValue<QuantityValue> create(const Value& _value, const knowCore::Uri& _unit_uri);
    template<typename _TOther_, std::enable_if_t<not std::is_base_of_v<Value, _TOther_>, bool> = true>
    static ReturnValue<QuantityValue> create(const _TOther_& _value, const QString& _unit_uri) = delete;
    static ReturnValue<QuantityValue> create(const Value& _value, const QString& _unit_uri) = delete;
    template<typename _TOther_, std::enable_if_t<not std::is_base_of_v<Value, _TOther_>, bool> = true>
    static ReturnValue<QuantityValue> create(const _TOther_& _value, const Symbol& _unit_symbol);
    static ReturnValue<QuantityValue> create(const Value& _value, const Symbol& _unit_symbol);
 
    Unit unit() const { return m_unit; }
    _T_ value() const { return m_value; }
 
    ReturnValue<QuantityValue> operator+(const QuantityValue& _rhs) const;
    ReturnValue<QuantityValue> operator-(const QuantityValue& _rhs) const;
    ReturnValue<QuantityValue> operator/(const QuantityValue& _rhs) const;
    ReturnValue<QuantityValue> operator*(const QuantityValue& _rhs) const;
    QuantityValue operator/(const _T_& _rhs) const;
    QuantityValue operator*(const _T_& _rhs) const;
 
    bool operator==(const QuantityValue& _rhs) const;
    ReturnValue<bool> operator<(const QuantityValue& _rhs) const;
 
    ReturnValue<QByteArray> md5() const;
    ReturnValue<QJsonValue> toJsonValue(const SerialisationContexts& _contexts = defaultSerialisationContext()) const;
    static ReturnValue<QuantityValue> fromJsonValue(const QJsonValue& _value, const DeserialisationContexts& _context = defaultDeserialisationContext());
    ReturnValue<QCborValue> toCborValue(const SerialisationContexts& _contexts = defaultSerialisationContext()) const;
    static ReturnValue<QuantityValue> fromCborValue(const QCborValue& _value, const DeserialisationContexts& _context = defaultDeserialisationContext());
    ReturnValue<QString> toRdfLiteral(const SerialisationContexts& _contexts = defaultSerialisationContext()) const;
    static ReturnValue<QuantityValue> fromRdfLiteral(const QString& _value, const DeserialisationContexts& _context = defaultDeserialisationContext());
    ReturnValue<QString> printable() const;
  private:
    ReturnValue<_T_> cast_rhs(const QuantityValue& _rhs) const;
    _T_ m_value;
    Unit m_unit;
  };
  template<typename _T_>
  QuantityValue<_T_> operator*(const _T_& _lhs, const QuantityValue<_T_>& _rhs);
 
  //BEGIN Specialized constructors
  template<>
  template<typename _TOther_>
  struct QuantityValue<BigNumber>::Constructor<_TOther_, std::enable_if_t<not std::is_same_v<_TOther_, QString>>>
  {
    static knowCore::ReturnValue<BigNumber> construct(const _TOther_& _v) { return kCrvSuccess(BigNumber(_v)); }
  };
  template<>
  template<>
  struct QuantityValue<BigNumber>::Constructor<QString>
  {
    static knowCore::ReturnValue<BigNumber> construct(const QString& _v) { return BigNumber::fromString(_v); }
  };
  //END Specialized constructors
 
  //BEGIN implementation
  template<typename _T_>
  inline QuantityValue<_T_>::QuantityValue(const _T_& _value, const Unit& _unit) : m_value(_value), m_unit(_unit)
  {
  }
 
  template<typename _T_>
  template<typename _TOther_, std::enable_if_t<not std::is_base_of_v<Value, _TOther_>, bool>>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::create(const _TOther_& _value, const knowCore::Uri& _unit_uri)
  {
    KNOWCORE_RETURN_VALUE_TRY(unit, Unit::byUri(_unit_uri));
    return kCrvSuccess(QuantityValue(_value, unit));
  }
 
  template<typename _T_>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::create(const knowCore::Value& _value, const knowCore::Uri& _unit_uri)
  {
    KNOWCORE_RETURN_VALUE_TRY(value, _value.value<_T_>());
    return create(value, _unit_uri);
  }
 
  template<typename _T_>
  template<typename _TOther_, std::enable_if_t<not std::is_base_of_v<Value, _TOther_>, bool>>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::create(const _TOther_& _value, const Symbol& _unit_symbol)
  {
    KNOWCORE_RETURN_VALUE_TRY(unit, Unit::bySymbol(_unit_symbol));
    KNOWCORE_RETURN_VALUE_TRY(value, Constructor<_TOther_>::construct(_value));
    return kCrvSuccess(QuantityValue(value, unit));
  }
 
  template<typename _T_>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::create(const Value& _value, const Symbol& _unit_symbol)
  {
    KNOWCORE_RETURN_VALUE_TRY(value, _value.value<_T_>());
    return create(value, _unit_symbol);
  }
 
  template<typename _T_>
  inline ReturnValue<_T_> QuantityValue<_T_>::cast_rhs(const QuantityValue& _rhs) const
  {
    if(_rhs.unit().base() == unit().base())
    {
      return kCrvSuccess(_rhs.value() * _rhs.unit().scale() / unit().scale());
    } else {
      return kCrvError("Cannot operate on incompatible units: {} is not compatible with {}", unit(), _rhs.unit());
    }
  }
 
  template<typename _T_>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::operator+(const QuantityValue& _rhs) const
  {
    KNOWCORE_RETURN_VALUE_TRY(rhsv, cast_rhs(_rhs));
    return kCrvSuccess<QuantityValue<_T_>>({value() + rhsv, unit()});
  }
  template<typename _T_>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::operator-(const QuantityValue& _rhs) const
  {
    KNOWCORE_RETURN_VALUE_TRY(rhsv, cast_rhs(_rhs));
    return kCrvSuccess<QuantityValue<_T_>>({value() - rhsv, unit()});
  }
  template<typename _T_>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::operator/(const QuantityValue& _rhs) const
  {
    if(unit().base() == _rhs.unit().base())
    {
      KNOWCORE_RETURN_VALUE_TRY(rhsv, cast_rhs(_rhs));
      return kCrvSuccess<QuantityValue<_T_>>({value() / rhsv, Unit::empty()});
    } else {
      KNOWCORE_RETURN_VALUE_TRY(runit, unit() / _rhs.unit());
      return kCrvSuccess<QuantityValue<_T_>>({value() / _rhs.value(), runit});
    }
  }
  template<typename _T_>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::operator*(const QuantityValue& _rhs) const
  {
    if(unit().base() == _rhs.unit().base())
    {
      KNOWCORE_RETURN_VALUE_TRY(rhsv, cast_rhs(_rhs));
      KNOWCORE_RETURN_VALUE_TRY(runit, unit() * unit());
      return kCrvSuccess<QuantityValue<_T_>>({value() * rhsv, runit});
    } else {
      KNOWCORE_RETURN_VALUE_TRY(runit, unit() * _rhs.unit());
      return kCrvSuccess<QuantityValue<_T_>>({value() * _rhs.value(), runit});
    }
  }
 
  template<typename _T_>
  QuantityValue<_T_> QuantityValue<_T_>::operator/(const _T_& _rhs) const
  {
    return QuantityValue<_T_>{value() / _rhs, unit()};
  }
 
  template<typename _T_>
  QuantityValue<_T_> QuantityValue<_T_>::operator*(const _T_& _rhs) const
  {
    return QuantityValue<_T_>{value() * _rhs, unit()};
  }
 
  template<typename _T_>
  QuantityValue<_T_> operator*(const _T_& _lhs, const QuantityValue<_T_>& _rhs)
  {
    return _rhs * _lhs;
  }
 
 
  template<typename _T_>
  bool QuantityValue<_T_>::operator==(const QuantityValue& _rhs) const
  {
    return value() == _rhs.value() and unit() == _rhs.unit();
  }
 
  template<typename _T_>
  ReturnValue<bool> QuantityValue<_T_>::operator<(const QuantityValue& _rhs) const
  {
    KNOWCORE_RETURN_VALUE_TRY(rhsv, cast_rhs(_rhs));
    return kCrvSuccess(value() < rhsv);
  }
 
  template<typename _T_>
  inline ReturnValue<QByteArray> QuantityValue<_T_>::md5() const
  {
    QCryptographicHash hash(QCryptographicHash::Md5);
    KNOWCORE_RETURN_VALUE_TRY(value_md5, MetaTypeInformation<_T_>::md5(m_value));
    hash.addData(value_md5);
    hash.addData(unit().symbol().toUtf8());
    return kCrvSuccess(hash.result());
  }
 
#define __KNOWCORE_VALUE_KEY QString("value")
#define __KNOWCORE_UNIT_KEY QString("unit")
 
  template<typename _T_>
  inline ReturnValue<QJsonValue> QuantityValue<_T_>::toJsonValue(const SerialisationContexts& _contexts) const
  {
    QJsonObject object;
    KNOWCORE_RETURN_VALUE_TRY_ASSIGN(object[__KNOWCORE_VALUE_KEY], MetaTypeInformation<_T_>::toJsonValue(value(), _contexts));
    object[__KNOWCORE_UNIT_KEY] = unit().symbol();
    return kCrvSuccess(object);
  }
 
  template<typename _T_>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::fromJsonValue(const QJsonValue& _value, const DeserialisationContexts& _context)
  {
    if(_value.isObject())
    {
      QJsonObject object = _value.toObject();
      KNOWCORE_RETURN_VALUE_TRY(value, MetaTypeInformation<_T_>::fromJsonValue(object.value(__KNOWCORE_VALUE_KEY), _context));
      KNOWCORE_RETURN_VALUE_TRY(unit, Unit::bySymbol(object.value(__KNOWCORE_UNIT_KEY).toString()));
      return kCrvSuccess<QuantityValue<_T_>>({value, unit});
    } else {
      return kCrvError("Expected object got {}", _value);
    }
  }
 
  template<typename _T_>
  inline ReturnValue<QCborValue> QuantityValue<_T_>::toCborValue(const SerialisationContexts& _contexts) const
  {
    QCborMap object;
    KNOWCORE_RETURN_VALUE_TRY_ASSIGN(object[__KNOWCORE_VALUE_KEY], MetaTypeInformation<_T_>::toCborValue(value(), _contexts));
    object[__KNOWCORE_UNIT_KEY] = unit().symbol();
    return kCrvSuccess(object);
  }
 
  template<typename _T_>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::fromCborValue(const QCborValue& _value, const DeserialisationContexts& _context)
  {
    if(_value.isMap())
    {
      QCborMap object = _value.toMap();
      KNOWCORE_RETURN_VALUE_TRY(value, MetaTypeInformation<_T_>::fromCborValue(object.value(__KNOWCORE_VALUE_KEY), _context));
      KNOWCORE_RETURN_VALUE_TRY(unit, Unit::bySymbol(object.value(__KNOWCORE_UNIT_KEY).toString()));
      return kCrvSuccess<QuantityValue<_T_>>({value, unit});
    } else {
      return kCrvError("Expected object got {}", _value);
    }
  }
 
  template<typename _T_>
  inline ReturnValue<QString> QuantityValue<_T_>::toRdfLiteral(const SerialisationContexts& _contexts) const
  {
    KNOWCORE_RETURN_VALUE_TRY(str, MetaTypeInformation<_T_>::toRdfLiteral(value(), _contexts));
    return kCrvSuccess(str + " " + m_unit.symbol());
  }
 
  template<typename _T_>
  inline ReturnValue<QuantityValue<_T_>> QuantityValue<_T_>::fromRdfLiteral(const QString& _value, const DeserialisationContexts& _context)
  {
    QStringList splited = _value.split(" ", KNOWCORE_QT_SKIP_EMPTY_PART);
    if(splited.size() == 0)
    {
      return kCrvError("Empty literal");
    }
    Unit u = Unit::empty();
    if(splited.size() == 2)
    {
      KNOWCORE_RETURN_VALUE_TRY_ASSIGN(u, Unit::bySymbol(splited[1]));
    }
    KNOWCORE_RETURN_VALUE_TRY(value, MetaTypeInformation<_T_>::fromRdfLiteral(splited[0], _context));
    return kCrvSuccess<QuantityValue<_T_>>({value, u});
  }
 
  template<typename _T_>
  inline ReturnValue<QString> QuantityValue<_T_>::printable() const
  {
    return toRdfLiteral();
  }
 
#undef __KNOWCORE_UNIT_KEY
#undef __KNOWCORE_VALUE_KEY
 
  //END implementation
}
 
#include "MetaType.h"
KNOWCORE_DECLARE_FULL_METATYPE(knowCore, QuantityNumber)
 
template<typename _T_>
struct fmt::formatter<knowCore::QuantityValue<_T_>> : public clog_fmt::base_formatter {
  template <typename FormatContext>
  auto format(knowCore::QuantityValue<_T_> const& p, FormatContext& ctx) -> decltype(ctx.out())
  {
    return format_to(ctx.out(), "({} {})", p.value(), p.unit());
  }
};