CFastBinaryIndex.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
 
 
// ICF 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(nullptr), 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 != nullptr);
 
    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