Container2DIterator.h

#ifndef _theplu_yat_utility_container2d_iterator_
#define _theplu_yat_utility_container2d_iterator_

// $Id: Container2DIterator.h 4207 2022-08-26 04:36:28Z peter $

/*
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2010, 2015, 2022 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 "concept_check.h"
#include "iterator_traits.h"
#include "yat_assert.h"

#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/iterator_facade.hpp>

#include <cstddef>
#include <iterator>
#include <stdexcept>
#include <utility>

namespace theplu {
namespace yat {
namespace utility {

  template<typename Container, typename value, typename reference = value&>
  class Container2DIterator
    : public boost::iterator_facade<
    Container2DIterator<Container, value, reference>
    , value
    , boost::random_access_traversal_tag
    , reference>
  {
  private:
    typedef Container2DIterator<Container, value, reference> self;

  public:
    Container2DIterator(void)
    {
      BOOST_CONCEPT_ASSERT((Container2D<Container>));
    };

    Container2DIterator(Container& container, size_t row, size_t column)
      : container_(&container), index_(row*container.columns()+column)
    {
      BOOST_CONCEPT_ASSERT((Container2D<Container>));
    }


    template<typename C2, typename V2, typename R2>
    Container2DIterator(Container2DIterator<C2,V2,R2> other,
          typename boost::enable_if_convertible<C2*, Container*>::type* = 0,
          typename boost::enable_if_convertible<R2, reference>::type* = 0)
      : container_(&other.container()),
        index_(other.row() * other.container().columns()+other.column())
    {}


    Container& container(void) const { return *container_; }

    size_t row(void) const { return row(index_); }

    size_t column(void) const { return column(index_); }

  private:
    friend class boost::iterator_core_access;

    Container* container_;
    size_t index_;

    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(), column());
    }

    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&);
  };

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

#endif