reorder_iterator.hpp

Go to the documentation of this file.

// (C) Copyright Toon Knapen    2001.
// (C) Copyright David Abrahams 2003.
// (C) Copyright Roland Richter 2003.
// (C) Copyright Renaud Detry   2007-2011.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
 
// This file is a fork of boost/iterator/permutation_iterator.hpp
 
#ifndef TRSL_REORDER_ITERATOR_HPP
#define TRSL_REORDER_ITERATOR_HPP
 
#include <trsl/error_handling.hpp>
#include <trsl/common.hpp>
 
#include <iterator>
#include <vector>
#include <algorithm>
#include <boost/iterator.hpp>
#include <boost/detail/iterator.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/shared_ptr.hpp>
 
namespace trsl
{
  template<class ElementIterator>
  class reorder_iterator;
  
  namespace detail
  {
    template<class ElementIterator>
    struct reorder_iterator_base
    {
      typedef ElementIterator element_iterator;
      typedef size_t index_t;
      typedef std::vector<index_t> index_container;
      typedef boost::shared_ptr<index_container> index_container_ptr;
      typedef typename index_container::const_iterator index_iterator;
    
      typedef boost::iterator_adaptor< 
        reorder_iterator<ElementIterator>,
        index_iterator,
        typename boost::detail::iterator_traits<ElementIterator>::value_type,
        boost::use_default,
        typename boost::detail::iterator_traits<ElementIterator>::reference
      > type;
    };
  }
  
  
  template<class ElementIterator>
  class reorder_iterator
    : public detail::reorder_iterator_base<ElementIterator>::type
  {
    typedef detail::reorder_iterator_base<ElementIterator> base_t;
    typedef typename base_t::type super_t;
 
    friend class boost::iterator_core_access;
    
  public:
 
    typedef typename base_t::index_t index_t;
    typedef typename base_t::index_container index_container;
    typedef typename base_t::index_container_ptr index_container_ptr;
    typedef typename base_t::index_iterator index_iterator;
 
    
    typedef typename base_t::element_iterator element_iterator;
 
    reorder_iterator() :
      m_elt_iter(),
      m_index_collection(new index_container)
      {}
      
    explicit reorder_iterator(ElementIterator first,
                              const index_container_ptr& index_collection)
      : super_t(index_collection->begin()),
        m_elt_iter(first),
        m_index_collection(index_collection)
      {}
    
    template<class OtherElementIterator>
    reorder_iterator
    (reorder_iterator<OtherElementIterator> const& r,
     typename boost::enable_if_convertible<OtherElementIterator, ElementIterator>::type* = 0) :
      super_t(r.base()), m_elt_iter(r.m_elt_iter),
      m_index_collection(r.m_index_collection)
      {}
 
    reorder_iterator<ElementIterator> begin() const
      {
        reorder_iterator<ElementIterator> indexIterator(*this);
        indexIterator.base_reference() =
          indexIterator.m_index_collection->begin();
        return indexIterator;
      }
    
    reorder_iterator<ElementIterator> end() const
      {
        reorder_iterator<ElementIterator> indexIterator(*this);
        indexIterator.base_reference() =
          indexIterator.m_index_collection->end();
        return indexIterator;
      }
    
    index_t index() const
      {
        return *this->base();
      }
      
  private:
      
    typename super_t::reference dereference() const
      { return *(m_elt_iter + *this->base()); }
    
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
    template <class> friend class reorder_iterator;
#else
  public:
#endif 
    ElementIterator m_elt_iter;
  protected:
    index_container_ptr m_index_collection;
  };
  
} // namespace trsl
 
#endif // include guard