diff --git a/include/boost/iterator/iterator_adaptors.hpp b/include/boost/iterator/iterator_adaptors.hpp
index d2158d1..00e53c1 100644
--- a/include/boost/iterator/iterator_adaptors.hpp
+++ b/include/boost/iterator/iterator_adaptors.hpp
@@ -1,400 +1,660 @@
 #ifndef BOOST_ITERATOR_ADAPTORS_HPP
 #define BOOST_ITERATOR_ADAPTORS_HPP
 
+#include <boost/static_assert.hpp>
 #include <boost/utility.hpp> // for prior
 #include <boost/iterator.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/mpl/aux_/has_xxx.hpp>
+#include <boost/mpl/logical/or.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_convertible.hpp>
 
 #include "boost/type_traits/detail/bool_trait_def.hpp"
 
 namespace boost {
 
-template <class Final, class V, class R, class P, class C, class D>
-struct repository : iterator<C, V, D, P, R>
+  namespace detail {
 
-{
-    typedef Final final;
-};
+    template<bool>
+    struct enabled
+    {
+      template<typename T>
+      struct base
+      {
+        typedef T type;
+      };
+    };
+    
+    template<>
+    struct enabled<false>
+    {
+      template<typename T>
+      struct base
+      {
+      };
+    };
 
-template <class Base>
-struct downcastable : Base
-{
-    typedef typename Base::final final_t;
-public:
-    final_t& self() { return static_cast<final_t&>(*this); }
-    const final_t& self() const { return static_cast<const final_t&>(*this); }
-};
+    struct enable_type {};
 
-template <class Base>
-struct iterator_comparisons : Base
-{
-};
+    template <typename A, typename B>
+    struct is_interoperable :
+      mpl::logical_or< is_convertible< A, B >,
+                       is_convertible< B, A > >
+    {
+    };
 
-template <class Base1, class Base2>
-inline bool operator==(const iterator_comparisons<Base1>& xb,
-                       const iterator_comparisons<Base2>& yb)
-{
-    return xb.self().equal(yb.self());
-}
+    template <class Facade1,
+              class Facade2,
+              class Return>
+    struct enable_if_interoperable :
+      enabled<(is_interoperable<Facade1, Facade2>::value)>::template base<Return>
+    {
+    };
 
-template <class Base1, class Base2>
-inline bool operator!=(const iterator_comparisons<Base1>& xb,
-                       const iterator_comparisons<Base2>& yb)
-{
-    return !xb.self().equal(yb.self());
-}
-
-template <class Base1, class Base2>
-inline bool operator<(const iterator_comparisons<Base1>& xb,
-                      const iterator_comparisons<Base2>& yb)
-{
-    return xb.self().distance_to(yb.self()) > 0;
-}
-
-template <class Base1, class Base2>
-inline bool operator>(const iterator_comparisons<Base1>& xb,
-                      const iterator_comparisons<Base2>& yb)
-{
-    return xb.self().distance_to(yb.self()) < 0;
-}
-
-template <class Base1, class Base2>
-inline bool operator>=(const iterator_comparisons<Base1>& xb,
-                       const iterator_comparisons<Base2>& yb)
-{
-    return xb.self().distance_to(yb.self()) <= 0;
-}
-
-template <class Base1, class Base2>
-inline bool operator<=(const iterator_comparisons<Base1>& xb,
-                       const iterator_comparisons<Base2>& yb)
-{
-    return xb.self().distance_to(yb.self()) >= 0;
-}
+  } // namespace detail
 
 
-template <class B>
-struct iterator_arith :  B { };
+  template<typename From,
+           typename To>
+  struct enable_if_convertible :
+    detail::enabled<(is_convertible<From, To>::value)>::template base<detail::enable_type>
+  {
+  };
 
-template <class Base>
-typename Base::final operator+(
-    const iterator_arith<Base>& i, // pass by ref, not value to avoid slicing -JGS
-    typename Base::difference_type n)
-{
-    typename Base::final tmp(i.self());
-    return tmp += n;
-}
+  //
+  // Helper class for granting access to the iterator core interface.
+  //
+  // The simple core interface is used by iterator_facade. The core
+  // interface should not be made public so that it does not clutter
+  // the public interface of user defined iterators. Instead iterator_core_access
+  // should be made friend so that iterator_facade can access the core
+  // interface through iterator_core_access.
+  //
+  struct iterator_core_access
+  {
+    template <class Facade>
+    static typename Facade::reference dereference(Facade const& f)
+    {
+      return f.dereference();
+    }
 
-template <class Base>
-typename Base::final operator+(
-    typename Base::difference_type n,  
-    const iterator_arith<Base>& i) // pass by ref, not value to avoid slicing -JGS
-{
-    typename Base::final tmp(i.self());
-    return tmp += n;
-}
+    template <class Facade>
+    static void increment(Facade& f)
+    {
+      f.increment();
+    }
 
-template <class Base1, class Base2>
-typename Base1::difference_type operator-(
-    const iterator_arith<Base1>& i,
-    const iterator_arith<Base2>& j)
-{
-    return j.self().distance_to(i.self());
-}
+    template <class Facade>
+    static void decrement(Facade& f)
+    {
+      f.decrement();
+    }
 
-// Used for a default template argument, when we can't afford to
-// instantiate the default calculation if unused.
-struct unspecified {};
+    template <class Facade1, class Facade2>
+    static bool equal(Facade1 const& f1, Facade2 const& f2, Facade1* = 0, Facade2* = 0)
+    {
+      return f1.equal(f2);
+    }
+
+    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_to(Facade1 const& f1,
+                                                         Facade2 const& f2,
+                                                         Facade1* = 0,
+                                                         Facade2* = 0)
+    {
+      return f1.distance_to(f2);
+    }
+
+  };
+
+  template <class Derived,
+            class V,
+            class R,
+            class P,
+            class C,
+            class D>
+  class repository :
+    public iterator<C, V, D, P, R>
+  {
+    typedef Derived derived_t;
+  };
+
+  template <class Base>
+  class downcastable :
+    public Base
+  {
+  public:
+    typename Base::derived_t& derived()
+    {
+      return static_cast<typename Base::derived_t&>(*this);
+    }
+
+    typename Base::derived_t const& derived() const 
+    {
+      return static_cast<typename Base::derived_t const&>(*this);
+    }
+  };
 
 #if 0
-// Beginnings of a failed attempt to conditionally provide base()
-// functions in iterator_adaptor. It may be that a public m_base
-// member is the only way to avoid boilerplate!
+  namespace detail {
 
-template <class Base>
-struct base_wrapper_impl
-{
-    template <class Super>
-    struct apply : Super
-    {
-        apply() {}
-        apply(Base b) : m_base(b) {}
-    
-        Base base() const { return m_base; }
-        Base& base() { return m_base; }
-     private:
-        Base m_base;
-    };
-};
-
-template <>
-struct base_wrapper_impl<unspecified>
-{
-    template <class Super>
-    struct apply : Super
+    template <class Final1,
+              class Final2>
+    struct compare_traits :
+      mpl::if_< is_convertible<Final2, Final1>,
+                Final1,
+                Final2 >
     {
     };
-};
+
+  } // namespace detail
 #endif
 
-template <class Final
-          , class V, class R, class P, class C, class D
-          , class B = iterator_arith<
-             iterator_comparisons<
-        downcastable<repository<Final, V, R, P, C, D> > > >
-         >
-struct iterator_adaptor : B 
-{
-    typedef V value_type;
-    typedef R reference;
-    typedef P pointer;
-    typedef C iterator_category;
-    typedef D difference_type;
+  template <class Base>
+  class iterator_comparisons :
+    public Base
+  {
+  };
+
+  template <class Base1,
+            class Base2>
+  inline
+  typename detail::enable_if_interoperable<typename Base1::derived_t,
+                                           typename Base2::derived_t,
+                                           bool>::type
+  operator==(iterator_comparisons<Base1> const& lhs,
+             iterator_comparisons<Base2> const& rhs)
+  {
+    // For those compilers that do not support enable_if
+    BOOST_STATIC_ASSERT((detail::is_interoperable< 
+                         typename Base1::derived_t,
+                         typename Base2::derived_t >::value));
+
+    return iterator_core_access::equal(lhs.derived(),
+                                       rhs.derived());
+  }
+
+  template <class Base1,
+            class Base2>
+  inline
+  typename detail::enable_if_interoperable<typename Base1::derived_t,
+                                           typename Base2::derived_t,
+                                           bool>::type
+  operator!=(iterator_comparisons<Base1> const& lhs,
+             iterator_comparisons<Base2> const& rhs)
+  {
+    // For those compilers that do not support enable_if
+    BOOST_STATIC_ASSERT((detail::is_interoperable< 
+                         typename Base1::derived_t,
+                         typename Base2::derived_t >::value));
+
+    return !iterator_core_access::equal(lhs.derived(),
+                                        rhs.derived());
+  }
+
+  template <class Base1,
+            class Base2>
+  inline
+  typename detail::enable_if_interoperable<typename Base1::derived_t,
+                                           typename Base2::derived_t,
+                                           bool>::type
+  operator<(iterator_comparisons<Base1> const& lhs,
+                        iterator_comparisons<Base2> const& rhs)
+  {
+    // For those compilers that do not support enable_if
+    BOOST_STATIC_ASSERT((detail::is_interoperable< 
+                         typename Base1::derived_t,
+                         typename Base2::derived_t >::value));
+
+    return iterator_core_access::distance_to(lhs.derived(),
+                                             rhs.derived()) > 0;
+  }
+
+  template <class Base1,
+            class Base2>
+  inline
+  typename detail::enable_if_interoperable<typename Base1::derived_t,
+                                           typename Base2::derived_t,
+                                           bool>::type
+  operator>(iterator_comparisons<Base1> const& lhs,
+                        iterator_comparisons<Base2> const& rhs)
+  {
+    // For those compilers that do not support enable_if
+    BOOST_STATIC_ASSERT((detail::is_interoperable< 
+                         typename Base1::derived_t,
+                         typename Base2::derived_t >::value));
+
+    return iterator_core_access::distance_to(lhs.derived(),
+                                             rhs.derived()) < 0;
+  }
+
+  template <class Base1,
+            class Base2>
+  inline
+  typename detail::enable_if_interoperable<typename Base1::derived_t,
+                                           typename Base2::derived_t,
+                                           bool>::type
+  operator<=(iterator_comparisons<Base1> const& lhs,
+                        iterator_comparisons<Base2> const& rhs)
+  {
+    // For those compilers that do not support enable_if
+    BOOST_STATIC_ASSERT((detail::is_interoperable< 
+                         typename Base1::derived_t,
+                         typename Base2::derived_t >::value));
+
+    return iterator_core_access::distance_to(lhs.derived(),
+                                             rhs.derived()) >= 0;
+  }
+
+  template <class Base1,
+            class Base2>
+  inline
+  typename detail::enable_if_interoperable<typename Base1::derived_t,
+                                           typename Base2::derived_t,
+                                           bool>::type
+  operator>=(iterator_comparisons<Base1> const& lhs,
+             iterator_comparisons<Base2> const& rhs)
+  {
+    // For those compilers that do not support enable_if
+    BOOST_STATIC_ASSERT((detail::is_interoperable< 
+                         typename Base1::derived_t,
+                         typename Base2::derived_t >::value));
+
+    return iterator_core_access::distance_to(lhs.derived(),
+                                             rhs.derived()) <= 0;
+  }
+
+
+  template <class Base>
+  class iterator_arith :
+    public Base 
+  {
+  };
+
+  template <class Base>
+  inline
+  typename Base::derived_t operator+(iterator_arith<Base> const&    i,
+                                     typename Base::difference_type n)
+  {
+    typename Base::derived_t tmp(i.derived());
+    return tmp += n;
+  }
+
+  template <class Base>
+  inline
+  typename Base::derived_t operator+(typename Base::difference_type n,
+                                     iterator_arith<Base> const&    i)
+  {
+    typename Base::derived_t tmp(i.derived());
+    return tmp += n;
+  }
+
+  template <class Base1,
+            class Base2>
+  inline
+  typename detail::enable_if_interoperable<typename Base1::derived_t,
+                                           typename Base2::derived_t,
+                                           typename Base1::difference_type>::type
+  operator-(iterator_arith<Base1> const& lhs,
+            iterator_arith<Base2> const& rhs)
+  {
+    // For those compilers that do not support enable_if
+    BOOST_STATIC_ASSERT((detail::is_interoperable< 
+                         typename Base1::derived_t,
+                         typename Base2::derived_t >::value));
+
+    BOOST_STATIC_ASSERT((is_same<typename Base1::difference_type,
+                                 typename Base2::difference_type>::value));
+
+    return iterator_core_access::distance_to(lhs.derived(),
+                                             rhs.derived());
+  }
+
+  template <class Derived,
+            class V,
+            class R,
+            class P,
+            class C, 
+            class D,
+            // We do not use the name base here, as base is used in
+            // reverse iterator.
+            class Super = iterator_arith<
+    iterator_comparisons<
+    downcastable<
+    repository< Derived, V, R, P, C, D > > > >
+  >
+  class iterator_facade : 
+    public Super
+  {
+    typedef Super super_t;
+
+  public:
+    typedef typename super_t::reference       reference;
+    typedef typename super_t::difference_type difference_type;
 
     reference operator*() const
-    { return self().dereference(); }
+    { return iterator_core_access::dereference(this->derived()); }
 
     // Needs eventual help for input iterators
-    P operator->() const { return &self().dereference(); }
-    
-    //operator->() const { return detail::operator_arrow(*this, iterator_category()); }
-    
+    P operator->() const { return &iterator_core_access::dereference(this->derived()); }
+        
     reference operator[](difference_type n) const
     { return *(*this + n); }
-    Final& operator++()
-    { self().increment(); return self(); }
-    Final operator++(int)
-    { Final tmp(self()); ++*this; return tmp; }
-    Final& operator--()
-    { self().decrement(); return self(); }
-    Final operator--(int)
-    { Final tmp(self()); --*this; return tmp; }
-    Final& operator+=(difference_type n)
-    { self().advance(n); return self(); }
-    Final& operator-=(difference_type n)
-    { self().advance(-n); return self(); }
-    Final operator-(difference_type x) const
-    { Final result(self()); return result -= x; }
 
-    template <class Final2, class V2, class R2, class P2, class B2>
-    bool equal(iterator_adaptor<Final2,V2,R2,P2,C,D,B2> const& x) const
+    Derived& operator++()
+    { iterator_core_access::increment(this->derived()); return this->derived(); }
+
+    Derived operator++(int)
+    { Derived tmp(this->derived()); ++*this; return tmp; }
+  
+    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; }
+  };
+
+  //
+  // We should provide NTP here
+  //
+  // TODO Handle default arguments the same way as
+  // in former ia lib
+  //
+  template <class Derived,
+            class Iterator,
+            class Value     = typename std::iterator_traits<Iterator>::value_type,
+            class Reference = typename std::iterator_traits<Iterator>::reference,
+            class Pointer   = typename std::iterator_traits<Iterator>::pointer,
+            class Category  = typename std::iterator_traits<Iterator>::iterator_category,
+            class Distance  = typename std::iterator_traits<Iterator>::difference_type>
+  class iterator_adaptor :
+    public iterator_facade<Derived,
+                           Value,
+                           Reference,
+                           Pointer,
+                           Category,
+                           Distance>
+  {
+    friend class iterator_core_access;
+
+  public:
+    iterator_adaptor() {}
+
+    explicit iterator_adaptor(Iterator iter)
+      : m_iterator(iter)
     {
-        return self().base() == x.self().base();
-    }
-    void advance(difference_type n)
-    {
-        self().base() += n;
     }
 
-    reference dereference() const { return *self().base(); }  
-    
-    void increment() { ++self().base(); }
-    void decrement() { --self().base(); }
+    Iterator base() const { return m_iterator; }
 
-    template <class Final2, class B2, class V2, class R2, class P2>
-    difference_type
-    distance_to(const iterator_adaptor<Final2,V2,R2,P2,C,D,B2>& y) const
+  protected:
+    // Core iterator interface for iterator_facade
+    // 
+    Reference dereference() const { return *m_iterator; }
+
+    template <class OtherDerived,
+              class OtherIterator,
+              class OtherValue,     
+              class OtherReference, 
+              class OtherPointer >   
+    bool equal(iterator_adaptor<OtherDerived,
+                                OtherIterator,
+                                OtherValue,
+                                OtherReference,
+                                OtherPointer,
+                                Category,
+                                Distance> const& x) const
     {
-        return y.self().base() - self().base();//?
+      return m_iterator == x.base();
+    }
+  
+    void advance(Distance n)
+    {
+      m_iterator += n;
+    }
+  
+    void increment() { ++m_iterator; }
+    void decrement() { --m_iterator; }
+
+    template <class OtherDerived,
+              class OtherIterator,
+              class OtherValue,     
+              class OtherReference, 
+              class OtherPointer >   
+    Distance distance_to(iterator_adaptor<OtherDerived,
+                                          OtherIterator,
+                                          OtherValue,
+                                          OtherReference,
+                                          OtherPointer,
+                                          Category,
+                                          Distance> const& y) const
+    {
+      return y.base() - m_iterator;
     }
 
-    // Can't be private, or const/non-const interactions don't work
-    using B::self;
-};
+  private:
+    Iterator m_iterator;
 
+  };
 
-template <class Base, 
-          class V, class R, class P, class C, class D>
-struct reverse_iterator
-    : iterator_adaptor<
-         reverse_iterator<Base, V, R, P, C, D>, V, R, P, C, D
-      >
-{
-    typedef iterator_adaptor<reverse_iterator<Base, V, R, P, C, D>, V, R, P, C, D> super;
+  //
+  //
+  //
+  template <class Iterator>
+  class reverse_iterator :
+    public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
+  {
+    typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;
+
+    friend class iterator_core_access;
+
+  public:
+    reverse_iterator() {}
+
+    explicit reverse_iterator(Iterator x) 
+      : super_t(x) {}
+
+    template<class OtherIterator>
+    reverse_iterator(reverse_iterator<OtherIterator> const& r,
+                     typename enable_if_convertible<OtherIterator, Iterator>::type* = 0)
+      : super_t(r.base()) {}
+
+  private:
+    typename super_t::reference dereference() const { return *boost::prior(this->base()); }
     
-//  friend class super;
-    // hmm, I don't like the next two lines
-//  template <class Der> friend struct iterator_comparisons;
-//  template <class Der, class Dist> friend struct iterator_arith;
-    
- public:
-    reverse_iterator(const Base& x) : m_base(x) { }
+    void increment() { super_t::decrement(); }
+    void decrement() { super_t::increment(); }
 
-    reverse_iterator() { }
-
-    Base const& base() const { return m_base; }
-    
-    template <class B2, class V2, class R2, class P2>
-    reverse_iterator(const reverse_iterator<B2,V2,R2,P2,C,D>& y)
-        : m_base(y.m_base) { }
-
-
-    typename super::reference dereference() const { return *boost::prior(m_base); }
-    
-    void increment() { --m_base; }
-    void decrement() { ++m_base; }
-    void advance(typename super::difference_type n)
+    void advance(typename super_t::difference_type n)
     {
-        m_base -= n;
+      super_t::advance(-n);
     }
 
-    template <class B2, class V2, class R2, class P2>
-    typename super::difference_type
-    distance_to(const reverse_iterator<B2,V2,R2,P2,C,D>& y) const
+    template <class OtherIterator>
+    typename super_t::difference_type
+    distance_to(reverse_iterator<OtherIterator> const& y) const
     {
-        return y.m_base - m_base;
+      return -super_t::distance_to(y);
     }
- private:
-    Base m_base;
-};
+  };
 
-template <class AdaptableUnaryFunction, class Base>
-struct transform_iterator
-    : iterator_adaptor<
-         transform_iterator<AdaptableUnaryFunction, Base>, 
-         typename AdaptableUnaryFunction::result_type,
-         typename AdaptableUnaryFunction::result_type, 
-         typename AdaptableUnaryFunction::result_type*, 
-         iterator_tag<readable_iterator_tag,
-                      typename traversal_category<Base>::type>, 
-         typename detail::iterator_traits<Base>::difference_type
-      >
-{
- public: // types
-  typedef typename AdaptableUnaryFunction::result_type value_type;
+  //
+  // TODO fix category
+  //
+  template <class AdaptableUnaryFunction, class Iterator>
+  class transform_iterator :
+    public iterator_adaptor< transform_iterator<AdaptableUnaryFunction, Iterator>,
+                             Iterator,
+                             typename AdaptableUnaryFunction::result_type,
+                             typename AdaptableUnaryFunction::result_type, 
+                             typename AdaptableUnaryFunction::result_type*
+                             >
+  {
+    typedef iterator_adaptor< transform_iterator<AdaptableUnaryFunction, Iterator>,
+                              Iterator,
+                              typename AdaptableUnaryFunction::result_type,
+                              typename AdaptableUnaryFunction::result_type, 
+                              typename AdaptableUnaryFunction::result_type* > super_t;
 
- public: // member functions
-  transform_iterator() { }
+    friend class iterator_core_access;
 
-  transform_iterator(const Base& x, AdaptableUnaryFunction f)
-    : m_base(x), m_f(f) { }
+  public:
+    transform_iterator() { }
 
-  value_type dereference() const { return m_f(*m_base); }
+    transform_iterator(Iterator const&        x,
+                       AdaptableUnaryFunction f)
+      : super_t(x), m_f(f) { }
 
-  template <class F2, class B2>
-  transform_iterator(const transform_iterator<F2,B2>& y)
-	: m_base(y.m_base), m_f(y.m_f) { }
+    template<class OtherIterator>
+    transform_iterator(transform_iterator<AdaptableUnaryFunction, OtherIterator> const& t,
+                       typename enable_if_convertible<OtherIterator, Iterator>::type* = 0)
+      : super_t(t.base()), m_f(t.functor()) {}
 
-  Base& base() { return m_base; }
-  Base const& base() const { return m_base; }
-    
-private:
-  Base m_base;
-  AdaptableUnaryFunction m_f;
-};
+    AdaptableUnaryFunction functor() const { return m_f; }
 
-// This macro definition is only temporary in this file
+  private:
+    typename super_t::value_type dereference() const { return m_f(super_t::dereference()); }
+
+    AdaptableUnaryFunction m_f;
+  };
+
+  // This macro definition is only temporary in this file
 # if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
 #  define BOOST_ARG_DEPENDENT_TYPENAME typename
 # else
 #  define BOOST_ARG_DEPENDENT_TYPENAME
 # endif
 
-namespace detail
-{
-  //
-  // Detection for whether a type has a nested `element_type'
-  // typedef. Used to detect smart pointers. We're having trouble
-  // auto-detecting smart pointers with gcc-2.95 via the nested
-  // element_type member. However, we really ought to have a
-  // specializable is_pointer template which can be used instead with
-  // something like boost/python/pointee.hpp to find the value_type.
-  //
-  namespace aux
-  {
-    BOOST_MPL_HAS_XXX_TRAIT_DEF(element_type)
-  }
+  struct unspecified {};
 
-  template <class T>
-  struct has_element_type
+  namespace detail
+  {
+    //
+    // Detection for whether a type has a nested `element_type'
+    // typedef. Used to detect smart pointers. We're having trouble
+    // auto-detecting smart pointers with gcc-2.95 via the nested
+    // element_type member. However, we really ought to have a
+    // specializable is_pointer template which can be used instead with
+    // something like boost/python/pointee.hpp to find the value_type.
+    //
+    namespace aux
+    {
+      BOOST_MPL_HAS_XXX_TRAIT_DEF(element_type)
+        }
+
+    template <class T>
+    struct has_element_type
       : mpl::if_<
-          is_class<T>
+      is_class<T>
 # if __GNUC__ == 2 // gcc 2.95 doesn't seem to be able to detect element_type without barfing
-          , mpl::bool_c<false>
+      , mpl::bool_c<false>
 # else 
-          , aux::has_element_type<T>
+      , aux::has_element_type<T>
 # endif 
-          , mpl::bool_c<false>
-        >::type
-  {
-  };
+      , mpl::bool_c<false>
+    >::type
+    {
+    };
   
-  // Metafunction returning the nested element_type typedef
-  template <class T>
-  struct smart_pointer_traits
-  {
+    // Metafunction returning the nested element_type typedef
+    template <class T>
+    struct smart_pointer_traits
+    {
       typedef typename remove_const<
-          typename T::element_type
+        typename T::element_type
       >::type value_type;
 
       typedef typename T::element_type& reference;
       typedef typename T::element_type* pointer;
-  };
+    };
 
-  // If the Value parameter is unspecified, we use this metafunction
-  // to deduce the default types
-  template <class Iter>
-  struct indirect_defaults
+    // If the Value parameter is unspecified, we use this metafunction
+    // to deduce the default types
+    template <class Iter>
+    struct indirect_defaults
       : mpl::if_c<
-          has_element_type<typename iterator_traits<Iter>::value_type>::value
-          , smart_pointer_traits<typename iterator_traits<Iter>::value_type>
-          , iterator_traits<typename iterator_traits<Iter>::value_type>
-      >::type
-  {
+      has_element_type<typename iterator_traits<Iter>::value_type>::value
+      , smart_pointer_traits<typename iterator_traits<Iter>::value_type>
+      , iterator_traits<typename iterator_traits<Iter>::value_type>
+    >::type
+    {
       typedef typename iterator_traits<Iter>::iterator_category iterator_category;
       typedef typename iterator_traits<Iter>::difference_type difference_type;
-  };
+    };
 
-  template <class Base, class Traits>
-  struct indirect_traits
+    template <class Base, class Traits>
+    struct indirect_traits
       : mpl::if_<is_same<Traits,unspecified>, indirect_defaults<Base>, Traits>::type
+    {
+    };
+  } // namespace detail
+
+  template <class Iterator, class Traits = unspecified>
+  class indirect_iterator :
+    public iterator_adaptor< indirect_iterator<Iterator, Traits>,
+                             Iterator,
+                             typename detail::indirect_traits<Iterator, Traits>::value_type,
+                             typename detail::indirect_traits<Iterator, Traits>::reference,
+                             typename detail::indirect_traits<Iterator, Traits>::pointer,
+                             typename detail::indirect_traits<Iterator, Traits>::iterator_category,
+                             typename detail::indirect_traits<Iterator, Traits>::difference_type >
   {
-  };
-} // namespace detail
+    typedef iterator_adaptor< indirect_iterator<Iterator, Traits>,
+                              Iterator,
+                              typename detail::indirect_traits<Iterator, Traits>::value_type,
+                              typename detail::indirect_traits<Iterator, Traits>::reference,
+                              typename detail::indirect_traits<Iterator, Traits>::pointer,
+                              typename detail::indirect_traits<Iterator, Traits>::iterator_category,
+                              typename detail::indirect_traits<Iterator, Traits>::difference_type > super_t;
 
-template <class Base, class Traits = unspecified>
-struct indirect_iterator
-    : iterator_adaptor<
-       indirect_iterator<Base,Traits>
-        , typename detail::indirect_traits<Base,Traits>::value_type
-        , typename detail::indirect_traits<Base,Traits>::reference
-        , typename detail::indirect_traits<Base,Traits>::pointer
-        , typename detail::indirect_traits<Base,Traits>::iterator_category
-        , typename detail::indirect_traits<Base,Traits>::difference_type
-      >
-{
+    friend class iterator_core_access;
+
+  public:
     indirect_iterator() {}
-    
-    typename detail::indirect_traits<Base,Traits>::reference
-    dereference() const { return **this->m_base; }
 
-    indirect_iterator(Base iter)
-        : m_base(iter) {}
+    indirect_iterator(Iterator iter)
+      : super_t(iter) {}
 
-    template <class Base2, class Traits2>
-    indirect_iterator(const indirect_iterator<Base2,Traits2>& y)
-        : m_base(y.base())
-    {}
-    
-    Base& base() { return m_base; }
-    Base const& base() const { return m_base; }
- private:
-    Base m_base;
-};
+    template <class OtherIterator,
+              class OtherTraits>
+    indirect_iterator(indirect_iterator<OtherIterator, OtherTraits> const& y,
+                      typename enable_if_convertible<OtherIterator, Iterator>::type* = 0)
+      : super_t(y.base())  {}
 
-template <class Iter>
-indirect_iterator<Iter> make_indirect_iterator(Iter x)
-{
+  private:    
+    typename super_t::reference dereference() const { return **this->base(); }
+
+  };
+
+  template <class Iter>
+  inline
+  indirect_iterator<Iter> make_indirect_iterator(Iter x)
+  {
     return indirect_iterator<Iter>(x);
-}
+  }
 
-template <class Traits, class Iter>
-indirect_iterator<Iter,Traits> make_indirect_iterator(Iter x, Traits* = 0)
-{
-    return indirect_iterator<Iter,Traits>(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