CFastBinaryIndex.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
 
 
// ACF includes
#include <istd/CBitManip.h>
 
 
namespace istd
{
 
 
class CFastBinaryIndex
{
public:
       typedef int IndexType;
 
       enum{
              MAX_ELEMENTS_COUNT = 31
       };
 
       class Iterator
       {
       public:
              Iterator();
              Iterator(const CFastBinaryIndex* indexPtr, int position);
              Iterator(const Iterator& iter);
 
              int operator*();
              Iterator& operator++();
              Iterator operator++(int);
 
              bool operator==(const Iterator& iter) const;
              bool operator!=(const Iterator& iter) const;
 
              Iterator& operator=(const Iterator& iter);
 
       private:
              const CFastBinaryIndex* m_indexPtr;
              int m_position;
       };
 
       CFastBinaryIndex();
 
       explicit CFastBinaryIndex(int size, int value = 0);
 
       explicit CFastBinaryIndex(quint32 bits, int size, int dummy);
 
       CFastBinaryIndex(const CFastBinaryIndex& index);
 
       bool IsValid() const;
 
       bool IsZero() const;
 
       void Reset();
 
       void Clear();
 
       bool IsDimensionsCountFixed() const;
 
       int GetDimensionsCount() const;
 
       bool SetDimensionsCount(int count);
 
       int GetAt(int index) const;
 
       void SetAt(int index, int value);
 
       quint32 GetBits() const;
 
       void SetAllTo(int value);
 
       bool IncreaseAt(int index);
 
       bool DecreaseAt(int index);
 
       int GetProductVolume() const;
 
       bool IsInside(const CFastBinaryIndex& boundaries) const;
 
       bool Increase(const CFastBinaryIndex& boundaries);
 
       bool Decrease(const CFastBinaryIndex& boundaries);
 
       Iterator Begin() const;
       Iterator End() const;
 
       int operator[](int index) const;
 
