TArray.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// STL includes
#include <vector>
 
// Qt includes
#include <QtCore/QtGlobal>
 
// ACF includes
#include <istd/TIndex.h>
 
 
namespace istd
{
 
 
template <class Element, int Dimensions>
class TArray
{
public:
       typedef TIndex<Dimensions> IndexType;
       typedef TIndex<Dimensions> SizesType;
       typedef Element ElementType;
 
       class Iterator: public TIndex<Dimensions>
       {
       public:
              typedef TIndex<Dimensions> BaseClass;
 
              Iterator(const Iterator& iterator);
 
              Element& operator*();
              const Element& operator*() const;
 
              Element* operator->();
              const Element* operator->() const;
 
              Iterator& operator++();
              Iterator operator++(int);
 
              Iterator& operator--();
              Iterator operator--(int);
 
              Iterator& operator=(const Iterator& iterator);
 
              bool operator==(const Iterator& iterator) const;
              bool operator!=(const Iterator& iterator) const;
 
              friend class TArray<Element, Dimensions>;
 
       protected:
              Iterator(TArray* arrayPtr);
 
       private:
              TArray* m_arrayPtr = nullptr;
       };
 
       TArray();
       TArray(const TArray& array);
       explicit TArray(const SizesType& sizes, const ElementType& value = ElementType());
 
       void Reset();
 
       bool IsEmpty() const;
 
       bool IsDimensionsCountFixed() const;
 
       int GetDimensionsCount() const;
 
       bool SetDimensionsCount(int count);
 
       const SizesType& GetSizes() const;
 
       bool SetSizes(const SizesType& sizes);
 
       int GetSize(int dimension) const;
 
       bool SetSize(int dimension, int size);
 
       const Element& GetAt(const IndexType& index) const;
 
       Element& GetAtRef(const IndexType& index);
 
       void SetAt(const IndexType& index, const Element& value);
 
       void SetAllElements(const Element& value);
 
       // iterator support
       Iterator Begin() const;
       const Iterator& End() const;
 
       // operators
       bool operator==(const TArray<Element, Dimensions>& value) const;
       bool operator!=(const TArray<Element, Dimensions>& value) const;
       const Element& operator[](const IndexType& index) const;
       Element& operator[](const IndexType& index);
 
protected:
       typedef std::vector<Element> Elements;
 
       int GetElementIndex(const IndexType& index) const;
       void UpdateElementsSize(const ElementType& value = ElementType());
 
       void DeepCopy(const Elements& elements, const SizesType& sizes);
 
       SizesType m_sizes;
       Elements m_elements;
 
private:
       static Iterator s_endIterator;
};
 
 
// inline methods
 
template <class Element, int Dimensions>
bool TArray<Element, Dimensions>::IsEmpty() const
{
       return m_sizes.IsSizeEmpty();
}
 
 
template <class Element, int Dimensions>
inline bool TArray<Element, Dimensions>::IsDimensionsCountFixed() const
{
       return true;
}
 
 
template <class Element, int Dimensions>
inline int TArray<Element, Dimensions>::GetDimensionsCount() const
{
       return Dimensions;
}
 
 
template <class Element, int Dimensions>
inline bool TArray<Element, Dimensions>::SetDimensionsCount(int count)
{
       return (count == GetDimensionsCount());
}
 
 
template <class Element, int Dimensions>
inline const typename TArray<Element, Dimensions>::SizesType& TArray<Element, Dimensions>::GetSizes() const
{
       return m_sizes;
}
 
 
template <class Element, int Dimensions>
inline int TArray<Element, Dimensions>::GetSize(int dimension) const
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < Dimensions);
 
       return m_sizes[dimension];
}
 
 
template <class Element, int Dimensions>
inline const Element& TArray<Element, Dimensions>::GetAt(const IndexType& index) const
{
       Q_ASSERT(index.IsInside(m_sizes));
 
       int elementIndex = GetElementIndex(index);
       Q_ASSERT(elementIndex < int(m_elements.size()));
 
       return m_elements[elementIndex];
}
 
 
template <class Element, int Dimensions>
inline Element& TArray<Element, Dimensions>::GetAtRef(const IndexType& index)
{
       Q_ASSERT(index.IsInside(m_sizes));
 
       int elementIndex = GetElementIndex(index);
       Q_ASSERT(elementIndex < int(m_elements.size()));
 
       return m_elements[elementIndex];
}
 
 
template <class Element, int Dimensions>
inline void TArray<Element, Dimensions>::SetAt(const IndexType& index, const Element& value)
{
       Q_ASSERT(index.IsInside(m_sizes));
 
       int elementIndex = GetElementIndex(index);
       Q_ASSERT(elementIndex < int(m_elements.size()));
 
       m_elements[elementIndex] = value;
}
 
 
// iterator support
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::Iterator TArray<Element, Dimensions>::Begin() const
{
       return Iterator(const_cast<TArray<Element, Dimensions>*>(this));
}
 
 
template <class Element, int Dimensions>
const typename TArray<Element, Dimensions>::Iterator& TArray<Element, Dimensions>::End() const
{
       return s_endIterator;
}
 
 
template <class Element, int Dimensions>
inline const Element& TArray<Element, Dimensions>::operator[](const IndexType& index) const
{
       return GetAt(index);
}
 
 
template <class Element, int Dimensions>
inline Element& TArray<Element, Dimensions>::operator[](const IndexType& index)
{
       int elementIndex = GetElementIndex(index);
       Q_ASSERT(elementIndex < int(m_elements.size()));
 
       return m_elements[elementIndex];
}
 
 
// inline protected methods
 
