source: trunk/yat/utility/IteratorWeighted.h @ 916

#ifndef _theplu_yat_utility_iterator_weighted_
#define _theplu_yat_utility_iterator_weighted_

// $Id: IteratorWeighted.h 916 2007-09-30 00:50:10Z peter $

#include "yat_assert.h"

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

namespace theplu {
namespace yat {
namespace utility {

  /**
     @brief IteratorWeighted
  */
  template<typename return_type, typename Container>
  class IteratorWeighted
  {
  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
    */
    IteratorWeighted(void) {};

    /**
       \brief Constructor

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

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

    /**
       \return data
    */
    return_type data(void) const 
    { yat_assert(index_<container_->size()); return container_->data(index_); }

    /**
       \return weight
    */
    return_type weight(void) const 
    { yat_assert(index_<container_->size());return container_->weight(index_); }


    /**
       \brief pre-increment

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

    /**
       \brief post-increment

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

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

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

    /**
       \brief post-decrement

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

    /**
       \brief pre-decrement

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

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

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

    /**
       \brief addition operator

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

    /**
       \brief subtraction operator

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

    /**
       \brief difference operator

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

    
    /**
       \brief Conversion operator

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

    /**
       \brief Equality operator

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

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

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

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

#endif