iterator_wrapper.h

Go to the documentation of this file.

/* $Id$ */
#ifndef ITERATOR_WRAPPER_H
#define ITERATOR_WRAPPER_H

namespace Tumble {
  namespace iterators {

        /* Define the movement operators (++, +=, +, --, -=, -) to
           just forward on. */
#define define_move_operators \
        iterator& operator++ ()          { ++it_; return *this; } \
        iterator& operator+= (int i)     { it_ += i; return *this; } \
        iterator operator+ (int i) const { return iterator(it_ + i); } \
 \
        iterator& operator-- ()          { --it_; return *this; } \
        iterator& operator-= (int i)     { it_ -= i; return *this; } \
        iterator operator- (int i) const { return iterator(it_ - i); }

        /* Define the relational operators (<, <=, ==, !=, >=, >)
           and the difference operator to simply forward. */
#define define_relational_operators \
        difference_type operator- (const iterator& other) const { \
          return it_ - other.it_; \
        } \
        bool operator<(const iterator& other) const { \
          return it_ < other.it_; \
        } \
        bool operator<=(const iterator& other) const { \
          return it_ <= other.it_; \
        } \
        bool operator==(const iterator& other) const { \
          return it_ == other.it_; \
        } \
        bool operator!=(const iterator& other) const { \
          return it_ != other.it_; \
        } \
        bool operator>(const iterator& other) const { \
          return it_ > other.it_; \
        } \
        bool operator>=(const iterator& other) const { \
          return it_ >= other.it_; \
        }



    template<class old_iterator, class output_type, class output_ref = output_type&>
      class caster {
        old_iterator it_;
        typedef caster iterator;

        public:
        /* Inherit some but not all traits. */
        typedef typename std::iterator_traits<old_iterator>::difference_type
          difference_type;
        typedef typename std::iterator_traits<old_iterator>::iterator_category
          iterator_category;
        typedef output_type  value_type;
        typedef output_ref   reference;
        typedef output_type* pointer;

        caster () { } // leave the iterator undefined.
        caster (const old_iterator& it) : it_(it) { }

        reference operator*() const {
          return static_cast<reference>(*it_);
        }
        reference operator[](const difference_type& i) const {
          return static_cast<reference>(it_[i]);
        }

        old_iterator base() { return it_; }

        define_move_operators;
        define_relational_operators;
      };

    template<class old_iterator, class output_type, class output_ref = output_type&>
      class dereferencer {
        old_iterator it_;
        typedef dereferencer iterator;

        public:
        /* Inherit some but not all traits. */
        typedef typename std::iterator_traits<old_iterator>::difference_type
          difference_type;
        typedef typename std::iterator_traits<old_iterator>::iterator_category
          iterator_category;
        typedef output_type  value_type;
        typedef output_ref   reference;
        typedef output_type* pointer;

        dereferencer () { } // leave the iterator undefined
        dereferencer (const old_iterator& it) : it_(it) { }

        reference operator*() const {
          return **it_;
        }
        reference operator[](const difference_type& i) const {
          return *it_[i];
        }

        old_iterator base() { return it_; }

        define_move_operators;
        define_relational_operators;
      };

    template<class old_iterator, class output_type, class output_ref = output_type&>
      class dedereferencer {
        old_iterator it_;
        typedef dedereferencer iterator;

        public:
        /* Inherit some but not all traits. */
        typedef typename std::iterator_traits<old_iterator>::difference_type
          difference_type;
        typedef typename std::iterator_traits<old_iterator>::iterator_category
          iterator_category;
        typedef output_type  value_type;
        typedef output_ref   reference;
        typedef output_type* pointer;

        dedereferencer () { } // leave the iterator undefined
        dedereferencer (const old_iterator& it) : it_(it) { }

        reference operator*() const {
          return **(*it_);
        }
        reference operator[](const difference_type& i) const {
          return **(it_[i]);
        }

        old_iterator base() { return it_; }

        define_move_operators;
        define_relational_operators;
      };
  } // namespace iterators.
} // namespace Tumble.

#endif

---