template <class Element, int Dimensions>
inline int TArray<Element, Dimensions>::GetElementIndex(const IndexType& index) const
{
       int elementIndex = 0;
       int cumulatedSizes = 1;
       for (int i = 0; i < Dimensions; ++i){
              Q_ASSERT(index[i] >= 0);
              Q_ASSERT(index[i] < m_sizes[i]);
 
              elementIndex += index[i] * cumulatedSizes;
 
              cumulatedSizes *= m_sizes[i];
       }
 
       return elementIndex;
}
 
 
// public methods
 
template <class Element, int Dimensions>
TArray<Element, Dimensions>::TArray()
{
       for (int i = 0; i < Dimensions; ++i){
              m_sizes[i] = 0;
       }
}
 
 
template <class Element, int Dimensions>
TArray<Element, Dimensions>::TArray(const TArray& array)
:      m_sizes(array.m_sizes), m_elements(array.m_elements)
{
}
 
 
template <class Element, int Dimensions>
TArray<Element, Dimensions>::TArray(const SizesType& sizes, const ElementType& value)
:      m_sizes(sizes)
{
       UpdateElementsSize(value);
}
 
 
template <class Element, int Dimensions>
void TArray<Element, Dimensions>::Reset()
{
       m_sizes.Reset();
 
       m_elements.clear();
}
 
 
template <class Element, int Dimensions>
bool TArray<Element, Dimensions>::SetSizes(const SizesType& sizes)
{
       m_sizes = sizes;
 
       UpdateElementsSize();
 
       return true;
}
 
 
template <class Element, int Dimensions>
bool TArray<Element, Dimensions>::SetSize(int dimension, int size)
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < Dimensions);
 
       m_sizes[dimension] = size;
 
       UpdateElementsSize();
 
       return true;
}
 
 
template <class Element, int Dimensions>
void TArray<Element, Dimensions>::SetAllElements(const Element& value)
{
       for (         typename Elements::iterator iter = m_elements.begin();
                            iter != m_elements.end();
                            ++iter){
              *iter = value;
       }
}
 
 
// operators
 
template <class Element, int Dimensions>
bool TArray<Element, Dimensions>::operator==(const TArray<Element, Dimensions>& value) const
{
       return (m_sizes == value.m_sizes) && (m_elements == value.m_elements);
}
 
 
template <class Element, int Dimensions>
bool TArray<Element, Dimensions>::operator!=(const TArray<Element, Dimensions>& value) const
{
       return (m_sizes != value.m_sizes) || (m_elements != value.m_elements);
}
 
 
// protected methods
 
