source: trunk/yat/utility/Iterator.h @ 880

#ifndef _theplu_yat_utility_iterator_
#define _theplu_yat_utility_iterator_

// $Id: Iterator.h 880 2007-09-21 23:43:22Z peter $

/*
  Copyright (C) 2007 Peter Johansson

  This file is part of the yat library, http://trac.thep.lu.se/trac/yat

  The yat library 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.

  The yat 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
  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.
*/

#include <iterator>
#include <stddef.h>

namespace theplu {
namespace yat {
namespace utility {

  /**
     @brief Iterator
  */
  template<typename Container>
  class Iterator
  {
  public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef double value_type;
    typedef size_t difference_type;
    typedef double* pointer;
    typedef double& reference;

    /**
       @brief Constructor 
    */
    Iterator(void) {};
    Iterator(Container& container, difference_type index)
      : container_(&container), index_(index) {}

    reference operator*(void) const { return container_->operator()(index_); }
    const Iterator& operator++(void) { ++index_; return *this; }
    Iterator operator++(int) 
    { Iterator<Container> tmp(*this); ++index_; return tmp;}
    Iterator& operator+=(int n) { index_+=n; return *this; }
    Iterator operator+(int n) 
    { return Iterator<Container>(*container_, index_+n); }
    Iterator operator--(int) 
    { Iterator<Container> tmp(*this); --index_; return tmp;}
    Iterator operator--(void) { --index_; return *this; }
    Iterator& operator-=(int n) { index_-=n; return *this; }
    Iterator operator-(size_t n) 
    { return Iterator<Container>(*container_, index_-n); }
    size_t operator-(const Iterator& rhs) 
    { return index_-rhs.index_; }

    bool equal(const Iterator<Container>& other) const
    { return container_==other.container_ && index_==other.index_; }

    bool less(const Iterator<Container>& other) const
    { return index_<other.index_; }

  private:
    Container* container_;
    size_t index_;

    // Using compiler generated copy
    //Iterator(const Iterator&);
    //Iterator& operator=(const Iterator&);
  };

    template <typename T>
    inline bool operator==(const Iterator<T>& lhs, 
                           const Iterator<T>& rhs)
    {
      return lhs.equal(rhs);
    }

    template <typename T>
    inline bool operator!=(const Iterator<T>& lhs, 
                           const Iterator<T>& rhs)
    {
      return !(lhs==rhs);
    }


    template <typename T>
    inline bool operator<(const Iterator<T>& lhs, 
                          const Iterator<T>& rhs)
    {
      return lhs<rhs;
    }


    template <typename T>
    inline bool operator<=(const Iterator<T>& lhs, 
                           const Iterator<T>& rhs)
    {
      return !(rhs<lhs);
    }


    template <typename T>
    inline bool operator>(const Iterator<T>& lhs, 
                          const Iterator<T>& rhs)
    {
      return rhs<lhs;
    }


    template <typename T>
    inline bool operator>=(const Iterator<T>& lhs, 
                           const Iterator<T>& rhs)
    {
      return !(lhs<rhs);
    }


}}} // of namespace utility, yat, and theplu

#endif