ValueHash.h

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