iterator.hpp

Go to the documentation of this file.

/*
  CLAW - a C++ Library Absolutely Wonderful
 
  CLAW is a free library without any particular aim but being useful to
  anyone.
 
  Copyright (C) 2005-2011 Julien Jorge
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
  contact: julien.jorge@stuff-o-matic.com
*/
#ifndef __CLAW_ITERATOR_HPP__
#define __CLAW_ITERATOR_HPP__
 
#include <iterator>
 
namespace claw
{
  template <typename Category, typename Value, typename Iterator,
            typename Function>
  class wrapped_iterator_by_category
  {}; // class wrapped_iterator_by_category

  template <typename Value, typename Iterator, typename Function>
  class wrapped_iterator_by_category<std::forward_iterator_tag, Value,
                                     Iterator, Function>
  {
  public:
    typedef typename std::iterator_traits<Iterator>::difference_type
        difference_type;
    typedef Value value_type;
    typedef value_type* pointer;
    typedef value_type& reference;
    typedef typename std::iterator_traits<Iterator>::iterator_category
        iterator_category;
 
    typedef wrapped_iterator_by_category<std::forward_iterator_tag, Value,
                                         Iterator, Function>
        self_type;
 
  public:
    wrapped_iterator_by_category()
    {}
    wrapped_iterator_by_category(const Iterator& it)
      : m_it(it)
    {}
    wrapped_iterator_by_category(const Iterator& it, const Function& f)
      : m_it(it)
      , m_fun(f)
    {}
    template <typename C, typename V, typename I, typename F>
    wrapped_iterator_by_category(
        const wrapped_iterator_by_category<C, V, I, F>& that)
      : m_it(that.get_iterator())
      , m_fun(that.get_function())
    {}
 
    const Iterator& get_iterator() const
    {
      return m_it;
    }
    const Function& get_function() const
    {
      return m_fun;
    }
 
    self_type& operator++()
    {
      ++m_it;
      return *this;
    }
 
    self_type operator++(int)
    {
      self_type tmp(*this);
      ++m_it;
      return tmp;
    }
 
    reference operator*() const
    {
      return m_fun(*m_it);
    }
    pointer operator->() const
    {
      return &m_fun(*m_it);
    }
 
    bool operator==(const self_type& that) const
    {
      return m_it == that.m_it;
    }
    bool operator!=(const self_type& that) const
    {
      return m_it != that.m_it;
    }
    bool operator==(const Iterator& it) const
    {
      return m_it == it;
    }
    bool operator!=(const Iterator& it) const
    {
      return m_it != it;
    }
 
  private:
    Iterator m_it;

    Function m_fun;
 
  }; // class wrapped_iterator_by_category [forward_iterator_tag]

  template <typename Value, typename Iterator, typename Function>
  class wrapped_iterator_by_category<std::bidirectional_iterator_tag, Value,
                                     Iterator, Function>
  {
  public:
    typedef typename std::iterator_traits<Iterator>::difference_type
        difference_type;
    typedef Value value_type;
    typedef value_type* pointer;
    typedef value_type& reference;
    typedef typename std::iterator_traits<Iterator>::iterator_category
        iterator_category;
 
    typedef wrapped_iterator_by_category<std::bidirectional_iterator_tag,
                                         Value, Iterator, Function>
        self_type;
 
  public:
    wrapped_iterator_by_category()
    {}
    wrapped_iterator_by_category(const Iterator& it)
      : m_it(it)
    {}
    wrapped_iterator_by_category(const Iterator& it, const Function& f)
      : m_it(it)
      , m_fun(f)
    {}
    template <typename C, typename V, typename I, typename F>
    wrapped_iterator_by_category(
        const wrapped_iterator_by_category<C, V, I, F>& that)
      : m_it(that.get_iterator())
      , m_fun(that.get_function())
    {}
 
    const Iterator& get_iterator() const
    {
      return m_it;
    }
    const Function& get_function() const
    {
      return m_fun;
    }
 
    self_type& operator++()
    {
      ++m_it;
      return *this;
    }
 
    self_type operator++(int)
    {
      self_type tmp(*this);
      ++m_it;
      return tmp;
    }
 
    self_type& operator--()
    {
      --m_it;
      return *this;
    }
 
    self_type operator--(int)
    {
      self_type tmp(*this);
      --m_it;
      return tmp;
    }
 
    reference operator*() const
    {
      return m_fun(*m_it);
    }
    pointer operator->() const
    {
      return &m_fun(*m_it);
    }
 
    bool operator==(const self_type& that) const
    {
      return m_it == that.m_it;
    }
    bool operator!=(const self_type& that) const
    {
      return m_it != that.m_it;
    }
    bool operator==(const Iterator& it) const
    {
      return m_it == it;
    }
    bool operator!=(const Iterator& it) const
    {
      return m_it != it;
    }
 
  private:
    Iterator m_it;

    Function m_fun;
 
  }; // class wrapped_iterator_by_category [bidirectional_iterator_tag]

