/* Copyright 2003-2005 Joaquín M López Muñoz.

 * 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)

 *

 * See http://www.boost.org/libs/multi_index for library home page.

 */

#ifndef BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP

#define BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP

#if defined(_MSC_VER)&&(_MSC_VER>=1200)

#pragma once

#endif

#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */

#include <boost/mpl/apply.hpp>

#include <boost/multi_index/detail/prevent_eti.hpp>

#include <boost/operators.hpp>

namespace boost{

namespace multi_index{

namespace detail{

/* Poor man's version of boost::iterator_adaptor. Used instead of the

 * original as compile times for the latter are significantly higher.

 * The interface is not replicated exactly, only to the extent necessary

 * for internal consumption.

 */

class iter_adaptor_access

{

public:

  template<class Class>

    static typename Class::reference dereference(const Class& x)

  {

    return x.dereference();

  }

  template<class Class>

  static bool equal(const Class& x,const Class& y)

  {

    return x.equal(y);

  }

  template<class Class>

  static void increment(Class& x)

  {

    x.increment();

  }

  template<class Class>

  static void decrement(Class& x)

  {

    x.decrement();

  }

  template<class Class>

  static void advance(Class& x,typename Class::difference_type n)

  {

    x.advance(n);

  }

  template<class Class>

  static typename Class::difference_type distance_to(

    const Class& x,const Class& y)

  {

    return x.distance_to(y);

  }

};

template<typename Category>

struct iter_adaptor_selector;

template<class Derived,class Base>

class forward_iter_adaptor_base:

  public forward_iterator_helper<

    Derived,

    typename Base::value_type,

    typename Base::difference_type,

    typename Base::pointer,

    typename Base::reference>

{

public:

  typedef typename Base::reference reference;

  reference operator*()const

  {

    return iter_adaptor_access::dereference(final());

  }

  friend bool operator==(const Derived& x,const Derived& y)

  {

    return iter_adaptor_access::equal(x,y);

  }

  Derived& operator++()

  {

    iter_adaptor_access::increment(final());

    return final();

  }

private:

  Derived& final(){return *static_cast<Derived*>(this);}

  const Derived& final()const{return *static_cast<const Derived*>(this);}

};

template<>

struct iter_adaptor_selector<std::forward_iterator_tag>

{

  template<class Derived,class Base>

  struct apply

  {

    typedef forward_iter_adaptor_base<Derived,Base> type;

  };

};

template<class Derived,class Base>

class bidirectional_iter_adaptor_base:

  public bidirectional_iterator_helper<

    Derived,

    typename Base::value_type,

    typename Base::difference_type,

    typename Base::pointer,

    typename Base::reference>

{

public:

  typedef typename Base::reference reference;

  reference operator*()const

  {

    return iter_adaptor_access::dereference(final());

  }

  friend bool operator==(const Derived& x,const Derived& y)

  {

    return iter_adaptor_access::equal(x,y);

  }

  Derived& operator++()

  {

    iter_adaptor_access::increment(final());

    return final();

  }

  Derived& operator--()

  {

    iter_adaptor_access::decrement(final());

    return final();

  }

private:

  Derived& final(){return *static_cast<Derived*>(this);}

  const Derived& final()const{return *static_cast<const Derived*>(this);}

};

template<>

struct iter_adaptor_selector<std::bidirectional_iterator_tag>

{

  template<class Derived,class Base>

  struct apply

  {

    typedef bidirectional_iter_adaptor_base<Derived,Base> type;

  };

};

template<class Derived,class Base>

class random_access_iter_adaptor_base:

  public random_access_iterator_helper<

    Derived,

    typename Base::value_type,

    typename Base::difference_type,

    typename Base::pointer,

    typename Base::reference>

{

public:

  typedef typename Base::reference       reference;

  typedef typename Base::difference_type difference_type;

  reference operator*()const

  {

    return iter_adaptor_access::dereference(final());

  }

  friend bool operator==(const Derived& x,const Derived& y)

  {

    return iter_adaptor_access::equal(x,y);

  }

  friend bool operator<(const Derived& x,const Derived& y)

  {

    return iter_adaptor_access::distance_to(x,y)>0;

  }

  Derived& operator++()

  {

    iter_adaptor_access::increment(final());

    return final();

  }

  Derived& operator--()

  {

    iter_adaptor_access::decrement(final());

    return final();

  }

  Derived& operator+=(difference_type n)

  {

    iter_adaptor_access::advance(final(),n);

    return final();

  }

  Derived& operator-=(difference_type n)

  {

    iter_adaptor_access::advance(final(),-n);

    return final();

  }

  friend difference_type operator-(const Derived& x,const Derived& y)

  {

    return iter_adaptor_access::distance_to(y,x);

  }

private:

  Derived& final(){return *static_cast<Derived*>(this);}

  const Derived& final()const{return *static_cast<const Derived*>(this);}

};

template<>

struct iter_adaptor_selector<std::random_access_iterator_tag>

{

  template<class Derived,class Base>

  struct apply

  {

    typedef random_access_iter_adaptor_base<Derived,Base> type;

  };

};

template<class Derived,class Base>

struct iter_adaptor_base

{

  typedef iter_adaptor_selector<

    typename Base::iterator_category>        selector;

  typedef typename prevent_eti<

    selector,

    typename mpl::apply2<

      selector,Derived,Base>::type

  >::type                                    type;

};

template<class Derived,class Base>

class iter_adaptor:public iter_adaptor_base<Derived,Base>::type

{

protected:

  iter_adaptor(){}

  explicit iter_adaptor(const Base& b_):b(b_){}

  const Base& base_reference()const{return b;}

  Base&       base_reference(){return b;}

private:

  Base b;

};

} /* namespace multi_index::detail */

} /* namespace multi_index */

} /* namespace boost */

#endif