source: trunk/yat/utility/Container2DIterator.h @ 1562

#ifndef _theplu_yat_utility_container2d_iterator_
#define _theplu_yat_utility_container2d_iterator_

// $Id: Container2DIterator.h 1562 2008-10-10 17:10:21Z peter $

/*
  Copyright (C) 2007 Jari Häkkinen, Peter Johansson
  Copyright (C) 2008 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/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 3 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "IteratorPolicy.h"
#include "yat_assert.h"

#include <boost/iterator/iterator_facade.hpp>

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

namespace theplu {
namespace yat {
namespace utility {

  /**
     @brief Iterator
  */
  template<typename Container, typename value, 
           typename pointer = value*, typename reference = value&,
           class Policy = IteratorPolicy<Container, reference, value> > 
  class Container2DIterator
    : public boost::iterator_facade<
    Container2DIterator<Container, value, pointer, reference, Policy>
    , value
    , std::random_access_iterator_tag
    , reference>
  {
  public:
    /**
       Tells whether iterator is weighted or not.

       \see weighted_iterator_tag and unweighted_iterator_tag
     */
    typedef typename Policy::weighted_iterator_type weighted_iterator_type;

  private:
    typedef Container2DIterator<Container, value, pointer,reference,Policy> self;

  public:
    /**
       \brief Default Constructor
    */
    Container2DIterator(void) {};

    /**
       \brief Constructor

       \param container iterator points to
       \param row telling which row iterator points to
       \param column telling which column iterator points to
    */
    Container2DIterator(Container& container, size_t row, size_t column)
      : container_(&container), index_(row*container.columns()+column) {}

    /**
       \return data
    */
    typename Policy::data_type data(void) const 
    { yat_assert<std::out_of_range>(index_<this->size(), 
                                    "Container2DIterator::data"); 
      return ip_.data(*container_, row(index_), column(index_)); 
    }

    /**
       \return weight
    */
    typename Policy::weight_type weight(void) const 
    { yat_assert<std::out_of_range>(index_<this->size(), 
                                    "Container2DIterator::weight"); 
      return ip_.weight(*container_, row(index_), column(index_)); 
    }

  private:
    friend class boost::iterator_core_access;

    Container* container_;
    size_t index_;
    Policy ip_;

    void advance(int n) { index_+=n; }

    void decrement(void) { --index_; }

    int distance_to(const Container2DIterator& other) const
    { return other.index_ - index_; }

    reference dereference(void) const 
    { 
      yat_assert<std::out_of_range>(index_ < this->size(), 
                                    "Container2DIterator::dereference");
      return container_->operator()(row(index_), column(index_));
    }

    bool equal(const Container2DIterator& other) const
    { return index_ == other.index_; }

    void increment(void) { ++index_; }

    size_t column(size_t i) const 
    { return i % container_->columns(); }
    size_t row(size_t i) const 
    { return static_cast<size_t>(i/container_->columns()); }
    size_t size() const 
    { return container_->columns()*container_->rows(); }


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

  /**
     Specialization for Container2DIterator
   */
  template<typename A, typename B, typename C, typename D, typename E> 
  struct iterator_traits<Container2DIterator<A, B, C, D, E> > {
    /**
       data_reference is defined by Policy class E::data_type
     */
    typedef typename E::data_type data_reference;

    /**
       weight_reference is defined by Policy class E::weight_type
     */
    typedef typename E::weight_type weight_reference;

    /**
       \return data
    */
    data_reference data(Container2DIterator<A, B, C, D, E> iter) const 
    { return iter.data(); }

    /**
       \return weight
    */
    weight_reference weight(Container2DIterator<A, B, C, D, E> iter) const 
    { return iter.weight(); }

  };


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

#endif