filtered_iterator.h

Go to the documentation of this file.

#ifndef FILTERED_ITERATOR_H
#define FILTERED_ITERATOR_H
 
#include "boost/iterator/filter_iterator.hpp"
 
namespace bitrl
{
 
template <typename PREDICATE, typename TYPE> class FilteredIterator
{
 
  public:
    typedef PREDICATE predicate;
    typedef TYPE iterator_type;
    typedef typename boost::filter_iterator<PREDICATE, TYPE> iterator_t;
    typedef typename iterator_t::value_type value_type;
 
    FilteredIterator();
 
    FilteredIterator(predicate p, iterator_type begin, iterator_type end);
 
    FilteredIterator(iterator_type begin, iterator_type end);
 
    FilteredIterator(const FilteredIterator &o);
 
    virtual ~FilteredIterator() {}
 
    FilteredIterator &operator++();
 
    FilteredIterator operator++(int);
 
    iterator_t get_iterator() { return it_; }
 
    value_type operator*() const { return *it_; }
 
    template <typename Pred, typename Type>
    friend bool operator==(const FilteredIterator<Pred, Type> &lhs,
                           const FilteredIterator<Pred, Type> &rhs);
 
  private:
    iterator_t it_;
};
 
template <typename PREDICATE, typename TYPE>
FilteredIterator<PREDICATE, TYPE>::FilteredIterator() : it_()
{
}
 
template <typename PREDICATE, typename TYPE>
FilteredIterator<PREDICATE, TYPE>::FilteredIterator(
    typename FilteredIterator<PREDICATE, TYPE>::predicate p,
    typename FilteredIterator<PREDICATE, TYPE>::iterator_type begin,
    typename FilteredIterator<PREDICATE, TYPE>::iterator_type end)
    : it_(boost::make_filter_iterator(p, begin, end))
{
}
 
template <typename PREDICATE, typename TYPE>
FilteredIterator<PREDICATE, TYPE>::FilteredIterator(
    typename FilteredIterator<PREDICATE, TYPE>::iterator_type begin,
    typename FilteredIterator<PREDICATE, TYPE>::iterator_type end)
    : it_(boost::make_filter_iterator(PREDICATE(), begin, end))
{
}
 
template <typename PREDICATE, typename TYPE>
FilteredIterator<PREDICATE, TYPE>::FilteredIterator(const FilteredIterator<PREDICATE, TYPE> &o)
    : it_(o.it_)
{
}
 
template <typename PREDICATE, typename TYPE>
FilteredIterator<PREDICATE, TYPE> &FilteredIterator<PREDICATE, TYPE>::operator++()
{
    it_++;
    return *this;
}
 
template <typename PREDICATE, typename TYPE>
FilteredIterator<PREDICATE, TYPE> FilteredIterator<PREDICATE, TYPE>::operator++(int)
{
    FilteredIterator<PREDICATE, TYPE> tmp(*this);
    ++it_;
    return tmp;
}
 
template <typename Pred, typename Type>
inline bool operator==(const FilteredIterator<Pred, Type> &lhs,
                       const FilteredIterator<Pred, Type> &rhs)
{
    return lhs.it_ == rhs.it_;
}
 
template <typename Pred, typename Type>
inline bool operator!=(const FilteredIterator<Pred, Type> &lhs,
                       const FilteredIterator<Pred, Type> &rhs)
{
 
    return !(lhs == rhs);
}
 
} // namespace bitrl
#endif