CVarIndex.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/TIndex.h>
 
// std includes
#include <vector>
 
 
namespace istd
{
 
 
class CVarIndex
{
public:
       typedef int IndexType;
       typedef QVector<int> Elements;
       typedef Elements::iterator Iterator;
 
       CVarIndex();
 
       explicit CVarIndex(int size, int value = 0);
 
       CVarIndex(const CVarIndex& index);
 
       CVarIndex(const std::vector<IndexType>& values);
 
       CVarIndex(const Elements& values);
 
       template <int Dimensions>
       CVarIndex(const TIndex<Dimensions> index);
 
       std::vector<int> ToStdVector() const
       {
              return std::vector<int>(m_elements.begin(), m_elements.end());
       }
 
       bool IsValid() const;
 
       bool IsZero() const;
 
       bool IsSizeEmpty() const;
 
       void Reset();
 
       void Clear();
 
       bool IsDimensionsCountFixed() const;
 
       int GetDimensionsCount() const;
 
       bool SetDimensionsCount(int count, int value = 0);
 
       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 CVarIndex& boundaries) const;
 
       bool Increase(const CVarIndex& boundaries);
 
       bool Decrease(const CVarIndex& boundaries);
 
       int GetProductVolume() const;
 
       int GetIterationIndex(const CVarIndex& boundaries) const;
 
       int GetMinDimensionsCount() const;
 
       istd::CVarIndex GetExpanded(const istd::CVarIndex& other) const;
 
       Iterator Begin() const;
       Iterator End() const;
 
       int operator[](int index) const;
       int& operator[](int index);
 
       bool operator==(const CVarIndex& index) const;
       bool operator!=(const CVarIndex& index) const;
       bool operator<(const CVarIndex& index) const;
       bool operator>(const CVarIndex& index) const;
       bool operator<=(const CVarIndex& index) const;
       bool operator>=(const CVarIndex& index) const;
 
       CVarIndex& operator=(const CVarIndex& index);
       CVarIndex& operator+=(const CVarIndex& index);
       CVarIndex& operator-=(const CVarIndex& index);
 
       friend uint qHash(const CVarIndex& index, uint seed);
 
private:
       Elements m_elements;
};
 
 
// inline methods
 
inline bool CVarIndex::IsDimensionsCountFixed() const
{
       return false;
}
 
 
inline int CVarIndex::GetDimensionsCount() const
{
       return int(m_elements.size());
}
 
 
inline bool CVarIndex::SetDimensionsCount(int count, int value)
{
       int lastSize = m_elements.size();
 
       m_elements.resize(count);
 
       for (int i = lastSize; i < count; ++i){
              m_elements[i] = value;
       }
 
       return true;
}
 
 
inline int CVarIndex::GetAt(int index) const
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < int(m_elements.size()));
 
       return m_elements[index];
}
 
 
inline void CVarIndex::SetAt(int index, int value)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < int(m_elements.size()));
 
       m_elements[index] = value;
}
 
 
inline bool CVarIndex::IncreaseAt(int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < int(m_elements.size()));
 
       ++m_elements[index];
 
       return true;
}
 
 
inline bool CVarIndex::DecreaseAt(int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < int(m_elements.size()));
 
       --m_elements[index];
 
       return true;
}
 
 
inline int CVarIndex::GetProductVolume() const
{
       int retVal = 1;
 
       int dimensionsCount = GetDimensionsCount();
 
       for (int i = 0; i < dimensionsCount; ++i){
              retVal *= GetAt(i);
       }
 
       return retVal;
}
 
 
inline int CVarIndex::GetMinDimensionsCount() const
{
       int dimensionsCount = GetDimensionsCount();
 
       for (int i = dimensionsCount - 1; i >= 0; --i){
              if (GetAt(i) > 0){
                     return i + 1;
              }
       }
 
       return 0;
}
 
 
inline istd::CVarIndex CVarIndex::GetExpanded(const istd::CVarIndex& other) const
{
       istd::CVarIndex retVal(*this);
 
       retVal.m_elements += other.m_elements;
 
       return retVal;
}
 
 
inline CVarIndex::Iterator CVarIndex::Begin() const
{
       return const_cast<CVarIndex*>(this)->m_elements.begin();
}
 
 
inline CVarIndex::Iterator CVarIndex::End() const
{
       return const_cast<CVarIndex*>(this)->m_elements.end();
}
 
 
inline int CVarIndex::operator[](int index) const
{
       return GetAt(index);
}
 
 
inline int& CVarIndex::operator[](int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < int(m_elements.size()));
 
       return m_elements[index];
}
 
 
 
inline bool CVarIndex::operator<(const CVarIndex& index) const
{
       int count = m_elements.size();
       int indexCount = index.m_elements.size();
       int commonSize = qMin(count, indexCount);
       for (int i = 0; i < commonSize; ++i){
              int element = m_elements[i];
              int indexElement = index.m_elements[i];
              if (element != indexElement){
                     return element < indexElement;
              }
       }
 
       return count < indexCount;
}
 
 
inline bool CVarIndex::operator>(const CVarIndex& index) const
{
       int count = m_elements.size();
       int indexCount = index.m_elements.size();
       int commonSize = qMin(count, indexCount);
       for (int i = 0; i < commonSize; ++i){
              int element = m_elements[i];
              int indexElement = index.m_elements[i];
              if (element != indexElement){
                     return element > indexElement;
              }
       }
 
       return count > indexCount;
}
 
 
inline bool CVarIndex::operator<=(const CVarIndex& index) const
{
       int count = m_elements.size();
       int indexCount = index.m_elements.size();
       int commonSize = qMin(count, indexCount);
       for (int i = 0; i < commonSize; ++i){
              int element = m_elements[i];
              int indexElement = index.m_elements[i];
              if (element != indexElement){
                     return element < indexElement;
              }
       }
 
       return count <= indexCount;
}
 
 
inline bool CVarIndex::operator>=(const CVarIndex& index) const
{
       int count = m_elements.size();
       int indexCount = index.m_elements.size();
       int commonSize = qMin(count, indexCount);
       for (int i = 0; i < commonSize; ++i){
              int element = m_elements[i];
              int indexElement = index.m_elements[i];
              if (element != indexElement){
                     return element > indexElement;
              }
       }
 
       return count >= indexCount;
}
 
 
// public template methods
 
template <int Dimensions>
CVarIndex::CVarIndex(const TIndex<Dimensions> index)
:      m_elements(Dimensions)
{
       for (int i = 0; i < Dimensions; ++i){
              m_elements[i] = index[i];
       }
}
 
 
// related global functions
 
uint qHash(const CVarIndex& index, uint seed = 0);
 
 
} // namespace istd