ValueList.h

#pragma once
 
#include "Value.h"
 
namespace knowCore
{
  class ValueList
  {
  public:
    using const_iterator = QList<Value>::const_iterator;
  public:
    ValueList();
    ValueList(const QList<Value>& _value);
    ValueList(const ValueList& _list);
    ValueList operator=(const ValueList& _list);
    ~ValueList();
    int size() const;
    Value at(int _index) const;
    template<typename _T_>
    ReturnValue<_T_> at(int _index) const;
    template<typename _T_>
    ReturnValue<QList<_T_>> values() const;
    
    bool operator==(const ValueList& _rhs) const;
    bool operator==(const QList<Value>& _rhs) const;
    Value operator[](std::size_t _index) const;
 
    const_iterator begin() const;
    const_iterator end() const;
    
    bool contains(const knowCore::Value& _value) const;
    template<typename _T_>
    bool contains(const _T_& _value) const { return contains(knowCore::Value::fromValue(_value)); }
 
    ReturnValue<QByteArray> md5() const;
    ReturnValue<QJsonValue> toJsonValue(const SerialisationContexts& _contexts) const;
    static ReturnValue<ValueList> fromJsonValue(const QJsonValue& _value, const DeserialisationContexts& _contexts);
    ReturnValue<QCborValue> toCborValue(const SerialisationContexts& _contexts) const;
    static ReturnValue<ValueList> fromCborValue(const QCborValue& _value, const DeserialisationContexts& _contexts);
    ReturnValue<QString> printable() const;
    QList<Value> values() const;
    ReturnVoid checkContainsOnly(const Uri& _uri) const;
    template<typename _T_>
    inline ReturnVoid checkContainsOnly() const;
    operator Value() const { return Value::fromValue(*this); }
    bool canConvertAllTo(const Uri& _uri) const;
    template<typename _T_>
    bool canConvertAllTo() const;
    template<typename _T_>
    inline static const ValueList fromValues(const QList<_T_>& _t);
    static ReturnValue<ValueList> fromVariants(const QVariantList& _t);
    QVariantList toVariantList() const;
    QVariant toVariant() const;
  private:
    struct Private;
    QSharedDataPointer<Private> d;
  };
  
  template<typename _T_>
  ReturnValue<_T_> ValueList::at(int _index) const
  {
    return at(_index).template value<_T_>();
  }
  template<typename _T_>
  ReturnValue<QList<_T_>> ValueList::values() const
  {
    QList<_T_> list;
    for(int i = 0; i < size(); ++i)
    {
      KNOWCORE_RETURN_VALUE_TRY(value, at<_T_>(i));
      list.append(value);
    }
    return kCrvSuccess(list);
  }
  template<typename _T_>
  ReturnVoid ValueList::checkContainsOnly() const
  {
    return checkContainsOnly(MetaTypeInformation<_T_>::uri());
  }
  template<typename _T_>
  bool ValueList::canConvertAllTo() const
  {
    return canConvertAllTo(MetaTypeInformation<_T_>::uri());
  }
  template<typename _T_>
  const ValueList ValueList::fromValues(const QList<_T_>& _t)
  {
    QList<Value> l;
    std::transform(_t.begin(), _t.end(), std::back_inserter(l), [](const _T_& _t) -> Value { return Value::fromValue(_t); });
    return l;
  }
 
}
 
KNOWCORE_CORE_DECLARE_FORMATTER_PRINTABLE(knowCore::ValueList)
KNOWCORE_DECLARE_FULL_METATYPE(knowCore, ValueList)