---

more/gen/iterator.h

Go to the documentation of this file.

//  Copyright (C) 1999--2002  Petter Urkedal

//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.

//  This file 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 General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.

//  $Id: iterator.h,v 1.2 2002/08/24 13:58:16 petter_urkedal Exp $


#ifndef MORE_GEN_ITERATOR_H
#define MORE_GEN_ITERATOR_H

#include <more/bits/config.h>
#include <iosfwd>
#include <iterator>


namespace more {
namespace gen {

  /** \class trivial_iterator_tag iterator.h more/gen/iterator.h
   **
   ** Iterator category tag for the trivial iterator concept as
   ** defined in the standard. However, we can't inject it as the base
   ** class of other iterator tags, so care must be taken when writing
   ** algorithms. */
  struct trivial_iterator_tag {};

  /** \class transforming_iterator iterator.h more/gen/iterator.h
   **
   ** An iterator which iterate over a transformed range. */
  template<typename Iterator, typename Function>
    struct transforming_iterator
    {
        typedef typename std::iterator_traits<Iterator>::iterator_category
                iterator_category;
        typedef typename Function::result_type value_type;
        typedef typename std::iterator_traits<Iterator>::difference_type
                difference_type;
        typedef value_type& reference;
        typedef value_type* pointer;

        transforming_iterator() {}
        transforming_iterator(transforming_iterator const& x) : it(x.it) {}
        explicit transforming_iterator(Iterator const& it0) : it(it0) {}

        transforming_iterator& operator=(transforming_iterator const& rhs)
            { it = rhs.it; return *this; }
        bool operator==(transforming_iterator const& rhs) const
            { return it==rhs.it; }
        bool operator!=(transforming_iterator const& rhs) const
            { return !operator==(rhs); }
        bool operator<(transforming_iterator const& rhs) const
            { return it<rhs.it; }

        transforming_iterator& operator++() { ++it; return *this; }
        transforming_iterator operator++(int)
            { transforming_iterator tmp = *this; ++it; return tmp; }
        transforming_iterator& operator--() { --it; return *this; }
        transforming_iterator& operator--(int)
            { transforming_iterator tmp = *this; --it; return tmp; }

        transforming_iterator& operator+=(int i) { it += i; return *this; }
        transforming_iterator& operator-=(int i) { it -= i; return *this; }
        int operator-(transforming_iterator const& v) const
            { return it - v.it; }

        value_type& operator*() const { return f(*it); }
        value_type& operator[](int i) const { return f(it[i]); }
        value_type* operator->() const { return &f(*it); }
        Iterator sub_iterator() { return it; }

      private:
        Iterator it;
        Function f;
    };

  template<typename T, typename U> inline transforming_iterator<T, U>
    operator+(transforming_iterator<T, U> u, int i)
    {
        u += i;
        return u;
    }

  template<typename T, typename U> inline transforming_iterator<T, U>
    operator+(int i, transforming_iterator<T, U> u)
    {
        u += i;
        return u;
    }

  template<typename T, typename U> inline transforming_iterator<T, U>
    operator-(transforming_iterator<T, U> u, int i)
    {
        u -= i;
        return u;
    }


  // --- misc ---

  /** \class null_output_iteraton iterator.h more/gen/iterator.h
   **
   ** An output iterator which discards its output. */
  class null_output_iterator
  {
      typedef std::ptrdiff_t difference_type;
      typedef void value_type;
      typedef void reference;
      typedef void pointer;
      typedef std::output_iterator_tag iterator_category;

      struct proxy
      {
          template<typename T> proxy operator=(const T&x) { return *this; }
      };

    public:
      proxy operator*() { return proxy(); }
      null_output_iterator operator++() { return *this; }
      null_output_iterator operator++(int) { return *this; }
  };

  /** \class assign_iterator iterator.h more/gen/iterator.h
   ** 
   ** An output iterator which repeatedly assigns to the same location. */
  template<typename T>
    struct assign_iterator
    {
        typedef std::ptrdiff_t difference_type;
        typedef void value_type;
        typedef void reference;
        typedef void pointer;
        typedef std::output_iterator_tag iterator_category;
        explicit assign_iterator(T& ref_) : ref(&ref_) {}
        T& operator*() { return *ref; }
        assign_iterator& operator++() { return *this; }
        assign_iterator& operator++(int) { return *this; }
      private:
        T* ref;
    };

  template<typename T>
    assign_iterator<T>
    assigner(T& x)
    {
        return assign_iterator<T>(x);
    }


  /** \class ostream_iterator iterator.h more/gen/iterator.h
   **
   ** This is an alternative to \c std::ostream_iterator. This
   ** iterator places the string argument between value rather than
   ** after. The rationale is that this is a common case, and a
   ** separator at the end can easily be inserted added, but redundant
   ** separator can not be removed from the stream. This class also
   ** extends std::ostream_iterator by allowing the width and
   ** precision to be specified.  */
  template< typename Value,
            typename Char = char, typename Traits = std::char_traits<Char> >
    struct ostream_iterator
    {
        typedef std::ptrdiff_t difference_type;
        typedef void value_type;
        typedef void reference;
        typedef void pointer;
        typedef std::output_iterator_tag iterator_category;
        typedef Char char_type;
        typedef Traits traits_type;
        typedef std::basic_ostream<Char, Traits> ostream_type;

        /** Construct an iterator which prints values separated with
         ** \a sep to \a os.  Before each value, set \a width and \a
         ** precision on \a os if given. */
        ostream_iterator(ostream_type& os, char const* sep = "",
                         int width = 0, int precision = 0)
            : m_os(&os), m_sep(sep),
              m_width(width), m_precision(precision),
              m_is_first(true) {}

        ostream_iterator&
        operator=(Value const& value)
        {
            if (m_is_first)
                m_is_first = false;
            else
                *m_os << m_sep;
            if (m_width > 0)
                m_os->width(m_width);
            if (m_precision > 0)
                m_os->precision(m_precision);
            *m_os << value;
            return *this;
        }

        ostream_iterator& operator*() { return *this; }
        ostream_iterator& operator++() { return *this; }
        ostream_iterator& operator++(int) { return *this; }

      private:
        ostream_type* m_os;
        char const* m_sep;
        int m_width, m_precision;
        bool m_is_first;
    };

}} // more::gen

#endif

---