bucket_iterator.h

#pragma once
namespace stingray_plugin_foundation {
template <class CONTAINER, class ITEM>
class ConstBucketIterator;
// A helper class that makes an iterator for a bucket based data structure.
// Such a data structure has a number of random access buckets which may be
// "valid" or not. The iterator iterates over the valid buckets only.
template <class CONTAINER, class ITEM>
class BucketIterator {
public:
    typedef BucketIterator<CONTAINER, ITEM> iterator;
    friend class ConstBucketIterator<CONTAINER, ITEM>;
    typedef ITEM value_type;
    typedef ITEM* pointer;
    typedef ITEM& reference;
    typedef ptrdiff_t difference_type;
    typedef std::forward_iterator_tag iterator_category;
    inline BucketIterator() : _i(0) { }
    inline BucketIterator(CONTAINER &container, unsigned i);
    inline BucketIterator(const BucketIterator &other);
    inline bool operator==(const iterator &rhs) const   { return cmp(rhs) == 0; }
    inline bool operator!=(const iterator &rhs) const   { return cmp(rhs) != 0; }
    inline bool operator<(const iterator &rhs) const    { return cmp(rhs) <  0; }
    inline bool operator<=(const iterator &rhs) const   { return cmp(rhs) <=  0; }
    inline bool operator>(const iterator &rhs) const    { return cmp(rhs) >  0; }
    inline bool operator>=(const iterator &rhs) const   { return cmp(rhs) >=  0; }
    inline iterator operator++();
    inline iterator operator++(int);
    inline ITEM &operator*()                { return _container->bucket_value(_i); }
    inline ITEM *operator->()               { return &_container->bucket_value(_i); }
private:
    inline int cmp(const iterator &rhs) const {
        if(_container < rhs._container) return -1;
        else if(_container > rhs._container) return 1;
        else if(_i < rhs._i) return -1;
        else if(_i > rhs._i) return 1;
        else return 0;
    }
    void advance_to_valid_bucket();
    CONTAINER *_container;
    unsigned _i;
};
// A helper class that makes an iterator for a bucket based data structure.
// Such a data structure has a number of random access buckets which may be
// "valid" or not. The iterator iterates over the valid buckets only.
template <class CONTAINER, class ITEM>
class ConstBucketIterator {
public:
    typedef ConstBucketIterator<CONTAINER, ITEM> iterator;
    typedef ITEM value_type;
    typedef ITEM* pointer;
    typedef ITEM& reference;
    typedef ptrdiff_t difference_type;
    typedef std::forward_iterator_tag iterator_category;
    inline ConstBucketIterator() : _i(0) {}
    inline ConstBucketIterator(const CONTAINER &container, unsigned i);
    inline ConstBucketIterator(const ConstBucketIterator<CONTAINER, ITEM> &rhs);
    inline ConstBucketIterator(const BucketIterator<CONTAINER, ITEM> &rhs);
    inline bool operator==(const iterator &rhs) const   { return cmp(rhs) == 0; }
    inline bool operator!=(const iterator &rhs) const   { return cmp(rhs) != 0; }
    inline bool operator<(const iterator &rhs) const    { return cmp(rhs) <  0; }
    inline bool operator<=(const iterator &rhs) const   { return cmp(rhs) <=  0; }
    inline bool operator>(const iterator &rhs) const    { return cmp(rhs) >  0; }
    inline bool operator>=(const iterator &rhs) const   { return cmp(rhs) >=  0; }
    inline iterator operator++();
    inline iterator operator++(int);
    inline const ITEM &operator*()              { return _container->bucket_value(_i); }
    inline const ITEM *operator->()             { return &_container->bucket_value(_i); }
private:
    inline int cmp(const iterator &rhs) const {if (_container != rhs._container) return (int)(_container - rhs._container); return (int)(_i - rhs._i);}
    void advance_to_valid_bucket();
    const CONTAINER *_container;
    unsigned _i;
};
} // namespace stingray_plugin_foundation
#include "bucket_iterator.inl"