ValueHash.h

#pragma once
 
#include "Value.h"
 
namespace knowCore
{
  // BEGIN ValueHash
  class ValueHash
  {
  public:
    ValueHash();
    template<typename _T_, typename... _TOther_>
    ValueHash(const QString& _key, const _T_& _t, const _TOther_&...);
    ValueHash(const QHash<QString, Value>& _value);
    ValueHash(const ValueHash& _list);
    ValueHash(ValueHash&& _list);
    ValueHash operator=(const ValueHash& _list);
    ~ValueHash();
    static cres_qresult<ValueHash> fromVariantMap(const QVariantMap& _map);
    static cres_qresult<ValueHash> fromVariantHash(const QVariantHash& _map);
    static cres_qresult<ValueHash> parseVariantMap(const QVariantMap& _value);
  private:
    template<typename _T_>
    static cres_qresult<ValueHash> fromVariantHashMap(const _T_& _map);
  public:
    int size() const;
 
    QStringList keys() const;
 
    Value value(const QString& _key) const;
 
    template<typename _T_>
    cres_qresult<_T_> value(const QString& _key) const;
    template<typename _T_>
    cres_qresult<_T_> value(const QString& _key, const _T_& _default) const;
    bool contains(const QString& _key) const;
    bool contains(const QString& _key, const knowCore::Uri& _datatype) const;
    template<typename _T_>
    bool contains(const QString& _key) const;
    cres_qresult<void> ensureContains(const QString& _key, const knowCore::Uri& _datatype) const;
    template<typename _T_>
    cres_qresult<void> ensureContains(const QString& _key) const;
    template<typename _T_>
    cres_qresult<QHash<QString, _T_>> hash() const;
    QHash<QString, Value> hash() const;
    template<typename _T_>
    cres_qresult<QMap<QString, _T_>> map() const;
    QMap<QString, Value> map() const;
    template<typename _T_>
    cres_qresult<QList<_T_>> values() const;
    QList<Value> values() const { return hash().values(); }
 
    bool operator==(const ValueHash& _rhs) const;
    bool operator!=(const ValueHash& _rhs) const;
    bool operator==(const QHash<QString, Value>& _rhs) const;
 
    cres_qresult<QByteArray> md5() const;
    cres_qresult<QJsonValue> toJsonValue(const SerialisationContexts& _contexts) const;
    static cres_qresult<ValueHash> fromJsonValue(const QJsonValue& _value,
                                                 const DeserialisationContexts& _contexts);
    cres_qresult<QCborValue> toCborValue(const SerialisationContexts& _contexts) const;
    static cres_qresult<ValueHash> fromCborValue(const QCborValue& _value,
                                                 const DeserialisationContexts& _contexts);
    cres_qresult<QString> printable() const;
    QVariantHash toVariantHash() const;
    QVariantMap toVariantMap() const;
    QVariant toVariant() const;
    cres_qresult<void> checkContainsOnly(const Uri& _uri) const;
    template<typename _T_>
    cres_qresult<void> checkContainsOnly() const;
 
    operator Value() const { return Value::fromValue(*this); }
 
    template<typename _T_>
    ValueHash& insert(const QString& _key, const _T_& _value)
    {
      return insert(_key, Value::fromValue(_value));
    }
    template<typename _T_, typename... _TOther_>
    ValueHash& insert(const QString& _key, const _T_& _value, const QString& _key_n,
                      const _TOther_&... _other)
    {
      insert(_key, _value);
      return insert(_key_n, _other...);
    }
    ValueHash& insert(const QString& _key, const knowCore::Value& _value);
    cres_qresult<void> insert(const QString& _key, const QVariant& _value);
    cres_qresult<void> insert(const QVariantHash& _value);
    ValueHash& insert(const knowCore::ValueHash& _value);
    cres_qresult<void> insert(const QVariantMap& _value);
    cres_qresult<void> insert(const QJsonObject& _value);
    ValueHash& remove(const QString& _key);
    void clear();
  private:
    template<typename _T_>
    cres_qresult<void> insertHashMap(const _T_& _map);
    struct Private;
    QSharedDataPointer<Private> d;
  };
 
  template<typename _T_, typename... _TOther_>
  ValueHash::ValueHash(const QString& _key, const _T_& _t, const _TOther_&... _other) : ValueHash()
  {
    insert(_key, _t, _other...);
  }
 
  template<typename _T_>
  bool ValueHash::contains(const QString& _key) const
  {
    return contains(_key, MetaTypeInformation<_T_>::uri());
  }
  template<typename _T_>
  cres_qresult<void> ValueHash::ensureContains(const QString& _key) const
  {
    return ensureContains(_key, MetaTypeInformation<_T_>::uri());
  }
 
  inline cres_qresult<ValueHash> ValueHash::fromVariantMap(const QVariantMap& _map)
  {
    return fromVariantHashMap(_map);
  }
  inline cres_qresult<ValueHash> ValueHash::fromVariantHash(const QVariantHash& _map)
  {
    return fromVariantHashMap(_map);
  }
 
  template<typename _T_>
  inline cres_qresult<ValueHash> ValueHash::fromVariantHashMap(const _T_& _map)
  {
    ValueHash h;
    cres_try(cres_ignore, h.insert(_map));
    return cres_success(h);
  }
  template<typename _T_>
  inline cres_qresult<_T_> ValueHash::value(const QString& _key) const
  {
    return value(_key).template value<_T_>();
  }
  template<typename _T_>
  inline cres_qresult<_T_> ValueHash::value(const QString& _key, const _T_& _default) const
  {
    if(contains(_key))
    {
      return value<_T_>(_key);
    }
    else
    {
      return cres_success(_default);
    }
  }
 
  template<typename _T_>
  inline cres_qresult<QHash<QString, _T_>> ValueHash::hash() const
  {
    QHash<QString, _T_> values;
    QHash<QString, Value> values_ = hash();
    for(auto it = values_.begin(); it != values_.end(); ++it)
    {
      cres_try(_T_ value, it.value().value<_T_>());
      values[it.key()] = value;
    }
    return cres_success(values);
  }
  template<typename _T_>
  inline cres_qresult<QMap<QString, _T_>> ValueHash::map() const
  {
    QMap<QString, _T_> values;
    QHash<QString, Value> values_ = hash();
    for(auto it = values_.begin(); it != values_.end(); ++it)
    {
      cres_try(_T_ value, it.value().value<_T_>());
      values[it.key()] = value;
    }
    return cres_success(values);
  }
  inline QMap<QString, Value> ValueHash::map() const
  {
    QMap<QString, Value> values;
    QHash<QString, Value> values_ = hash();
    for(auto it = values_.begin(); it != values_.end(); ++it)
    {
      values[it.key()] = it.value();
    }
    return values;
  }
  template<typename _T_>
  inline cres_qresult<void> ValueHash::checkContainsOnly() const
  {
    return checkContainsOnly(MetaTypeInformation<_T_>::uri());
  }
} // namespace knowCore
 
KNOWCORE_CORE_DECLARE_FORMATTER_PRINTABLE(knowCore::ValueHash);
 
KNOWCORE_DECLARE_FULL_METATYPE(knowCore, ValueHash);