range_iterator.h

Go to the documentation of this file.

/*
 * This file is a part of TiledArray.
 * Copyright (C) 2013  Virginia Tech
 *
 *  This program 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.
 *
 *  This program 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, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef TILEDARRAY_RANGE_ITERATOR_H__INCLUDED
#define TILEDARRAY_RANGE_ITERATOR_H__INCLUDED

#include <TiledArray/error.h>
#include <iterator>
#include <vector>

namespace TiledArray {
  namespace detail {

    template <typename, typename>
    class RangeIterator;

  } // namespace detail
} // namespace TiledArray

namespace std {
  template <typename T, typename Container>
  void advance(TiledArray::detail::RangeIterator<T, Container>&,
      typename TiledArray::detail::RangeIterator<T, Container>::difference_type );

  template <typename T, typename Container>
  typename TiledArray::detail::RangeIterator<T, Container>::difference_type
  distance(const TiledArray::detail::RangeIterator<T, Container>&,
      const TiledArray::detail::RangeIterator<T, Container>&);

} // namespace std

namespace TiledArray {
  namespace detail {


    template <typename T, typename Container>
    class RangeIterator {
    public:
      typedef RangeIterator<T,Container> RangeIterator_; 

      // Standard iterator typedefs
      typedef std::vector<T> value_type; 
      typedef const value_type& reference; 
      typedef const value_type* pointer; 
      typedef std::input_iterator_tag iterator_category; 
      typedef std::ptrdiff_t difference_type; 


      RangeIterator(const RangeIterator_& other) :
        container_(other.container_), current_(other.current_) {
      }


      RangeIterator(const T* v, const Container* c) :
          container_(c), current_(v, v + c->rank())
      { }


      RangeIterator_& operator=(const RangeIterator_& other) {
        current_ = other.current_;
        container_ = other.container_;

        return *this;
      }

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


      reference operator*() const { return current_; }


      RangeIterator_& operator++() {
        container_->increment(current_);
        return *this;
      }


      RangeIterator_ operator++(int) {
        RangeIterator_ temp(*this);
        container_->increment(current_);
        return temp;
      }


      pointer operator->() const { return & current_; }


      void advance(difference_type n) {
        container_->advance(current_, n);
      }

      difference_type distance_to(const RangeIterator_& other) const {
        TA_ASSERT(container_ == other.container_);
        return container_->distance_to(current_, other.current_);
      }

    private:

      const Container* container_;  
      std::vector<T> current_;      
    }; // class RangeIterator


    template <typename T, typename Container>
    bool operator==(const RangeIterator<T, Container>& left_it,
        const RangeIterator<T, Container>& right_it)
    {
      return ((*left_it) == (*right_it)) &&
          (left_it.container() == right_it.container());
    }


    template <typename T, typename Container>
    bool operator!=(const RangeIterator<T, Container>& left_it,
        const RangeIterator<T, Container>& right_it)
    {
      return ((*left_it) != (*right_it)) ||
          (left_it.container() != right_it.container());
    }

  } // namespace detail
} // namespace TiledArray

namespace std {
  template <typename T, typename Container>
  void advance(TiledArray::detail::RangeIterator<T, Container>& it,
      typename TiledArray::detail::RangeIterator<T, Container>::difference_type n)
  {
    it.advance(n);
  }

  template <typename T, typename Container>
  typename TiledArray::detail::RangeIterator<T, Container>::difference_type
  distance(const TiledArray::detail::RangeIterator<T, Container>& first,
      const TiledArray::detail::RangeIterator<T, Container>& last)
  {
    return first.distance_to(last);
  }

} // namespace std

#endif // TILEDARRAY_RANGE_ITERATOR_H__INCLUDED