// (C) Copyright David Abrahams 2002.

// (C) Copyright Jeremy Siek    2002.

// (C) Copyright Thomas Witt    2002.

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

#ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP

#define BOOST_ITERATOR_FACADE_23022003THW_HPP

#include <boost/iterator.hpp>

#include <boost/iterator/interoperable.hpp>

#include <boost/iterator/iterator_traits.hpp>

#include <boost/iterator/detail/facade_iterator_category.hpp>

#include <boost/iterator/detail/enable_if.hpp>

#include <boost/implicit_cast.hpp>

#include <boost/static_assert.hpp>

#include <boost/type_traits/is_same.hpp>

#include <boost/type_traits/add_const.hpp>

#include <boost/type_traits/add_pointer.hpp>

#include <boost/type_traits/remove_const.hpp>

#include <boost/type_traits/remove_reference.hpp>

#include <boost/type_traits/is_convertible.hpp>

#include <boost/type_traits/is_pod.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/if.hpp>

#include <boost/mpl/or.hpp>

#include <boost/mpl/and.hpp>

#include <boost/mpl/not.hpp>

#include <boost/mpl/always.hpp>

#include <boost/mpl/apply.hpp>

#include <boost/mpl/identity.hpp>

#include <boost/iterator/detail/config_def.hpp> // this goes last

namespace boost

{

  // This forward declaration is required for the friend declaration

  // in iterator_core_access

  template <class I, class V, class TC, class R, class D> class iterator_facade;

  namespace detail

  {

    // A binary metafunction class that always returns bool.  VC6

    // ICEs on mpl::always<bool>, probably because of the default

    // parameters.

    struct always_bool2

    {

        template <class T, class U>

        struct apply

        {

            typedef bool type;

        };

    };

    //

    // enable if for use in operator implementation.

    //

    template <

        class Facade1

      , class Facade2

      , class Return

    >

    struct enable_if_interoperable

#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

    {

        typedef typename mpl::if_<

            mpl::or_<

                is_convertible<Facade1, Facade2>

              , is_convertible<Facade2, Facade1>

            >

          , Return

          , int[3]

        >::type type;

    };        

#else

      : ::boost::iterators::enable_if<

           mpl::or_<

               is_convertible<Facade1, Facade2>

             , is_convertible<Facade2, Facade1>

           >

         , Return

        >

    {};

#endif 

    //

    // Generates associated types for an iterator_facade with the

    // given parameters.

    //

    template <

        class ValueParam

      , class CategoryOrTraversal

      , class Reference 

      , class Difference

    >

    struct iterator_facade_types

    {

        typedef typename facade_iterator_category<

            CategoryOrTraversal, ValueParam, Reference

        >::type iterator_category;

        typedef typename remove_const<ValueParam>::type value_type;

        typedef typename mpl::eval_if<

            detail::iterator_writability_disabled<ValueParam,Reference>

          , add_pointer<const value_type>

          , add_pointer<value_type>

        >::type pointer;

# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                          \

    && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452))              \

        || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310)))     \

    || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101))              \

    || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310)

        // To interoperate with some broken library/compiler

        // combinations, user-defined iterators must be derived from

        // std::iterator.  It is possible to implement a standard

        // library for broken compilers without this limitation.

#  define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1

        typedef

           iterator<iterator_category, value_type, Difference, pointer, Reference>

        base;

# endif

    };

    // iterators whose dereference operators reference the same value

    // for all iterators into the same sequence (like many input

    // iterators) need help with their postfix ++: the referenced

    // value must be read and stored away before the increment occurs

    // so that *a++ yields the originally referenced element and not

    // the next one.

    template <class Iterator>

    class postfix_increment_proxy

    {

        typedef typename iterator_value<Iterator>::type value_type;

     public:

        explicit postfix_increment_proxy(Iterator const& x)

          : stored_value(*x)

        {}

        // Returning a mutable reference allows nonsense like

        // (*r++).mutate(), but it imposes fewer assumptions about the

        // behavior of the value_type.  In particular, recall taht

        // (*r).mutate() is legal if operator* returns by value.

        value_type&

        operator*() const

        {

            return this->stored_value;

        }

     private:

        mutable value_type stored_value;

    };

    //

    // In general, we can't determine that such an iterator isn't

    // writable -- we also need to store a copy of the old iterator so

    // that it can be written into.

    template <class Iterator>

    class writable_postfix_increment_proxy

    {

        typedef typename iterator_value<Iterator>::type value_type;

     public:

        explicit writable_postfix_increment_proxy(Iterator const& x)

          : stored_value(*x)

          , stored_iterator(x)

        {}

        // Dereferencing must return a proxy so that both *r++ = o and

        // value_type(*r++) can work.  In this case, *r is the same as

        // *r++, and the conversion operator below is used to ensure

        // readability.

        writable_postfix_increment_proxy const&

        operator*() const

        {

            return *this;

        }

        // Provides readability of *r++

        operator value_type&() const

        {

            return stored_value;

        }

        // Provides writability of *r++

        template <class T>

        T const& operator=(T const& x) const

        {

            *this->stored_iterator = x;

            return x;

        }

        // This overload just in case only non-const objects are writable

        template <class T>

        T& operator=(T& x) const

        {

            *this->stored_iterator = x;

            return x;

        }

        // Provides X(r++)

        operator Iterator const&() const

        {

            return stored_iterator;

        }

     private:

        mutable value_type stored_value;

        Iterator stored_iterator;

    };

# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

    template <class Reference, class Value>

    struct is_non_proxy_reference_impl

    {

        static Reference r;

        template <class R>

        static typename mpl::if_<

            is_convertible<

                R const volatile*

              , Value const volatile*

            >

          , char[1]

          , char[2]

        >::type& helper(R const&);

        BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1);

    };

    template <class Reference, class Value>

    struct is_non_proxy_reference

      : mpl::bool_<

            is_non_proxy_reference_impl<Reference, Value>::value

        >

    {};

# else 

    template <class Reference, class Value>

    struct is_non_proxy_reference

      : is_convertible<

            typename remove_reference<Reference>::type

            const volatile*

          , Value const volatile*

        >

    {};

# endif 

    // A metafunction to choose the result type of postfix ++

    //

    // Because the C++98 input iterator requirements say that *r++ has

    // type T (value_type), implementations of some standard

    // algorithms like lexicographical_compare may use constructions

    // like:

    //

    //          *r++ < *s++

    //

    // If *r++ returns a proxy (as required if r is writable but not

    // multipass), this sort of expression will fail unless the proxy

    // supports the operator<.  Since there are any number of such

    // operations, we're not going to try to support them.  Therefore,

    // even if r++ returns a proxy, *r++ will only return a proxy if

    // *r also returns a proxy.

    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>

    struct postfix_increment_result

      : mpl::eval_if<

            mpl::and_<

                // A proxy is only needed for readable iterators

                is_convertible<Reference,Value const&>

                // No multipass iterator can have values that disappear

                // before positions can be re-visited

              , mpl::not_<

                    is_convertible<

                        typename iterator_category_to_traversal<CategoryOrTraversal>::type

                      , forward_traversal_tag

                    >

                >

            >

          , mpl::if_<

                is_non_proxy_reference<Reference,Value>

              , postfix_increment_proxy<Iterator>

              , writable_postfix_increment_proxy<Iterator>

            >

          , mpl::identity<Iterator>

        >

    {};

    // operator->() needs special support for input iterators to strictly meet the

    // standard's requirements. If *i is not a reference type, we must still

    // produce a lvalue to which a pointer can be formed. We do that by

    // returning an instantiation of this special proxy class template.

    template <class T>

    struct operator_arrow_proxy

    {

        operator_arrow_proxy(T const* px) : m_value(*px) {}

        T* operator->() const { return &m_value; }

        // This function is needed for MWCW and BCC, which won't call operator->

        // again automatically per 13.3.1.2 para 8

        operator T*() const { return &m_value; }

        mutable T m_value;

    };

    // A metafunction that gets the result type for operator->.  Also

    // has a static function make() which builds the result from a

    // Reference

    template <class ValueType, class Reference, class Pointer>

    struct operator_arrow_result

    {

        // CWPro8.3 won't accept "operator_arrow_result::type", and we

        // need that type below, so metafunction forwarding would be a

        // losing proposition here.

        typedef typename mpl::if_<

            is_reference<Reference>

          , Pointer

          , operator_arrow_proxy<ValueType>

        >::type type;

        static type make(Reference x)

        {

            return implicit_cast<type>(&x);

        }

    };

# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)

    // Deal with ETI

    template<>

    struct operator_arrow_result<int, int, int>

    {

        typedef int type;

    };

