TIndex.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/QtGlobal>
 
 
namespace istd
{
 
 
template <int Dimensions>
class TIndex
{
public:
       typedef int IndexType;
       typedef int* Iterator;
 
       enum
       {
              DIMENSIONS = Dimensions
       };
 
       TIndex();
 
       explicit TIndex(int value);
 
       TIndex(const TIndex& index);
 
       bool IsValid() const;
 
       bool IsZero() const;
 
       bool IsSizeEmpty() const;
 
       void Reset();
 
       void Clear();
 
       bool IsDimensionsCountFixed() const;
 
       int GetDimensionsCount() const;
 
       bool SetDimensionsCount(int count) const;
 
       int GetAt(int index) const;
 
       void SetAt(int index, int value);
 
       void SetAllTo(int value);
 
       bool IncreaseAt(int index);
 
       bool DecreaseAt(int index);
 
       bool IsInside(const TIndex& boundaries) const;
 
       bool Increase(const TIndex& boundaries);
 
       bool Decrease(const TIndex& boundaries);
 
       int GetProductVolume() const;
 
       int GetIterationIndex(const TIndex& boundaries) const;
 
       Iterator Begin() const;
       Iterator End() const;
 
       int operator[](int index) const;
       int& operator[](int index);
 
       bool operator==(const TIndex& index) const;
       bool operator!=(const TIndex& index) const;
 
       TIndex operator+(const TIndex& index) const;
       TIndex& operator+=(const TIndex& index);
       TIndex operator-(const TIndex& index) const;
    TIndex& operator-=(const TIndex& index);
    TIndex& operator=(const TIndex& index) = default;
 
       // static methods
       static const TIndex<Dimensions>& GetZero();
       static const TIndex<Dimensions>& GetInvalid();
 
private:
       int m_elements[Dimensions];
 
       // static attributes
       static TIndex<Dimensions> s_zeroInstance;
       static TIndex<Dimensions> s_invalidInstance;
};
 
 
// inline methods
 
template <int Dimensions>
inline bool TIndex<Dimensions>::IsDimensionsCountFixed() const
{
       return true;
}
 
 
template <int Dimensions>
inline int TIndex<Dimensions>::GetDimensionsCount() const
{
       return Dimensions;
}
 
 
template <int Dimensions>
inline bool TIndex<Dimensions>::SetDimensionsCount(int count) const
{
       return (count == GetDimensionsCount());
}
 
 
template <int Dimensions>
inline bool TIndex<Dimensions>::IsValid() const
{
       for (int i = 0; i < Dimensions; ++i){
              if (m_elements[i] < 0){
                     return false;
              }
       }
 
       return true;
}
 
 
template <int Dimensions>
inline bool TIndex<Dimensions>::IsZero() const
{
       for (int i = 0; i < Dimensions; ++i){
              if (m_elements[i] > 0){
                     return false;
              }
       }
 
       return true;
}
 
 
template <int Dimensions>
inline bool TIndex<Dimensions>::IsSizeEmpty() const
{
       for (int i = 0; i < Dimensions; ++i){
              if (m_elements[i] <= 0){
                     return true;
              }
       }
 
       return false;
}
 
 
template <int Dimensions>
inline void TIndex<Dimensions>::Reset()
{
       Clear();
}
 
 
template <int Dimensions>
inline void TIndex<Dimensions>::Clear()
{
       SetAllTo(0);
}
 
 
template <int Dimensions>
inline int TIndex<Dimensions>::GetAt(int index) const
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < Dimensions);
 
       return m_elements[index];
}
 
 
template <int Dimensions>
inline void TIndex<Dimensions>::SetAt(int index, int value)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < Dimensions);
 
       m_elements[index] = value;
}
 
 
template <int Dimensions>
inline bool TIndex<Dimensions>::IncreaseAt(int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < Dimensions);
 
       ++m_elements[index];
 
       return true;
}
 
 
template <int Dimensions>
inline bool TIndex<Dimensions>::DecreaseAt(int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < Dimensions);
 
       --m_elements[index];
 
       return true;
}
 
 
template <int Dimensions>
inline typename TIndex<Dimensions>::Iterator TIndex<Dimensions>::Begin() const
{
       return (Iterator)&m_elements[0];
}
 
 
template <int Dimensions>
inline typename TIndex<Dimensions>::Iterator TIndex<Dimensions>::End() const
{
       return (Iterator)&m_elements[Dimensions];
}
 
 
template <int Dimensions>
inline int TIndex<Dimensions>::operator[](int index) const
{
       return GetAt(index);
}
 
 
template <int Dimensions>
inline int& TIndex<Dimensions>::operator[](int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < Dimensions);
 
       return m_elements[index];
}
 
 
template <int Dimensions>
bool TIndex<Dimensions>::operator==(const TIndex& index) const
{
       for (int i = 0; i < Dimensions; ++i){
              if (m_elements[i] != index.m_elements[i]){
                     return false;
              }
       }
 
       return true;
}
 
 
template <int Dimensions>
bool TIndex<Dimensions>::operator!=(const TIndex& index) const
{
       return !operator==(index);
}
 
 
template <int Dimensions>
TIndex<Dimensions> TIndex<Dimensions>::operator+(const TIndex<Dimensions>& index) const
{
       Q_ASSERT(Dimensions >= index.GetDimensionsCount());
 
       TIndex<Dimensions> retVal = *this;
 
       for (int i = 0; i < Dimensions; ++i){
              retVal[i] += index[i];
       }
 
       return retVal;
}
 
 
template <int Dimensions>
TIndex<Dimensions>& TIndex<Dimensions>::operator+=(const TIndex<Dimensions>& index)
{
       Q_ASSERT(Dimensions >= index.GetDimensionsCount());
 
       for (int i = 0; i < Dimensions; ++i){
              m_elements[i] += index[i];
       }
 
       return *this;
}
 
 
template <int Dimensions>
TIndex<Dimensions> TIndex<Dimensions>::operator-(const TIndex<Dimensions>& index) const
{
       Q_ASSERT(Dimensions >= index.GetDimensionsCount());
 
       TIndex<Dimensions> retVal = *this;
 
       for (int i = 0; i < Dimensions; ++i){
              retVal[i] -= index[i];
       }
 
       return retVal;
}
 
 
template <int Dimensions>
TIndex<Dimensions>& TIndex<Dimensions>::operator-=(const TIndex<Dimensions>& index)
{
       Q_ASSERT(Dimensions >= index.GetDimensionsCount());
 
       for (int i = 0; i < Dimensions; ++i){
              m_elements[i] -= index[i];
       }
 
       return *this;
}
 
 
 
// public methods
 
template <int Dimensions>
TIndex<Dimensions>::TIndex(int value)
{
       SetAllTo(value);
}
 
 
template <int Dimensions>
TIndex<Dimensions>::TIndex()
{
       for (int i = 0; i < Dimensions; ++i){
              m_elements[i] = 0;
       }
}
 
 
template <int Dimensions>
TIndex<Dimensions>::TIndex(const TIndex& index)
{
       for (int i = 0; i < Dimensions; ++i){
              m_elements[i] = index.m_elements[i];
       }
}
 
 
template <int Dimensions>
void TIndex<Dimensions>::SetAllTo(int value)
{
       for (int i = 0; i < Dimensions; ++i){
              m_elements[i] = value;
       }
}
 
 
template <int Dimensions>
bool TIndex<Dimensions>::IsInside(const TIndex& boundaries) const
{
       for (int i = 0; i < Dimensions; ++i){
              Q_ASSERT(m_elements[i] >= 0);
 
              if (m_elements[i] >= boundaries.m_elements[i]){
                     return false;
              }
       }
 
       return true;
}
 
 
template <int Dimensions>
bool TIndex<Dimensions>::Increase(const TIndex& boundaries)
{
       Q_ASSERT(IsInside(boundaries));
 
       // Iterate in column-major order (dimension 0 first)
       for (int i = 0; i < Dimensions; ++i){
              if (m_elements[i] < boundaries.m_elements[i] - 1){
                     m_elements[i]++;
                     for (int j = 0; j < i; ++j){
                            m_elements[j] = 0;
                     }
 
                     return true;
              }
       }
 
       SetAllTo(0);
 
       return false;
}
 
 
template <int Dimensions>
bool TIndex<Dimensions>::Decrease(const TIndex& boundaries)
{
       Q_ASSERT(IsInside(boundaries));
 
       // Iterate in column-major order (dimension 0 first)
       for (int i = 0; i < Dimensions; ++i){
              if (m_elements[i] > 0){
                     m_elements[i]--;
 
                     for (int j = 0; j < i; ++j){
                            m_elements[j] = boundaries.m_elements[j] - 1;
                     }
 
                     return true;
              }
       }
 
       for (int j = 0; j < Dimensions; ++j){
              m_elements[j] = boundaries.m_elements[j] - 1;
       }
 
       return false;
}
 
 
template <int Dimensions>
int TIndex<Dimensions>::GetProductVolume() const
{
       int retVal = 1;
 
       for (int i = 0; i < Dimensions; ++i){
              retVal *= m_elements[i];
       }
 
       return retVal;
}
 
 
template <int Dimensions>
int TIndex<Dimensions>::GetIterationIndex(const TIndex& boundaries) const
{
       int retVal = 0;
 
       int positionBase = 1;
       for (int i = 0; i < Dimensions; ++i){
              retVal += m_elements[i] * positionBase;
 
              positionBase *= boundaries.m_elements[i];
       }
 
       return retVal;
}
 
 
// static methods
 
template <int Dimensions>
const TIndex<Dimensions>& TIndex<Dimensions>::GetZero()
{
       return s_zeroInstance;
}
 
 
template <int Dimensions>
const TIndex<Dimensions>& TIndex<Dimensions>::GetInvalid()
{
       return s_invalidInstance;
}
 
 
// static attributes
 
template <int Dimensions>
TIndex<Dimensions> TIndex<Dimensions>::s_zeroInstance(0);
template <int Dimensions>
TIndex<Dimensions> TIndex<Dimensions>::s_invalidInstance(-1);
 
 
// related global functions
 
template <int Dimensions>
inline uint qHash(const TIndex<Dimensions>& key, uint seed = 0)
{
       uint retVal = seed;
 
       for (int i = 0; i < Dimensions; ++i){
              uint value = uint(key[i]);
 
              retVal *= 16187;     // some big enough prime number
              retVal ^= value;
       }
 
       return retVal;
}
 
 
} // namespace istd