Array.h

#ifndef _KNOW_CORE_ARRAY_H_
#define _KNOW_CORE_ARRAY_H_
 
#include <QVector>
 
#include "Global.h"
#include "Logging.h"
#include "ReturnValue.h"
#include "Vector.h"
 
namespace knowCore
{
  template<typename _T_>
  class Array
  {
  public:
    Array() {}
    explicit Array(const QList<int>& _dimensions) : m_dimensions(_dimensions)
    {
      m_data.resize(totalSize());
    }
    Array(const std::initializer_list<int>& _il) : Array(QList<int>(_il))
    {
    }
    Array(const QVector<_T_>& _data, const QList<int>& _dimensions) : m_data(_data), m_dimensions(_dimensions)
    {
      Q_ASSERT(m_data.size() == totalSize());
    }
    template<int _v_dimension_>
    ReturnValue<Vector<_T_, _v_dimension_>> toVector() const
    {
      if(m_dimensions.size() == 1 and m_dimensions[0] == _v_dimension_)
      {
        Vector<_T_, _v_dimension_> v;
        v.copyFrom(m_data);
        return kCrvSuccess(v);
      } else {
        return kCrvError("Invalid conversion from array of dimensions {} to vector of dimension {}", m_dimensions, _v_dimension_);
      }
    }
    template<typename _RList_ = QList<_T_>>
    ReturnValue<_RList_> toList() const
    {
      if(m_dimensions.size() == 1)
      {
        return kCrvSuccess(m_data.toList());
      } else {
        return kCrvError("Invalid conversion from array of dimensions {} to list.", m_dimensions);
      }
    }
    template<int _v_dimension_>
    ReturnValue<QList<Vector<_T_, _v_dimension_>>> toVectorList() const
    {
      if(m_dimensions.size() == 2)
      {
        if(m_dimensions[1] != _v_dimension_)
        {
          return kCrvError("Invalid conversion from array of dimensions {} to a list of vectors of dimension {}", m_dimensions, _v_dimension_);
        }
        QList<Vector<_T_, _v_dimension_>> result;
        for(int i = 0; i < m_dimensions.size(); ++i)
        {
          Vector<_T_, _v_dimension_> v;
          for(int k = 0; k < _v_dimension_; ++k)
          {
            v[k] = m_data[i * _v_dimension_ + k];
          }
          result.append(v);
        }
        return kCrvSuccess(result);
      } else {
        return kCrvError("Invalid conversion from array of dimensions {} to a list of vectors of dimension {}", m_dimensions, _v_dimension_);
      }
 
    }
    bool operator==(const Array<_T_>& _rhs) const
    {
      return m_dimensions == _rhs.m_dimensions and m_data == _rhs.m_data;
    }
    void fill(const _T_& _v) { m_data.fill(_v); }
    typename QVector<_T_>::iterator begin() { return m_data.begin(); }
    typename QVector<_T_>::iterator end() { return m_data.end(); }
    typename QVector<_T_>::const_iterator begin() const { return m_data.begin(); }
    typename QVector<_T_>::const_iterator end() const { return m_data.end(); }
    QVector<_T_> data() const { return m_data; }
    QList<int> dimensions() const { return m_dimensions; }
    template<typename... _Args_>
    typename std::enable_if_t<details::all_int_v<_Args_...>, _T_>& operator()(_Args_... _indices)
    {
      KNOWCORE_ASSERT(sizeof...(_Args_) == m_dimensions.size());
      return m_data[make_index(0, _indices...)];
    }
  private:
    template<typename _Arg1_, typename _Arg2_, typename... _Args_>
    int make_index(int _level, _Arg1_ _i, _Arg2_ j, _Args_... _indices)
    {
      return make_index(_level + 1, j, _indices...) * m_dimensions[_level] + _i;
    }
    int make_index(int, int _i)
    {
      return _i;
    }
    int totalSize() const
    {
      int ts = 1;
      for(int d : m_dimensions)
      {
        ts *= d;
      }
      return ts;
    }
  public:
    QVector<_T_> m_data;
    QList<int> m_dimensions;
  };
}
 
#endif