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

#ifndef _theplu_yat_utility_const_iterator_
#define _theplu_yat_utility_const_iterator_

// $Id: constIterator.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.h"

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

namespace theplu {
namespace yat {
namespace utility {

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

    /**
       @brief Constructor 
    */
    constIterator(void) {};
    constIterator(Container& container, difference_type index)
      : container_(&container), index_(index) {}
    // allow const conversion
    constIterator(const Iterator<Container>& iter)
      : container_(&iter.container_), index_(&(iter.index_)) {}

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

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

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

  private:
    Container* container_;
    size_t index_;

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

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

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


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


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


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


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


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

#endif