TArray.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// STL includes
#include <vector>
 
// Qt includes
#include <QtCore/QtGlobal>
 
// ICF 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;
    };
 
    TArray();
    TArray(TArray&& array) = default;
    TArray(const TArray& array) = default;
    explicit TArray(const SizesType& sizes);
 
    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
    TArray& operator=(TArray&& array) = default;
    TArray& operator=(const TArray& array) = default;
 
    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();
 
    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 SizesType& sizes)
:   m_sizes(sizes)
{
    UpdateElementsSize();
}
 
 
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()
{
    int cumulatedSizes = 1;
    for (int i = 0; i < Dimensions; ++i){
        cumulatedSizes *= m_sizes[i];
    }
 
    m_elements.resize(cumulatedSizes);
}
 
 
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(nullptr);
 
 
// 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 != nullptr);
    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 != nullptr);
    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 != nullptr);
    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 != nullptr);
    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 != nullptr) && !BaseClass::Increase(m_arrayPtr->GetSizes())){
        m_arrayPtr = nullptr;
    }
 
    return *this;
}
 
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::iterator TArray<Element, Dimensions>::iterator::operator++(int)
{
    iterator retVal = *this;
 
    if ((m_arrayPtr != nullptr) && !BaseClass::Increase(m_arrayPtr->GetSizes())){
        m_arrayPtr = nullptr;
    }
 
    return retVal;
}
 
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::iterator& TArray<Element, Dimensions>::iterator::operator--()
{
    if ((m_arrayPtr != nullptr) && !Decrease(m_arrayPtr->GetSizes())){
        m_arrayPtr = nullptr;
    }
 
    return *this;
}
 
 
template <class Element, int Dimensions>
typename TArray<Element, Dimensions>::iterator TArray<Element, Dimensions>::iterator::operator--(int)
{
    iterator retVal = *this;
 
    if ((m_arrayPtr != nullptr) && !Decrease(m_arrayPtr->GetSizes())){
        m_arrayPtr = nullptr;
    }
 
    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;
}
 
 
template <class Element, int Dimensions>
bool TArray<Element, Dimensions>::iterator::operator==(const iterator& iterator) const
{
    if ((m_arrayPtr != nullptr) && (iterator.m_arrayPtr != nullptr)){
        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 != nullptr) && !BaseClass::IsInside(m_arrayPtr->GetSizes())){
        m_arrayPtr = nullptr;   // if it is not inside of array set it directly to the end iterator state
    }
}
 
 
} // namespace istd