  template <typename Value, typename Iterator, typename Function>
  class wrapped_iterator_by_category<std::random_access_iterator_tag, Value,
                                     Iterator, Function>
  {
  public:
    typedef typename std::iterator_traits<Iterator>::difference_type
        difference_type;
    typedef Value value_type;
    typedef value_type* pointer;
    typedef value_type& reference;
    typedef typename std::iterator_traits<Iterator>::iterator_category
        iterator_category;
 
    typedef wrapped_iterator_by_category<std::random_access_iterator_tag,
                                         Value, Iterator, Function>
        self_type;
 
  public:
    wrapped_iterator_by_category()
    {}
    wrapped_iterator_by_category(const Iterator& it)
      : m_it(it)
    {}
    wrapped_iterator_by_category(const Iterator& it, const Function& f)
      : m_it(it)
      , m_fun(f)
    {}
    template <typename V, typename I>
    wrapped_iterator_by_category(
        const wrapped_iterator_by_category<std::random_access_iterator_tag, V,
                                           I, Function>& that)
      : m_it(that.m_it)
      , m_fun(that.m_fun)
    {}
    template <typename C, typename V, typename I, typename F>
    wrapped_iterator_by_category(
        const wrapped_iterator_by_category<C, V, I, F>& that)
      : m_it(that.get_iterator())
      , m_fun(that.get_function())
    {}
 
    const Iterator& get_iterator() const
    {
      return m_it;
    }
    const Function& get_function() const
    {
      return m_fun;
    }
 
    self_type& operator++()
    {
      ++m_it;
      return *this;
    }
 
    self_type operator++(int)
    {
      self_type tmp(*this);
      ++m_it;
      return tmp;
    }
 
    self_type& operator--()
    {
      --m_it;
      return *this;
    }
 
    self_type operator--(int)
    {
      self_type tmp(*this);
      --m_it;
      return tmp;
    }
 
    reference operator*() const
    {
      return m_fun(*m_it);
    }
    pointer operator->() const
    {
      return &m_fun(*m_it);
    }
 
    bool operator==(const self_type& that) const
    {
      return m_it == that.m_it;
    }
    bool operator!=(const self_type& that) const
    {
      return m_it != that.m_it;
    }
    bool operator==(const Iterator& it) const
    {
      return m_it == it;
    }
    bool operator!=(const Iterator& it) const
    {
      return m_it != it;
    }
    bool operator<(const self_type& that) const
    {
      return m_it < that.m_it;
    }
    bool operator<=(const self_type& that) const
    {
      return m_it <= that.m_it;
    }
    bool operator>(const self_type& that) const
    {
      return m_it > that.m_it;
    }
    bool operator>=(const self_type& that) const
    {
      return m_it >= that.m_it;
    }
 
    difference_type operator-(const self_type& that) const
    {
      return m_it - that.m_it;
    }
 
    self_type& operator+=(int n)
    {
      m_it += n;
      return *this;
    }
 
    self_type operator+(int n) const
    {
      self_type result(*this);
      result += n;
      return result;
    }
 
    self_type& operator-=(int n)
    {
      return *this += -n;
    }
 
    self_type operator-(int n) const
    {
      self_type result(*this);
      result -= n;
      return result;
    }
 
    reference operator[](int n)
    {
      return m_fun(m_it[n]);
    }
 
  private:
    Iterator m_it;

    Function m_fun;
 
  }; // class wrapped_iterator_by_category [random_access_iterator_tag]
 
  template <typename Value, typename Iterator, typename Function>
  wrapped_iterator_by_category<std::random_access_iterator_tag, Value,
                               Iterator, Function>
  operator+(int n,
            const wrapped_iterator_by_category<std::random_access_iterator_tag,
                                               Value, Iterator, Function>& it)
  {
    return it + n;
  }
 
  template <typename Value, typename Iterator, typename Function>
  wrapped_iterator_by_category<std::random_access_iterator_tag, Value,
                               Iterator, Function>
  operator-(int n,
            const wrapped_iterator_by_category<std::random_access_iterator_tag,
                                               Value, Iterator, Function>& it)
  {
    return it - n;
  }

  template <typename Value, typename Iterator, typename Function>
  class wrapped_iterator
  {
  public:
    typedef wrapped_iterator_by_category<
        typename std::iterator_traits<Iterator>::iterator_category, Value,
        Iterator, Function>
        iterator_type;
 
  }; // class wrapped_iterator
}
 
#endif // __CLAW_ITERATOR_HPP__