TVarArray.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
 
 
// Qt includes
#include <QtCore/QVector>
 
// ACF includes
#include <istd/CVarIndex.h>
 
 
namespace istd
{
 
 
template <class Element>
class TVarArray
{
public:
       typedef CVarIndex IndexType;
       typedef CVarIndex SizesType;
       typedef Element ElementType;
 
       class Iterator: public CVarIndex
       {
       public:
              typedef CVarIndex 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 TVarArray<Element>;
 
       protected:
              Iterator(TVarArray* arrayPtr);
 
       private:
              TVarArray* m_arrayPtr = nullptr;
       };
 
       TVarArray();
       TVarArray(const TVarArray& array);
 
       void Reset();
 
       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;
 
       void SetAt(const IndexType& index, const Element& value);
 
       void SetAllElements(const Element& value);
 
       // iterator support
       Iterator Begin() const;
       const Iterator& End() const;
 
       const Element& operator[](const IndexType& index) const;
       Element& operator[](const IndexType& index);
 
       int GetElementIndex(const IndexType& index) const;
 
protected:
       void UpdateElementsSize();
 
private:
       typedef QVector<Element> Elements;
       Elements m_elements;
 
       SizesType m_sizes;
 
       static Iterator s_endIterator;
};
 
 
// inline methods
 
template <class Element>
inline bool TVarArray<Element>::IsDimensionsCountFixed() const
{
       return false;
}
 
 
template <class Element>
inline int TVarArray<Element>::GetDimensionsCount() const
{
       return m_sizes.GetDimensionsCount();
}
 
 
template <class Element>
inline bool TVarArray<Element>::SetDimensionsCount(int count)
{
       bool retVal = m_sizes.SetDimensionsCount(count);
 
       UpdateElementsSize();
 
       return retVal;
}
 
 
template <class Element>
inline const typename TVarArray<Element>::SizesType& TVarArray<Element>::GetSizes() const
{
       return m_sizes;
}
 
 
template <class Element>
inline int TVarArray<Element>::GetSize(int dimension) const
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < m_sizes.GetDimensionsCount());
 
       return m_sizes[dimension];
}
 
 
template <class Element>
inline const Element& TVarArray<Element>::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>
inline void TVarArray<Element>::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>
typename TVarArray<Element>::Iterator TVarArray<Element>::Begin() const
{
       return Iterator(const_cast<TVarArray<Element>*>(this));
}
 
 
template <class Element>
const typename TVarArray<Element>::Iterator& TVarArray<Element>::End() const
{
       return s_endIterator;
}
 
 
template <class Element>
inline const Element& TVarArray<Element>::operator[](const IndexType& index) const
{
       return GetAt(index);
}
 
 
template <class Element>
inline Element& TVarArray<Element>::operator[](const IndexType& index)
{
       int elementIndex = GetElementIndex(index);
       Q_ASSERT(elementIndex < int(m_elements.size()));
 
       return m_elements[elementIndex];
}
 
 
template <class Element>
inline int TVarArray<Element>::GetElementIndex(const IndexType& index) const
{
       int indexDimensionsCount = index.GetDimensionsCount();
       int dimensionsCount = m_sizes.GetDimensionsCount();
 
       int minDimensionsCount = qMin(indexDimensionsCount, dimensionsCount);
 
       int elementIndex = 0;
       int cumulatedSizes = 1;
       for (int i = 0; i < minDimensionsCount; ++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>
TVarArray<Element>::TVarArray()
{
}
 
 
template <class Element>
TVarArray<Element>::TVarArray(const TVarArray& array)
:      m_elements(array.m_elements),
       m_sizes(array.m_sizes)
{
}
 
 
template <class Element>
void TVarArray<Element>::Reset()
{
       m_sizes.Reset();
 
       m_elements.clear();
}
 
 
template <class Element>
bool TVarArray<Element>::SetSizes(const SizesType& sizes)
{
       m_sizes = sizes;
 
       UpdateElementsSize();
 
       return true;
}
 
 
template <class Element>
bool TVarArray<Element>::SetSize(int dimension, int size)
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < m_sizes.GetDimensionsCount());
 
       m_sizes[dimension] = size;
 
       UpdateElementsSize();
 
       return true;
}
 
 
template <class Element>
void TVarArray<Element>::SetAllElements(const Element& value)
{
       for (         typename Elements::Iterator iter = m_elements.begin();
                            iter != m_elements.end();
                            ++iter){
              *iter = value;
       }
}
 
 
// protected methods
 
