---

BitIterator.h

Go to the documentation of this file.

#ifndef CLASSLIB_BIT_ITERATOR_H
# define CLASSLIB_BIT_ITERATOR_H

//<<<<<< INCLUDES                                                       >>>>>>

# include "classlib/utils/BitOps.h"
# include <iterator>

namespace lat {
//<<<<<< PUBLIC DEFINES                                                 >>>>>>
//<<<<<< PUBLIC CONSTANTS                                               >>>>>>
//<<<<<< PUBLIC TYPES                                                   >>>>>>
//<<<<<< PUBLIC VARIABLES                                               >>>>>>
//<<<<<< PUBLIC FUNCTIONS                                               >>>>>>
//<<<<<< CLASS DECLARATIONS                                             >>>>>>

template <class T, unsigned int BITS>
class BitIterator ITERATOR_BASE(input_iterator, unsigned int, STDC::ptrdiff_t)
{
public:
    typedef std::input_iterator_tag     iterator_category;
    typedef unsigned int                value_type;
    typedef STDC::ptrdiff_t             difference_type;
    typedef void                        reference;
    typedef void                        pointer;

    BitIterator (void);
    BitIterator (const T *data, unsigned int bitpos);
    // implicit copy constructor
    // implicit destructor
    // implicit assignment operator

    bool                operator== (const BitIterator &x) const;
    bool                operator!= (const BitIterator &x) const;
    bool                operator< (const BitIterator &x) const;
    bool                operator<= (const BitIterator &x) const;
    bool                operator> (const BitIterator &x) const;
    bool                operator>= (const BitIterator &x) const;

    T                   operator* (void) const;
    T                   operator[] (difference_type n) const;
    BitIterator &       operator++ (void);
    BitIterator         operator++ (int);
    BitIterator &       operator-- (void);
    BitIterator         operator-- (int);

    BitIterator &       operator+= (difference_type n);
    difference_type     operator- (const BitIterator &x) const;
    BitIterator &       operator-= (difference_type n);

private:
    const T             *m_data;
    unsigned int        m_bit;
};

//<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
//<<<<<< INLINE MEMBER FUNCTIONS                                        >>>>>>

template <class T, unsigned int BITS>
inline
BitIterator<T,BITS>::BitIterator (void)
    : m_data (0),
      m_bit (0)
{}

template <class T, unsigned int BITS>
inline
BitIterator<T,BITS>::BitIterator (const T *data, unsigned int bit)
    : m_data (data),
      m_bit (bit)
{}

template <class T, unsigned int BITS>
inline bool
BitIterator<T,BITS>::operator== (const BitIterator &x) const
{ return m_data == x.m_data && m_bit == x.m_bit; }

template <class T, unsigned int BITS>
inline bool
BitIterator<T,BITS>::operator!= (const BitIterator &x) const
{ return !(*this == x); }

template <class T, unsigned int BITS>
inline bool
BitIterator<T,BITS>::operator< (const BitIterator &x) const
{ return m_bit < x.m_bit; }

template <class T, unsigned int BITS>
inline bool
BitIterator<T,BITS>::operator<= (const BitIterator &x) const
{ return m_bit <= x.m_bit; }

template <class T, unsigned int BITS>
inline bool
BitIterator<T,BITS>::operator> (const BitIterator &x) const
{ return m_bit > x.m_bit; }

template <class T, unsigned int BITS>
inline bool
BitIterator<T,BITS>::operator>= (const BitIterator &x) const
{ return m_bit >= x.m_bit; }

template <class T, unsigned int BITS>
inline T
BitIterator<T,BITS>::operator* (void) const
{ return (BitTraits<T>::Bits % BITS == 0
          ? BitOps<T>::extractSafe (m_data, m_bit * BITS, BITS)
          : BitOps<T>::extractStraddledSafe (m_data, m_bit * BITS, BITS)); }

template <class T, unsigned int BITS>
inline T
BitIterator<T,BITS>::operator[] (difference_type n) const
{ return *(*this + n); }

template <class T, unsigned int BITS>
inline BitIterator<T,BITS> &
BitIterator<T,BITS>::operator++ (void)
{ m_bit++; return *this; }

template <class T, unsigned int BITS>
inline BitIterator<T,BITS>
BitIterator<T,BITS>::operator++ (int)
{ BitIterator<T,BITS> old (*this); ++*this; return old; }

template <class T, unsigned int BITS>
inline BitIterator<T,BITS> &
BitIterator<T,BITS>::operator-- (void)
{ m_bit--; return *this; }

template <class T, unsigned int BITS>
inline BitIterator<T,BITS>
BitIterator<T,BITS>::operator-- (int)
{ BitIterator<T,BITS> old (*this); --*this; return old; }

template <class T, unsigned int BITS>
inline BitIterator<T,BITS>
operator+ (const BitIterator<T,BITS> &x,
           typename BitIterator<T,BITS>::difference_type n)
{ BitIterator<T,BITS> r (x); r += n; return r; }

template <class T, unsigned int BITS>
inline BitIterator<T,BITS>
operator+ (typename BitIterator<T,BITS>::difference_type n,
           const BitIterator<T,BITS> &x)
{ BitIterator<T,BITS> r (x); r += n; return r; }

template <class T, unsigned int BITS>
inline BitIterator<T,BITS> &
BitIterator<T,BITS>::operator+= (difference_type n)
{ return m_bit += n; }

template <class T, unsigned int BITS>
inline BitIterator<T,BITS>
operator- (const BitIterator<T,BITS> &x,
           typename BitIterator<T,BITS>::difference_type n)
{ BitIterator<T,BITS> r (x); r -= n; return r; }

template <class T, unsigned int BITS>
inline typename BitIterator<T,BITS>::difference_type
BitIterator<T,BITS>::operator- (const BitIterator<T,BITS> &x) const
{ return m_bit - x.m_bit; }

template <class T, unsigned int BITS>
inline BitIterator<T,BITS> &
BitIterator<T,BITS>::operator-= (difference_type n)
{ return m_bit -= n; }

} // namespace lat
#endif // CLASSLIB_BIT_ITERATOR_H

---