# endif

    // A proxy return type for operator[], needed to deal with

    // iterators that may invalidate referents upon destruction.

    // Consider the temporary iterator in *(a + n)

    template <class Iterator>

    class operator_brackets_proxy

    {

        // Iterator is actually an iterator_facade, so we do not have to

        // go through iterator_traits to access the traits.

        typedef typename Iterator::reference  reference;

        typedef typename Iterator::value_type value_type;

     public:

        operator_brackets_proxy(Iterator const& iter)

          : m_iter(iter)

        {}

        operator reference() const

        {

            return *m_iter;

        }

        operator_brackets_proxy& operator=(value_type const& val)

        {

            *m_iter = val;

            return *this;

        }

     private:

        Iterator m_iter;

    };

    // A metafunction that determines whether operator[] must return a

    // proxy, or whether it can simply return a copy of the value_type.

    template <class ValueType, class Reference>

    struct use_operator_brackets_proxy

      : mpl::not_<

            mpl::and_<

                // Really we want an is_copy_constructible trait here,

                // but is_POD will have to suffice in the meantime.

                boost::is_POD<ValueType>

              , iterator_writability_disabled<ValueType,Reference>

            >

        >

    {};

    template <class Iterator, class Value, class Reference>

    struct operator_brackets_result

    {

        typedef typename mpl::if_<

            use_operator_brackets_proxy<Value,Reference>

          , operator_brackets_proxy<Iterator>

          , Value

        >::type type;

    };

    template <class Iterator>

    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)

    {

        return operator_brackets_proxy<Iterator>(iter);

    }

    template <class Iterator>

    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)

    {

      return *iter;

    }

    struct choose_difference_type

    {

        template <class I1, class I2>

        struct apply

          :

# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP

          iterator_difference<I1>

# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)

          mpl::if_<

              is_convertible<I2,I1>

            , typename I1::difference_type

            , typename I2::difference_type

          >

# else 

          mpl::eval_if<

              is_convertible<I2,I1>

            , iterator_difference<I1>

            , iterator_difference<I2>

          >

# endif 

        {};

    };

  } // namespace detail

  // Macros which describe the declarations of binary operators

# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY

#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \

    template <                                                              \

        class Derived1, class V1, class TC1, class R1, class D1             \

      , class Derived2, class V2, class TC2, class R2, class D2             \

    >                                                                       \

    prefix typename mpl::apply2<result_type,Derived1,Derived2>::type \

    operator op(                                                            \

        iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs               \

      , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)

# else 

#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)   \

    template <                                                          \

        class Derived1, class V1, class TC1, class R1, class D1         \

      , class Derived2, class V2, class TC2, class R2, class D2         \

    >                                                                   \

    prefix typename detail::enable_if_interoperable<             \

        Derived1, Derived2                                              \

      , typename mpl::apply2<result_type,Derived1,Derived2>::type       \

    >::type                                                             \

    operator op(                                                        \

        iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs           \

      , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)

# endif 

#  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \

    template <class Derived, class V, class TC, class R, class D>   \

    prefix Derived operator+ args

  //

  // Helper class for granting access to the iterator core interface.

  //

  // The simple core interface is used by iterator_facade. The core

  // interface of a user/library defined iterator type should not be made public

  // so that it does not clutter the public interface. Instead iterator_core_access

  // should be made friend so that iterator_facade can access the core

  // interface through iterator_core_access.

  //

  class iterator_core_access

  {

# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \

    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))

      // Tasteless as this may seem, making all members public allows member templates

      // to work in the absence of member template friends.

   public:

# else

      template <class I, class V, class TC, class R, class D> friend class iterator_facade;

#  define BOOST_ITERATOR_FACADE_RELATION(op)                                \

      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, detail::always_bool2);

      BOOST_ITERATOR_FACADE_RELATION(==)

      BOOST_ITERATOR_FACADE_RELATION(!=)

      BOOST_ITERATOR_FACADE_RELATION(<)

      BOOST_ITERATOR_FACADE_RELATION(>)

      BOOST_ITERATOR_FACADE_RELATION(<=)

      BOOST_ITERATOR_FACADE_RELATION(>=)

#  undef BOOST_ITERATOR_FACADE_RELATION

      BOOST_ITERATOR_FACADE_INTEROP_HEAD(

          friend, -, detail::choose_difference_type)

      ;

      BOOST_ITERATOR_FACADE_PLUS_HEAD(

          friend inline

          , (iterator_facade<Derived, V, TC, R, D> const&

           , typename Derived::difference_type)

      )

      ;

      BOOST_ITERATOR_FACADE_PLUS_HEAD(

          friend inline

        , (typename Derived::difference_type

           , iterator_facade<Derived, V, TC, R, D> const&)

      )

      ;