template <class Element, int Dimensions>
void TArray<Element, Dimensions>::UpdateElementsSize(const ElementType& value)
{
       int cumulatedSizes = 1;
       for (int i = 0; i < Dimensions; ++i){
              cumulatedSizes *= m_sizes[i];
       }
 
       m_elements.resize(cumulatedSizes, value);
}
 
 
template <class Element, int Dimensions>
void TArray<Element, Dimensions>::DeepCopy(const Elements& elements, const SizesType& sizes)
{
       Q_ASSERT(int(elements.size()) == sizes[0] * sizes[1]);
 
       m_elements = elements;
       m_sizes = sizes;
}
 
 
// static attributes
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::Iterator TArray<Element, Dimensions>::s_endIterator(NULL);
 
 
// public methods of embedded class Iterator
 
template <class Element, int Dimensions>
TArray<Element, Dimensions>::Iterator::Iterator(const Iterator& iterator)
:      BaseClass(iterator), m_arrayPtr(iterator.m_arrayPtr)
{
}
 
 
template <class Element, int Dimensions>
const Element& TArray<Element, Dimensions>::Iterator::operator*() const
{
       Q_ASSERT(m_arrayPtr != NULL);
       Q_ASSERT(BaseClass::IsInside(m_arrayPtr->GetSizes()));
 
       return m_arrayPtr->GetAt(*this);
}
 
 
template <class Element, int Dimensions>
Element& TArray<Element, Dimensions>::Iterator::operator*()
{
       Q_ASSERT(m_arrayPtr != NULL);
       Q_ASSERT(BaseClass::IsInside(m_arrayPtr->GetSizes()));
 
       return m_arrayPtr->operator[](*this);
}
 
 
template <class Element, int Dimensions>
const Element* TArray<Element, Dimensions>::Iterator::operator->() const
{
       Q_ASSERT(m_arrayPtr != NULL);
       Q_ASSERT(BaseClass::IsInside(m_arrayPtr->GetSizes()));
 
       return &m_arrayPtr->GetAt(*this);
}
 
 
template <class Element, int Dimensions>
Element* TArray<Element, Dimensions>::Iterator::operator->()
{
       Q_ASSERT(m_arrayPtr != NULL);
       Q_ASSERT(BaseClass::IsInside(m_arrayPtr->GetSizes()));
 
       return &m_arrayPtr->operator[](*this);
}
 
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::Iterator& TArray<Element, Dimensions>::Iterator::operator++()
{
       if ((m_arrayPtr != NULL) && !BaseClass::Increase(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;
       }
 
       return *this;
}
 
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::Iterator TArray<Element, Dimensions>::Iterator::operator++(int)
{
       Iterator retVal = *this;
 
       if ((m_arrayPtr != NULL) && !BaseClass::Increase(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;
       }
 
       return retVal;
}
 
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::Iterator& TArray<Element, Dimensions>::Iterator::operator--()
{
       if ((m_arrayPtr != NULL) && !Decrease(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;
       }
 
       return *this;
}
 
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::Iterator TArray<Element, Dimensions>::Iterator::operator--(int)
{
       Iterator retVal = *this;
 
       if ((m_arrayPtr != NULL) && !Decrease(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;
       }
 
       return retVal;
}
 
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::Iterator& TArray<Element, Dimensions>::Iterator::operator=(const Iterator& iterator)
{
       BaseClass::operator=(iterator);
 
       m_arrayPtr = iterator.m_arrayPtr;
 
       return *this;
}
 
 
template <class Element, int Dimensions>
bool TArray<Element, Dimensions>::Iterator::operator==(const Iterator& iterator) const
{
       if ((m_arrayPtr != NULL) && (iterator.m_arrayPtr != NULL)){
              return (m_arrayPtr == iterator.m_arrayPtr) && (BaseClass::operator==(iterator));
       }
 
       return (m_arrayPtr == iterator.m_arrayPtr);
}
 
 
template <class Element, int Dimensions>
bool TArray<Element, Dimensions>::Iterator::operator!=(const Iterator& iterator) const
{
       return !operator==(iterator);
}
 
 
// protected methods of emedded class Iterator
 
template <class Element, int Dimensions>
TArray<Element, Dimensions>::Iterator::Iterator(TArray* arrayPtr)
:      BaseClass(0), m_arrayPtr(arrayPtr)
{
       if ((m_arrayPtr != NULL) && !BaseClass::IsInside(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;   // if it is not inside of array set it directly to the end iterator state
       }
}
 
 
} // namespace istd