// (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_INDIRECT_ITERATOR_23022003THW_HPP

 #define BOOST_INDIRECT_ITERATOR_23022003THW_HPP

 #include <boost/iterator.hpp>

 #include <boost/iterator/iterator_adaptor.hpp>

 #include <boost/pointee.hpp>

 #include <boost/indirect_reference.hpp>

 #include <boost/detail/iterator.hpp>

 #include <boost/detail/indirect_traits.hpp>

 #include <boost/type_traits/is_same.hpp>

 #include <boost/type_traits/add_reference.hpp>

 #include <boost/mpl/bool.hpp>

 #include <boost/mpl/identity.hpp>

 #include <boost/mpl/eval_if.hpp>

 #include <boost/mpl/not.hpp>

 #include <boost/mpl/has_xxx.hpp>

 #ifdef BOOST_MPL_CFG_NO_HAS_XXX

 # include <boost/shared_ptr.hpp>

 # include <boost/scoped_ptr.hpp>

 # include <boost/mpl/bool.hpp>

 # include <memory>

 #endif 

 #include <boost/iterator/detail/config_def.hpp> // must be last #include

 namespace boost

 {

   template <class Iter, class Value, class Category, class Reference, class Difference>

   class indirect_iterator;

   namespace detail

   {

     template <class Iter, class Value, class Category, class Reference, class Difference>

     struct indirect_base

     {

         typedef typename iterator_traits<Iter>::value_type dereferenceable;

         typedef iterator_adaptor<

             indirect_iterator<Iter, Value, Category, Reference, Difference>

           , Iter

           , typename ia_dflt_help<

                 Value, pointee<dereferenceable>

             >::type

           , Category

           , typename ia_dflt_help<

                 Reference

               , mpl::eval_if<

                     is_same<Value,use_default>

                   , indirect_reference<dereferenceable>

                   , add_reference<Value>

                 >

             >::type

           , Difference

         > type;

     };

     template <>

     struct indirect_base<int, int, int, int, int> {};

   } // namespace detail

   template <

       class Iterator

     , class Value = use_default

     , class Category = use_default

     , class Reference = use_default

     , class Difference = use_default

   >

   class indirect_iterator

     : public detail::indirect_base<

         Iterator, Value, Category, Reference, Difference

       >::type

   {

       typedef typename detail::indirect_base<

           Iterator, Value, Category, Reference, Difference

       >::type super_t;

       friend class iterator_core_access;

    public:

       indirect_iterator() {}

       indirect_iterator(Iterator iter)

         : super_t(iter) {}

       template <

           class Iterator2, class Value2, class Category2

         , class Reference2, class Difference2

       >

       indirect_iterator(

           indirect_iterator<

                Iterator2, Value2, Category2, Reference2, Difference2

           > const& y

         , typename enable_if_convertible<Iterator2, Iterator>::type* = 0

       )

         : super_t(y.base())

       {}

   private:    

       typename super_t::reference dereference() const

       {

 # if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))

           return const_cast<super_t::reference>(**this->base());

 # else

           return **this->base();

 # endif 

       }

   };

   template <class Iter>

   inline

   indirect_iterator<Iter> make_indirect_iterator(Iter x)

   {

     return indirect_iterator<Iter>(x);

   }

   template <class Traits, class Iter>

   inline

   indirect_iterator<Iter,Traits> make_indirect_iterator(Iter x, Traits* = 0)

   {

     return indirect_iterator<Iter, Traits>(x);

   }

 } // namespace boost

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

 #endif // BOOST_INDIRECT_ITERATOR_23022003THW_HPP