       bool operator==(const CFastBinaryIndex& index) const;
       bool operator!=(const CFastBinaryIndex& index) const;
 
private:
       quint32 m_bits;
       int m_size;
};
 
 
// inline methods
 
inline CFastBinaryIndex::CFastBinaryIndex()
:      m_bits(0), m_size(0)
{
}
 
 
inline CFastBinaryIndex::CFastBinaryIndex(int size, int value)
{
       m_size = size;
 
       SetAllTo(value);
}
 
 
inline CFastBinaryIndex::CFastBinaryIndex(quint32 bits, int size, int /*dummy*/)
:      m_bits(bits), m_size(size)
{
       Q_ASSERT(CBitManip::instance.GetFirstBitIndex(bits) < size);
}
 
 
inline CFastBinaryIndex::CFastBinaryIndex(const CFastBinaryIndex& index)
:      m_bits(index.m_bits), m_size(index.m_size)
{
       Q_ASSERT(m_size <= MAX_ELEMENTS_COUNT);
       Q_ASSERT((m_bits >> m_size) == 0);
}
 
 
inline bool CFastBinaryIndex::IsValid() const
{
       return true;
}
 
 
inline bool CFastBinaryIndex::IsZero() const
{
       return m_bits == 0;
}
 
 
inline void CFastBinaryIndex::Reset()
{
       m_size = 0;
       m_bits = 0;
}
 
 
inline void CFastBinaryIndex::Clear()
{
       m_size = 0;
       m_bits = 0;
}
 
 
inline bool CFastBinaryIndex::IsDimensionsCountFixed() const
{
       return false;
}
 
 
inline int CFastBinaryIndex::GetDimensionsCount() const
{
       return m_size;
}
 
 
inline bool CFastBinaryIndex::SetDimensionsCount(int count)
{
       if (count <= MAX_ELEMENTS_COUNT){
              m_size = count;
              m_bits &= quint32(1 << m_size) - 1;
 
              return true;
       }
 
       return false;
}
 
 
inline int CFastBinaryIndex::GetAt(int index) const
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < m_size);
 
       return int(m_bits >> index) & 1;
}
 
 
inline void CFastBinaryIndex::SetAt(int index, int value)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < m_size);
 
       if (value > 0){
              m_bits |= quint32(1 << index);
       }
       else{
              m_bits &= ~quint32(1 << index);
       }
}
 
 
inline quint32 CFastBinaryIndex::GetBits() const
{
       return m_bits;
}
 
 
inline void CFastBinaryIndex::SetAllTo(int value)
{
       if (value){
              m_bits = quint32(1 << m_size) - 1;
       }
       else{
              m_bits = 0;
       }
}
 
 
inline bool CFastBinaryIndex::IncreaseAt(int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < m_size);
 
       quint32 mask = quint32(1 << index);
 
       bool retVal = ((m_bits & mask) == 0);
 
       m_bits |= mask;
 
       return retVal;
}
 
 
inline bool CFastBinaryIndex::DecreaseAt(int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < m_size);
 
       quint32 mask = quint32(1 << index);
 
       bool retVal = ((m_bits & mask) != 0);
 
       m_bits &= ~mask;
 
       return retVal;
}
 
 
inline bool CFastBinaryIndex::IsInside(const CFastBinaryIndex& boundaries) const
{
       return (((boundaries.m_bits + 1) & quint32(1 << m_size)) != 0);
}
 
 
inline bool CFastBinaryIndex::Increase(const CFastBinaryIndex& /*boundaries*/)
{
       return false;
}
 
 
inline bool CFastBinaryIndex::Decrease(const CFastBinaryIndex& /*boundaries*/)
{
       return false;
}
 
 
inline int CFastBinaryIndex::GetProductVolume() const
{
       return int(m_bits + 1) >> m_size;  // it is 1 if all bits are 1
}
 
 
inline CFastBinaryIndex::Iterator CFastBinaryIndex::Begin() const
{
       return Iterator(this, 0);
}
 
 
inline CFastBinaryIndex::Iterator CFastBinaryIndex::End() const
{
       return Iterator(this, m_size);
}
 
 
inline int CFastBinaryIndex::operator[](int index) const
{
       return GetAt(index);
}
 
 
inline bool CFastBinaryIndex::operator==(const CFastBinaryIndex& index) const
{
       return (m_size == index.m_size) && (m_bits == index.m_bits);
}
 
 
inline bool CFastBinaryIndex::operator!=(const CFastBinaryIndex& index) const
{
       return (m_size != index.m_size) || (m_bits != index.m_bits);
}
 
 
// inline methods of embedded class Iterator
 
inline CFastBinaryIndex::Iterator::Iterator()
:      m_indexPtr(NULL), m_position(0)
{
}
 
 
inline CFastBinaryIndex::Iterator::Iterator(const CFastBinaryIndex* indexPtr, int position)
:      m_indexPtr(indexPtr), m_position(position)
{
}
 
 
inline CFastBinaryIndex::Iterator::Iterator(const Iterator& iter)
:      m_indexPtr(iter.m_indexPtr), m_position(iter.m_position)
{
}
 
 
inline int CFastBinaryIndex::Iterator::operator*()
{
       Q_ASSERT(m_indexPtr != NULL);
 
       return m_indexPtr->GetAt(m_position);
}
 
 
inline CFastBinaryIndex::Iterator& CFastBinaryIndex::Iterator::operator++()
{
       ++m_position;
 
       return *this;
}
 
 
inline CFastBinaryIndex::Iterator CFastBinaryIndex::Iterator::operator++(int)
{
       Iterator retVal(*this);
 
       ++m_position;
 
       return retVal;
}
 
 
inline bool CFastBinaryIndex::Iterator::operator==(const Iterator& iter) const
{
       return (m_indexPtr == iter.m_indexPtr) && (m_position == iter.m_position);
}
 
 
inline bool CFastBinaryIndex::Iterator::operator!=(const Iterator& iter) const
{
       return (m_indexPtr != iter.m_indexPtr) || (m_position != iter.m_position);
}
 
 
inline CFastBinaryIndex::Iterator& CFastBinaryIndex::Iterator::operator=(const Iterator& iter)
{
       m_indexPtr = iter.m_indexPtr;
       m_position = iter.m_position;
 
       return *this;
}
 
 
} // namespace istd