template <class Element>
void TVarArray<Element>::UpdateElementsSize()
{
       int dimensionsCount = m_sizes.GetDimensionsCount();
       int cumulatedSizes = 1;
       for (int i = 0; i < dimensionsCount; ++i){
              cumulatedSizes *= m_sizes[i];
       }
 
       m_elements.resize(cumulatedSizes);
}
 
 
// static attributes
 
template <class Element>
typename TVarArray<Element>::Iterator TVarArray<Element>::s_endIterator(NULL);
 
 
// public methods of embedded class Iterator
 
template <class Element>
TVarArray<Element>::Iterator::Iterator(const Iterator& iterator)
:      BaseClass(iterator), m_arrayPtr(iterator.m_arrayPtr)
{
}
 
 
template <class Element>
const Element& TVarArray<Element>::Iterator::operator*() const
{
       Q_ASSERT(m_arrayPtr != NULL);
       Q_ASSERT(BaseClass::IsInside(m_arrayPtr->GetSizes()));
 
       return m_arrayPtr->GetAt(*this);
}
 
 
template <class Element>
Element& TVarArray<Element>::Iterator::operator*()
{
       Q_ASSERT(m_arrayPtr != NULL);
       Q_ASSERT(BaseClass::IsInside(m_arrayPtr->GetSizes()));
 
       return m_arrayPtr->operator[](*this);
}
 
 
template <class Element>
const Element* TVarArray<Element>::Iterator::operator->() const
{
       Q_ASSERT(m_arrayPtr != NULL);
       Q_ASSERT(BaseClass::IsInside(m_arrayPtr->GetSizes()));
 
       return &m_arrayPtr->GetAt(*this);
}
 
 
template <class Element>
Element* TVarArray<Element>::Iterator::operator->()
{
       Q_ASSERT(m_arrayPtr != NULL);
       Q_ASSERT(BaseClass::IsInside(m_arrayPtr->GetSizes()));
 
       return &m_arrayPtr->operator[](*this);
}
 
 
template <class Element>
typename TVarArray<Element>::Iterator& TVarArray<Element>::Iterator::operator++()
{
       if ((m_arrayPtr != NULL) && !Increase(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;
       }
 
       return *this;
}
 
 
template <class Element>
typename TVarArray<Element>::Iterator TVarArray<Element>::Iterator::operator++(int)
{
       Iterator retVal = *this;
 
       if ((m_arrayPtr != NULL) && !Increase(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;
       }
 
       return retVal;
}
 
 
template <class Element>
typename TVarArray<Element>::Iterator& TVarArray<Element>::Iterator::operator--()
{
       if ((m_arrayPtr != NULL) && !Decrease(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;
       }
 
       return *this;
}
 
 
template <class Element>
typename TVarArray<Element>::Iterator TVarArray<Element>::Iterator::operator--(int)
{
       Iterator retVal = *this;
 
       if ((m_arrayPtr != NULL) && !Decrease(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;
       }
 
       return retVal;
}
 
 
template <class Element>
typename TVarArray<Element>::Iterator& TVarArray<Element>::Iterator::operator=(const Iterator& iterator)
{
       BaseClass::operator=(iterator);
 
       m_arrayPtr = iterator.m_arrayPtr;
}
 
 
template <class Element>
bool TVarArray<Element>::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>
bool TVarArray<Element>::Iterator::operator!=(const Iterator& iterator) const
{
       return !operator==(iterator);
}
 
 
// protected methods of emedded class Iterator
 
template <class Element>
TVarArray<Element>::Iterator::Iterator(TVarArray* arrayPtr)
:      BaseClass((arrayPtr != NULL)? arrayPtr->GetDimensionsCount(): 0, 0), m_arrayPtr(arrayPtr)
{
       if ((m_arrayPtr != NULL) && !IsInside(m_arrayPtr->GetSizes())){
              m_arrayPtr = NULL;   // if it is not inside of array set it directly to the end iterator state
       }
}
 
typedef TVarArray<double> CVarArray;
 
 
} // namespace istd