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

#ifndef _theplu_yat_utility_iterator_
#define _theplu_yat_utility_iterator_

// $Id: Iterator.h 966 2007-10-11 17:01:01Z 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 "yat_assert.h"

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

namespace theplu {
namespace yat {
namespace utility {

  /**
     @brief Iterator
  */
  template<typename return_type, 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 Default Constructor
    */
    Iterator(void) {};

    /**
       \brief Constructor

       \param container iterator points to
       \param index telling which element iterator points to
    */
    Iterator(Container& container, difference_type index)
      : container_(&container), index_(index) {}

    /**
       \return element
     */
    return_type operator*(void) const 
    { yat_assert<std::out_of_range>(index_<container_->size());
      return container_->operator()(index_); }

    /**
       \return element \a n steps forward
     */
    return_type operator[](difference_type n) const 
    { yat_assert<std::out_of_range>(index_+n < container_->size());
      return container_->operator()(index_+n); }

    /**
       \brief pre-increment

       \return reference to *this
     */
    Iterator& operator++(void) { ++index_; return *this; }

    /**
       \brief post-increment

       \return copy of iterator prior increment
     */
    Iterator operator++(int) 
    { Iterator<return_type, Container> tmp(*this); ++index_; return tmp;}

    /**
       \brief iterate \f$ n \f$ steps forward

       \return reference to resulting iterator
     */
    Iterator& operator+=(int n) { index_+=n; return *this; }

    /**
       \brief post-decrement

       \return copy of iterator prior decrement
     */
    Iterator operator--(int) 
    { Iterator<return_type, Container> tmp(*this); --index_; return tmp;}

    /**
       \brief pre-decrement

       \return reference to resulting iterator
     */
    Iterator& operator--(void) { --index_; return *this; }

    /**
       \brief iterate \f$ n \f$ steps backwards

       \return reference to resulting iterator
     */
    Iterator& operator-=(int n) { index_-=n; return *this; }

    /**
       \brief addition operator

       \return copy of resulting iterator
     */
    friend Iterator operator+(const Iterator& lhs, size_t n) 
    { return Iterator<return_type, Container>(*lhs.container_, lhs.index_+n); }

    /**
       \brief subtraction operator

       \return copy of resulting iterator
     */
    friend Iterator operator-(const Iterator& lhs, size_t n) 
    { return Iterator<return_type, Container>(*lhs.container_, lhs.index_-n); }

    /**
       \brief difference operator

       \return distance between \a lhs and \a rhs
     */
    friend difference_type operator-(const Iterator& lhs, const Iterator& rhs) 
    { return lhs.index_-rhs.index_; }

    
    /**
       \brief Conversion operator

       This operator allows automatic conversion from iterator to
       const_iterator
     */
    operator Iterator<const double, const Container> () 
    { return Iterator<const double, const Container>(*container_, index_); } 

    /**
       \brief Equality operator

       \return True if \a lhs and \a rhs are pointing to same element
     */
    friend bool operator==(const Iterator<return_type, Container>& lhs, 
                           const Iterator<return_type, Container>& rhs)
    { return lhs.container_==rhs.container_ && lhs.index_==rhs.index_; }
    
    /**
       \brief Non-equality operator

       \return False if \a lhs and \a rhs are pointing to same element
     */
    friend bool operator!=(const Iterator<return_type, Container>& lhs, 
                           const Iterator<return_type, Container>& rhs)
    { return !(lhs.container_==rhs.container_ && lhs.index_==rhs.index_); }
    
    /**
       \brief Less operator
     */
    friend bool operator<(const Iterator<return_type, Container>& lhs, 
                           const Iterator<return_type, Container>& rhs)
    { return lhs.index_<rhs.index_; }
    
    /**
       \brief Less equal operator
     */
    friend bool operator<=(const Iterator<return_type, Container>& lhs, 
                           const Iterator<return_type, Container>& rhs)
    { return lhs.index_<=rhs.index_; }
    
    /**
       \brief Larger operator
     */
    friend bool operator>(const Iterator<return_type, Container>& lhs, 
                           const Iterator<return_type, Container>& rhs)
    { return lhs.index_>rhs.index_; }
    
    /**
       \brief Larger equal operator
     */
    friend bool operator>=(const Iterator<return_type, Container>& lhs, 
                           const Iterator<return_type, Container>& rhs)
    { return lhs.index_>=rhs.index_; }
    
  private:
    Container* container_;
    size_t index_;

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

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

#endif