# endif

      template <class Facade>

      static typename Facade::reference dereference(Facade const& f)

      {

          return f.dereference();

      }

      template <class Facade>

      static void increment(Facade& f)

      {

          f.increment();

      }

      template <class Facade>

      static void decrement(Facade& f)

      {

          f.decrement();

      }

      template <class Facade1, class Facade2>

      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)

      {

          return f1.equal(f2);

      }

      template <class Facade1, class Facade2>

      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)

      {

          return f2.equal(f1);

      }

      template <class Facade>

      static void advance(Facade& f, typename Facade::difference_type n)

      {

          f.advance(n);

      }

      template <class Facade1, class Facade2>

      static typename Facade1::difference_type distance_from(

          Facade1 const& f1, Facade2 const& f2, mpl::true_)

      {

          return -f1.distance_to(f2);

      }

      template <class Facade1, class Facade2>

      static typename Facade2::difference_type distance_from(

          Facade1 const& f1, Facade2 const& f2, mpl::false_)

      {

          return f2.distance_to(f1);

      }

      //

      // Curiously Recurring Template interface.

      //

      template <class I, class V, class TC, class R, class D>

      static I& derived(iterator_facade<I,V,TC,R,D>& facade)

      {

          return *static_cast<I*>(&facade);

      }

      template <class I, class V, class TC, class R, class D>

      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)

      {

          return *static_cast<I const*>(&facade);

      }

   private:

      // objects of this class are useless

      iterator_core_access(); //undefined

  };

  //

  // iterator_facade - use as a public base class for defining new

  // standard-conforming iterators.

  //

  template <

      class Derived             // The derived iterator type being constructed

    , class Value

    , class CategoryOrTraversal

    , class Reference   = Value&

    , class Difference  = std::ptrdiff_t

  >

  class iterator_facade

# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE

    : public detail::iterator_facade_types<

         Value, CategoryOrTraversal, Reference, Difference

      >::base

#  undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE

# endif

  {

   private:

      //

      // Curiously Recurring Template interface.

      //

      Derived& derived()

      {

          return *static_cast<Derived*>(this);

      }

      Derived const& derived() const

      {

          return *static_cast<Derived const*>(this);

      }

      typedef detail::iterator_facade_types<

         Value, CategoryOrTraversal, Reference, Difference

      > associated_types;

   protected:

      // For use by derived classes

      typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;

   public:

      typedef typename associated_types::value_type value_type;

      typedef Reference reference;

      typedef Difference difference_type;

      typedef typename associated_types::pointer pointer;

      typedef typename associated_types::iterator_category iterator_category;

      reference operator*() const

      {

          return iterator_core_access::dereference(this->derived());

      }

      typename detail::operator_arrow_result<

          value_type

        , reference

        , pointer

      >::type

      operator->() const

      {

          return detail::operator_arrow_result<

              value_type

            , reference

            , pointer

          >::make(*this->derived());

      }

      typename detail::operator_brackets_result<Derived,Value,reference>::type

      operator[](difference_type n) const

      {

          typedef detail::use_operator_brackets_proxy<Value,Reference> use_proxy;

          return detail::make_operator_brackets_result<Derived>(

              this->derived() + n

            , use_proxy()

          );

      }

      Derived& operator++()

      {

          iterator_core_access::increment(this->derived());

          return this->derived();

      }

# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)

      typename detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type

      operator++(int)

      {

          typename detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type

          tmp(this->derived());

          ++*this;

          return tmp;

      }

# endif

      Derived& operator--()

      {

          iterator_core_access::decrement(this->derived());

          return this->derived();

      }

      Derived operator--(int)

      {

          Derived tmp(this->derived());

          --*this;

          return tmp;

      }

      Derived& operator+=(difference_type n)

      {

          iterator_core_access::advance(this->derived(), n);

          return this->derived();

      }

      Derived& operator-=(difference_type n)

      {

          iterator_core_access::advance(this->derived(), -n);

          return this->derived();

      }

      Derived operator-(difference_type x) const

      {

          Derived result(this->derived());

          return result -= x;

      }

# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)

      // There appears to be a bug which trashes the data of classes

      // derived from iterator_facade when they are assigned unless we

      // define this assignment operator.  This bug is only revealed

      // (so far) in STLPort debug mode, but it's clearly a codegen

      // problem so we apply the workaround for all MSVC6.

      iterator_facade& operator=(iterator_facade const&)

      {

          return *this;

      }

# endif

  };

# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)

  template <class I, class V, class TC, class R, class D>

  inline typename detail::postfix_increment_result<I,V,R,TC>::type

  operator++(

      iterator_facade<I,V,TC,R,D>& i

    , int

  )

  {

      typename detail::postfix_increment_result<I,V,R,TC>::type

          tmp(*static_cast<I*>(&i));

      ++i;

      return tmp;

  }

# endif 

  //

  // Comparison operator implementation. The library supplied operators

  // enables the user to provide fully interoperable constant/mutable

  // iterator types. I.e. the library provides all operators

  // for all mutable/constant iterator combinations.

  //

  // Note though that this kind of interoperability for constant/mutable

  // iterators is not required by the standard for container iterators.

  // All the standard asks for is a conversion mutable -> constant.

  // Most standard library implementations nowadays provide fully interoperable

  // iterator implementations, but there are still heavily used implementations

  // that do not provide them. (Actually it's even worse, they do not provide

  // them for only a few iterators.)

  //

  // ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should

  //    enable the user to turn off mixed type operators

  //

  // The library takes care to provide only the right operator overloads.

  // I.e.

  //

  // bool operator==(Iterator,      Iterator);

  // bool operator==(ConstIterator, Iterator);

  // bool operator==(Iterator,      ConstIterator);

  // bool operator==(ConstIterator, ConstIterator);

  //

  //   ...

  //

  // In order to do so it uses c++ idioms that are not yet widely supported

  // by current compiler releases. The library is designed to degrade gracefully

  // in the face of compiler deficiencies. In general compiler

  // deficiencies result in less strict error checking and more obscure

  // error messages, functionality is not affected.

  //

  // For full operation compiler support for "Substitution Failure Is Not An Error"

  // (aka. enable_if) and boost::is_convertible is required.

  //

  // The following problems occur if support is lacking.

  //

  // Pseudo code

  //

  // ---------------

  // AdaptorA<Iterator1> a1;

  // AdaptorA<Iterator2> a2;

  //

  // // This will result in a no such overload error in full operation

  // // If enable_if or is_convertible is not supported

  // // The instantiation will fail with an error hopefully indicating that

  // // there is no operator== for Iterator1, Iterator2

  // // The same will happen if no enable_if is used to remove

  // // false overloads from the templated conversion constructor

  // // of AdaptorA.

  //

  // a1 == a2;

  // ----------------

  //

  // AdaptorA<Iterator> a;

  // AdaptorB<Iterator> b;

  //

  // // This will result in a no such overload error in full operation

  // // If enable_if is not supported the static assert used

  // // in the operator implementation will fail.

  // // This will accidently work if is_convertible is not supported.

  //

  // a == b;

  // ----------------

  //

# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP

#  define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_()

# else

#  define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()

# endif

# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \

  BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type)                   \

  {                                                                             \

      /* For those compilers that do not support enable_if */                   \

      BOOST_STATIC_ASSERT((                                                     \

          is_interoperable< Derived1, Derived2 >::value                         \

      ));                                                                       \

      return_prefix iterator_core_access::base_op(                              \

          *static_cast<Derived1 const*>(&lhs)                                   \

        , *static_cast<Derived2 const*>(&rhs)                                   \

        , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \

      );                                                                        \

  }

# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \

  BOOST_ITERATOR_FACADE_INTEROP(                                    \

      op                                                            \

    , detail::always_bool2                                          \

    , return_prefix                                                 \

    , base_op                                                       \

  )

  BOOST_ITERATOR_FACADE_RELATION(==, return, equal)

  BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal)

  BOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_from)

  BOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_from)

  BOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_from)

  BOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_from)

# undef BOOST_ITERATOR_FACADE_RELATION

  // operator- requires an additional part in the static assertion

  BOOST_ITERATOR_FACADE_INTEROP(

      -

    , detail::choose_difference_type

    , return

    , distance_from

  )

# undef BOOST_ITERATOR_FACADE_INTEROP

# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD

# define BOOST_ITERATOR_FACADE_PLUS(args)           \

  BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args)     \

  {                                                 \

      Derived tmp(static_cast<Derived const&>(i));  \

      return tmp += n;                              \

  }

BOOST_ITERATOR_FACADE_PLUS((

  iterator_facade<Derived, V, TC, R, D> const& i

  , typename Derived::difference_type n

))

BOOST_ITERATOR_FACADE_PLUS((

    typename Derived::difference_type n

    , iterator_facade<Derived, V, TC, R, D> const& i

))

# undef BOOST_ITERATOR_FACADE_PLUS

# undef BOOST_ITERATOR_FACADE_PLUS_HEAD

} // namespace boost

#include <boost/iterator/detail/config_undef.hpp>

#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP