Merge pull request #9 from boostorg/develop

Merge develop into master Tested with gcc-4.2.1 on Darwin.
Merge pull request #8 from Lastique/add_docs
2025-07-25 18:37:19 +02:00 · 2014-09-06 11:18:28 -06:00 · 2014-08-23 16:14:52 -06:00 · 2014-08-24 01:55:25 +04:00 · 2014-08-23 14:08:11 -06:00 · 2014-08-23 13:53:06 -06:00
101 changed files with 1253 additions and 1100 deletions
--- a/doc/BidirectionalTraversal.rst
+++ b/doc/BidirectionalTraversal.rst
--- a/doc/ForwardTraversal.rst
+++ b/doc/ForwardTraversal.rst
--- a/doc/GNUmakefile
+++ b/doc/GNUmakefile
--- a/doc/IncrementableIterator.rst
+++ b/doc/IncrementableIterator.rst
--- a/doc/LvalueIterator.rst
+++ b/doc/LvalueIterator.rst
--- a/doc/ReadableIterator.rst
+++ b/doc/ReadableIterator.rst
--- a/doc/SinglePassIterator.rst
+++ b/doc/SinglePassIterator.rst
--- a/doc/SwappableIterator.rst
+++ b/doc/SwappableIterator.rst
--- a/doc/WritableIterator.rst
+++ b/doc/WritableIterator.rst
--- a/doc/counting_iterator.pdf
+++ b/doc/counting_iterator.pdf
--- a/doc/docutils.sty
+++ b/doc/docutils.sty
--- a/doc/facade-and-adaptor.pdf
+++ b/doc/facade-and-adaptor.pdf
--- a/doc/facade_iterator_category.rst
+++ b/doc/facade_iterator_category.rst
--- a/doc/filter_iterator.pdf
+++ b/doc/filter_iterator.pdf
--- a/doc/function_output_iterator.pdf
+++ b/doc/function_output_iterator.pdf
--- a/doc/indirect_iterator.pdf
+++ b/doc/indirect_iterator.pdf
--- a/doc/indirect_reference_ref.rst
+++ b/doc/indirect_reference_ref.rst
--- a/doc/interoperability-revisited.rst
+++ b/doc/interoperability-revisited.rst
--- a/doc/iterator_adaptor.pdf
+++ b/doc/iterator_adaptor.pdf
--- a/doc/iterator_adaptor_tutorial.rst
+++ b/doc/iterator_adaptor_tutorial.rst
--- a/doc/iterator_archetypes.html
+++ b/doc/iterator_archetypes.html
--- a/doc/iterator_archetypes.pdf
+++ b/doc/iterator_archetypes.pdf
--- a/doc/iterator_archetypes.rst
+++ b/doc/iterator_archetypes.rst
--- a/doc/iterator_concepts.pdf
+++ b/doc/iterator_concepts.pdf
--- a/doc/iterator_concepts.rst
+++ b/doc/iterator_concepts.rst
--- a/doc/iterator_facade.pdf
+++ b/doc/iterator_facade.pdf
--- a/doc/iterator_facade_tutorial.rst
+++ b/doc/iterator_facade_tutorial.rst
--- a/doc/iterator_traits.html
+++ b/doc/iterator_traits.html
@ -3,11 +3,11 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.5: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.11: http://docutils.sourceforge.net/" />
 <title>Iterator Traits</title>
 <meta name="author" content="David Abrahams" />
 <meta name="organization" content="Boost Consulting" />
-<meta name="date" content="2006-09-11" />
+<meta name="date" content="$Date$" />
 <meta name="copyright" content="Copyright David Abrahams 2004." />
 <link rel="stylesheet" href="../../../rst.css" type="text/css" />
 </head>
@ -25,7 +25,7 @@
 <tr><th class="docinfo-name">Organization:</th>
 <td><a class="first last reference external" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2006-09-11</td></tr>
+<td>$Date$</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
 <td>Copyright David Abrahams 2004.</td></tr>
 </tbody>
@ -37,7 +37,7 @@
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">abstract:</th><td class="field-body">Header <tt class="docutils literal"><span class="pre">&lt;boost/iterator/iterator_traits.hpp&gt;</span></tt> provides
+<tr class="field"><th class="field-name">abstract:</th><td class="field-body">Header <tt class="docutils literal">&lt;boost/iterator/iterator_traits.hpp&gt;</tt> provides
 the ability to access an iterator's associated types using
 MPL-compatible <a class="reference external" href="../../mpl/doc/index.html#metafunctions">metafunctions</a>.</td>
 </tr>
@ -46,15 +46,15 @@ MPL-compatible <a class="reference external" href="../../mpl/doc/index.html#meta
 <div class="section" id="overview">
 <h1>Overview</h1>
 <p><tt class="docutils literal"><span class="pre">std::iterator_traits</span></tt> provides access to five associated types
-of any iterator: its <tt class="docutils literal"><span class="pre">value_type</span></tt>, <tt class="docutils literal"><span class="pre">reference</span></tt>, <tt class="docutils literal"><span class="pre">pointer</span></tt>,
-<tt class="docutils literal"><span class="pre">iterator_category</span></tt>, and <tt class="docutils literal"><span class="pre">difference_type</span></tt>.  Unfortunately,
+of any iterator: its <tt class="docutils literal">value_type</tt>, <tt class="docutils literal">reference</tt>, <tt class="docutils literal">pointer</tt>,
+<tt class="docutils literal">iterator_category</tt>, and <tt class="docutils literal">difference_type</tt>.  Unfortunately,
 such a &quot;multi-valued&quot; traits template can be difficult to use in a
-metaprogramming context.  <tt class="docutils literal"><span class="pre">&lt;boost/iterator/iterator_traits.hpp&gt;</span></tt>
+metaprogramming context.  <tt class="docutils literal">&lt;boost/iterator/iterator_traits.hpp&gt;</tt>
 provides access to these types using a standard <a class="reference external" href="../../mpl/doc/index.html#metafunctions">metafunctions</a>.</p>
 </div>
 <div class="section" id="summary">
 <h1>Summary</h1>
-<p>Header <tt class="docutils literal"><span class="pre">&lt;boost/iterator/iterator_traits.hpp&gt;</span></tt>:</p>
+<p>Header <tt class="docutils literal">&lt;boost/iterator/iterator_traits.hpp&gt;</tt>:</p>
 <pre class="literal-block">
 template &lt;class Iterator&gt;
 struct iterator_value
@ -98,21 +98,6 @@ struct iterator_category
 };
 </pre>
 </div>
-<div class="section" id="broken-compiler-notes">
-<h1>Broken Compiler Notes</h1>
-<p>Because of workarounds in Boost, you may find that these
-<a class="reference external" href="../../mpl/doc/index.html#metafunctions">metafunctions</a> actually work better than the facilities provided by
-your compiler's standard library.</p>
-<p>On compilers that don't support partial specialization, such as
-Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
-<a class="reference external" href="../../type_traits/index.html#transformations">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</a> on the
-<tt class="docutils literal"><span class="pre">value_type</span></tt> of pointers that are passed to these metafunctions.</p>
-<p>Because of bugs in the implementation of GCC-2.9x, the name of
-<tt class="docutils literal"><span class="pre">iterator_category</span></tt> is changed to <tt class="docutils literal"><span class="pre">iterator_category_</span></tt> on that
-compiler.  A macro, <tt class="docutils literal"><span class="pre">BOOST_ITERATOR_CATEGORY</span></tt>, that expands to
-either <tt class="docutils literal"><span class="pre">iterator_category</span></tt> or <tt class="docutils literal"><span class="pre">iterator_category_</span></tt>, as
-appropriate to the platform, is provided for portability.</p>
-</div>
 </div>
 <div class="footer">
 <hr class="footer" />
--- a/doc/iterator_traits.pdf
+++ b/doc/iterator_traits.pdf
--- a/doc/iterator_traits.rst
+++ b/doc/iterator_traits.rst
@ -75,24 +75,3 @@ Header ``<boost/iterator/iterator_traits.hpp>``::
        detail::iterator_traits<Iterator>::iterator_category
      type;
  };
-
-Broken Compiler Notes
-=====================
-
-Because of workarounds in Boost, you may find that these
-metafunctions_ actually work better than the facilities provided by
-your compiler's standard library.
-
-On compilers that don't support partial specialization, such as
-Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION_ on the
-``value_type`` of pointers that are passed to these metafunctions.
-
-Because of bugs in the implementation of GCC-2.9x, the name of
-``iterator_category`` is changed to ``iterator_category_`` on that
-compiler.  A macro, ``BOOST_ITERATOR_CATEGORY``, that expands to
-either ``iterator_category`` or ``iterator_category_``, as
-appropriate to the platform, is provided for portability.
-
-.. _BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION: ../../type_traits/index.html#transformations
-
--- a/doc/make_counting_iterator.rst
+++ b/doc/make_counting_iterator.rst
--- a/doc/make_filter_iterator.rst
+++ b/doc/make_filter_iterator.rst
--- a/doc/make_transform_iterator.rst
+++ b/doc/make_transform_iterator.rst
--- a/doc/make_zip_iterator.rst
+++ b/doc/make_zip_iterator.rst
--- a/doc/new-iter-concepts.pdf
+++ b/doc/new-iter-concepts.pdf
--- a/doc/permutation_iterator.pdf
+++ b/doc/permutation_iterator.pdf
--- a/doc/pointee.html
+++ b/doc/pointee.html
--- a/doc/pointee.pdf
+++ b/doc/pointee.pdf
--- a/doc/pointee.rst
+++ b/doc/pointee.rst
--- a/doc/pointee_ref.rst
+++ b/doc/pointee_ref.rst
--- a/doc/quickbook/traits.qbk
+++ b/doc/quickbook/traits.qbk
@ -52,21 +52,4 @@ Header `<boost/iterator/iterator_traits.hpp>`:
      type;
  };

-[h2 Broken Compiler Notes]
-
-Because of workarounds in Boost, you may find that these
-[@../../mpl/doc/index.html#metafunctions metafunctions] actually work better than the facilities provided by
-your compiler's standard library.
-
-On compilers that don't support partial specialization, such as
-Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
-[@../../type_traits/index.html#transformations BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION] on the
-`value_type` of pointers that are passed to these metafunctions.
-
-Because of bugs in the implementation of GCC-2.9x, the name of
-`iterator_category` is changed to `iterator_category_` on that
-compiler.  A macro, `BOOST_ITERATOR_CATEGORY`, that expands to
-either `iterator_category` or `iterator_category_`, as
-appropriate to the platform, is provided for portability.
-
-[endsect]
+[endsect]
--- a/doc/quickbook/utilities.qbk
+++ b/doc/quickbook/utilities.qbk
@ -49,11 +49,40 @@ proxy references or return the pointee by value.  When that
 information is needed, call on `indirect_reference`.

 Both of these templates are essential to the correct functioning of
-[link indirecct `indirect_iterator`].
+[link boost_iterator.indirect `indirect_iterator`].
+
+[h2 `minimum_category`]
+
+`minimum_category` takes two iterator categories or two iterator traversal tags
+and returns the one that is the weakest (i.e. least advanced). For example:
+
+  static_assert(
+      is_same<
+          minimum_category<
+              std::forward_iterator_tag,
+              std::random_access_iterator_tag
+          >::type,
+          std::forward_iterator_tag
+      >::value,
+      "Unexpected minimum_category result"
+  );
+
+[h2 Iterator category and traversal tags manipulation]
+
+The library provides several utilities to simplify conversions between iterator categories
+and traversal tags:
+
+* `iterator_category_to_traversal<C>::type` - the metafunction takes an iterator category `C` and returns
+the corresponding traversal tag.
+* `iterator_traversal<T>::type` - a shorthand for `iterator_category_to_traversal<iterator_category<T>::type>::type`.
+* `pure_traversal_tag<T>::type` - the metafunction takes a tag `T` which derives from one of the iterator traversal tags
+and returns that traversal tag. `T` may also derive from other tags describing the iterator (e.g. whether this is a `const`-iterator
+or not), these additional tags are not considered.
+* `pure_iterator_traversal<T>::type` - a shorthand for `pure_traversal_tag<iterator_traversal<T>::type>::type`.

 [h2 Reference]

-[h3 `pointeee`]
+[h3 `pointee`]

  template <class Dereferenceable>
  struct pointee
@ -110,6 +139,77 @@ Both of these templates are essential to the correct functioning of
  else
      std::iterator_traits<Dereferenceable>::reference

+[h3 `minimum_category`]
+
+  template <typename C1, typename C2>
+  struct minimum_category
+  {
+      typedef /* see below */ type;
+  };
+
+[*Requires:] Both `C1` and `C2` shall be standard iterator categories or
+  iterator traversal tags.
+
+`type` is determined according to the following algorithm, where `c1` is an
+object of type `C1` and `c2` is an object of type `C2`:
+
+  if (c1 is convertible to c2)
+      return C2;
+  else
+      return C1;
+
+[note The above definition relies on the fact that the more restricting categories
+and traversal tags are convertible to the less restricting ones.]
+
+[h3 `iterator_category_to_traversal`]
+
+  template <typename C>
+  struct iterator_category_to_traversal
+  {
+      typedef /* see below */ type;
+  };
+
+[*Requires:] `C` shall be a standard iterator category or an
+  iterator traversal tag.
+
+If `C` is an iterator traversal tag or convertible to one, `type` equivalent to `C`.
+Otherwise, `type` is defined to the closest iterator traversal tag matching `C`.
+
+[h3 `iterator_traversal`]
+
+  template <typename Iterator>
+  struct iterator_traversal
+  {
+      typedef typename iterator_category_to_traversal<
+          typename iterator_category<Iterator>::type
+      >::type type;
+  };
+
+[*Requires:] `Iterator` shall be an iterator.
+
+[h3 `pure_traversal_tag`]
+
+  template <typename T>
+  struct pure_traversal_tag
+  {
+      typedef /* see below */ type;
+  };
+
+[*Requires:] `T` shall be convertible to an iterator traversal tag.
+
+`type` is defined to be the most advanced traversal tag `Tag` so that `T` is convertible to `Tag`.
+
+[h3 `pure_iterator_traversal`]
+
+  template <typename Iterator>
+  struct pure_iterator_traversal
+  {
+      typedef typename pure_traversal_tag<
+          typename iterator_traversal<Iterator>::type
+      >::type type;
+  };
+
+[*Requires:] `Iterator` shall be an iterator.

 [endsect]

@ -221,4 +321,4 @@ Iterator Traversal Concepts

 [endsect]

-[endsect]
+[endsect]
--- a/doc/reverse_iterator.pdf
+++ b/doc/reverse_iterator.pdf
--- a/doc/transform_iterator.pdf
+++ b/doc/transform_iterator.pdf
--- a/doc/transform_iterator_eg.rst
+++ b/doc/transform_iterator_eg.rst
--- a/doc/zip_iterator.html
+++ b/doc/zip_iterator.html
--- a/doc/zip_iterator.pdf
+++ b/doc/zip_iterator.pdf
--- a/doc/zip_iterator.rst
+++ b/doc/zip_iterator.rst
--- a/doc/zip_iterator_abstract.rst
+++ b/doc/zip_iterator_abstract.rst
--- a/doc/zip_iterator_eg.rst
+++ b/doc/zip_iterator_eg.rst
--- a/doc/zip_iterator_ref.rst
+++ b/doc/zip_iterator_ref.rst
--- a/example/node.hpp
+++ b/example/node.hpp
--- a/example/node_iterator1.cpp
+++ b/example/node_iterator1.cpp
--- a/example/node_iterator1.hpp
+++ b/example/node_iterator1.hpp
--- a/example/node_iterator2.cpp
+++ b/example/node_iterator2.cpp
--- a/example/node_iterator2.hpp
+++ b/example/node_iterator2.hpp
--- a/example/node_iterator3.cpp
+++ b/example/node_iterator3.cpp
--- a/example/node_iterator3.hpp
+++ b/example/node_iterator3.hpp
--- a/include/boost/function_output_iterator.hpp
+++ b/include/boost/function_output_iterator.hpp
@ -14,6 +14,7 @@
 #include <iterator>

 namespace boost {
+namespace iterators {

  template <class UnaryFunction>
  class function_output_iterator {
@ -33,13 +34,13 @@ namespace boost {
    struct output_proxy {
      output_proxy(UnaryFunction& f) : m_f(f) { }
      template <class T> output_proxy& operator=(const T& value) {
-        m_f(value); 
-        return *this; 
+        m_f(value);
+        return *this;
      }
      UnaryFunction& m_f;
    };
    output_proxy operator*() { return output_proxy(m_f); }
-    self& operator++() { return *this; } 
+    self& operator++() { return *this; }
    self& operator++(int) { return *this; }
  private:
    UnaryFunction m_f;
@ -51,6 +52,11 @@ namespace boost {
    return function_output_iterator<UnaryFunction>(f);
  }

+} // namespace iterators
+
+using iterators::function_output_iterator;
+using iterators::make_function_output_iterator;
+
 } // namespace boost

 #endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
--- a/include/boost/generator_iterator.hpp
+++ b/include/boost/generator_iterator.hpp
@ -17,6 +17,7 @@
 #include <boost/ref.hpp>

 namespace boost {
+namespace iterators {

 template<class Generator>
 class generator_iterator
@ -33,7 +34,7 @@ class generator_iterator
      , single_pass_traversal_tag
      , typename Generator::result_type const&
    > super_t;
-    
+
 public:
    generator_iterator() {}
    generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}
@ -73,8 +74,12 @@ make_generator_iterator(Generator & gen)
  return result_t(&gen);
 }

+} // namespace iterators
+
+using iterators::generator_iterator;
+using iterators::generator_iterator_generator;
+using iterators::make_generator_iterator;
+
 } // namespace boost

-
 #endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
-
--- a/include/boost/indirect_reference.hpp
+++ b/include/boost/indirect_reference.hpp
@ -17,7 +17,7 @@
 # include <boost/mpl/eval_if.hpp>
 # include <boost/pointee.hpp>

-namespace boost { 
+namespace boost {

 namespace detail
 {
@ -37,7 +37,7 @@ struct indirect_reference
    >
 {
 };
-  
+
 } // namespace boost

 #endif // INDIRECT_REFERENCE_DWA200415_HPP
--- a/include/boost/iterator/counting_iterator.hpp
+++ b/include/boost/iterator/counting_iterator.hpp
@ -13,6 +13,7 @@
 # include <boost/mpl/eval_if.hpp>

 namespace boost {
+namespace iterators {

 template <
    class Incrementable
@ -30,13 +31,13 @@ namespace detail
  {
      // For a while, this wasn't true, but we rely on it below. This is a regression assert.
      BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
-      
+
 # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-      
+
      BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
-      
+
 # else
-      
+
 #  if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
      BOOST_STATIC_CONSTANT(
          bool, value = (
@ -46,20 +47,20 @@ namespace detail
 #  else
    BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
 #  endif
-      
+
 # endif
  };

  template <class T>
  struct is_numeric
-    : mpl::bool_<(::boost::detail::is_numeric_impl<T>::value)>
+    : mpl::bool_<(::boost::iterators::detail::is_numeric_impl<T>::value)>
  {};

 #  if defined(BOOST_HAS_LONG_LONG)
  template <>
  struct is_numeric< ::boost::long_long_type>
    : mpl::true_ {};
-  
+
  template <>
  struct is_numeric< ::boost::ulong_long_type>
    : mpl::true_ {};
@ -69,7 +70,7 @@ namespace detail
  template <>
  struct is_numeric<wchar_t>
    : mpl::true_ {};
-  
+
  template <class T>
  struct numeric_difference
  {
@ -77,7 +78,7 @@ namespace detail
  };

  BOOST_STATIC_ASSERT(is_numeric<int>::value);
-  
+
  template <class Incrementable, class CategoryOrTraversal, class Difference>
  struct counting_iterator_base
  {
@ -89,7 +90,7 @@ namespace detail
            , iterator_traversal<Incrementable>
          >
      >::type traversal;
-      
+
      typedef typename detail::ia_dflt_help<
          Difference
        , mpl::eval_if<
@ -98,7 +99,7 @@ namespace detail
            , iterator_difference<Incrementable>
          >
      >::type difference;
-      
+
      typedef iterator_adaptor<
          counting_iterator<Incrementable, CategoryOrTraversal, Difference> // self
        , Incrementable                                           // Base
@ -106,7 +107,7 @@ namespace detail
 # ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
          const  // MSVC won't strip this.  Instead we enable Thomas'
                 // criterion (see boost/iterator/detail/facade_iterator_category.hpp)
-# endif 
+# endif
        , traversal
        , Incrementable const&                                    // reference
        , difference
@ -136,7 +137,7 @@ namespace detail
  {
      static Difference distance(Incrementable1 x, Incrementable2 y)
      {
-          return numeric_distance(x, y);
+          return boost::detail::numeric_distance(x, y);
      }
  };
 }
@ -154,14 +155,14 @@ class counting_iterator
    typedef typename detail::counting_iterator_base<
        Incrementable, CategoryOrTraversal, Difference
    >::type super_t;
-    
+
    friend class iterator_core_access;

 public:
    typedef typename super_t::difference_type difference_type;

    counting_iterator() { }
-    
+
    counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {}

    counting_iterator(Incrementable x)
@ -177,10 +178,10 @@ class counting_iterator
    )
      : super_t(t.base())
    {}
-# endif 
+# endif

 private:
-    
+
    typename super_t::reference dereference() const
    {
        return this->base_reference();
@ -209,7 +210,11 @@ make_counting_iterator(Incrementable x)
  return result_t(x);
 }

+} // namespace iterators

-} // namespace boost::iterator
+using iterators::counting_iterator;
+using iterators::make_counting_iterator;
+
+} // namespace boost

 #endif // COUNTING_ITERATOR_DWA200348_HPP
--- a/include/boost/iterator/detail/any_conversion_eater.hpp
+++ b/include/boost/iterator/detail/any_conversion_eater.hpp
@ -4,7 +4,9 @@
 #ifndef ANY_CONVERSION_EATER_DWA20031117_HPP
 # define ANY_CONVERSION_EATER_DWA20031117_HPP

-namespace boost { namespace detail {
+namespace boost {
+namespace iterators {
+namespace detail {

 // This type can be used in traits to "eat" up the one user-defined
 // implicit conversion allowed.
@ -14,6 +16,6 @@ struct any_conversion_eater
    any_conversion_eater(T const&);
 };

-}} // namespace boost::detail
+}}} // namespace boost::iterators::detail

 #endif // ANY_CONVERSION_EATER_DWA20031117_HPP
--- a/include/boost/iterator/detail/config_def.hpp
+++ b/include/boost/iterator/detail/config_def.hpp
@ -46,8 +46,7 @@

 #endif

-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                       \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                   \
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                      \
    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
@ -88,8 +87,7 @@
 #  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
 #endif

-#if BOOST_WORKAROUND(__GNUC__, == 2)                                                                            \
-    || BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
+#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 #  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:

@ -116,16 +114,9 @@
 # define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #endif 

-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-#  define BOOST_ARG_DEPENDENT_TYPENAME typename
-# else
-#  define BOOST_ARG_DEPENDENT_TYPENAME
-# endif
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

-# if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
-// GCC-2.95 eagerly instantiates templated constructors and conversion
+// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
 // operators in convertibility checks, causing premature errors.
 //
 // Borland's problems are harder to diagnose due to lack of an
--- a/include/boost/iterator/detail/config_undef.hpp
+++ b/include/boost/iterator/detail/config_undef.hpp
@ -14,7 +14,6 @@
 #undef BOOST_NO_IS_CONVERTIBLE
 #undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
 #undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#undef BOOST_ARG_DEPENDENT_TYPENAME
 #undef BOOST_NO_LVALUE_RETURN_DETECTION
 #undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP

--- a/include/boost/iterator/detail/enable_if.hpp
+++ b/include/boost/iterator/detail/enable_if.hpp
@ -35,7 +35,7 @@ namespace boost
        typedef T type;
      };
    };
-    
+
    //
    // For compilers that don't support "Substitution Failure Is Not An Error"
    // enable_if falls back to always enabled. See comments
@ -70,11 +70,8 @@ namespace boost
      : enabled<(Cond::value)>::template base<Return>
 # else
      : mpl::identity<Return>
-# endif 
+# endif
    {
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        typedef Return type;
-# endif 
    };

  } // namespace iterators
--- a/include/boost/iterator/detail/facade_iterator_category.hpp
+++ b/include/boost/iterator/detail/facade_iterator_category.hpp
@ -30,10 +30,13 @@
 // iterator_category deduction for iterator_facade
 //

-// forward declaration
-namespace boost { struct use_default; }
+namespace boost {
+namespace iterators {

-namespace boost { namespace detail  {
+// forward declaration
+struct use_default;
+
+namespace detail {

 struct input_output_iterator_tag
  : std::input_iterator_tag
@ -63,9 +66,9 @@ struct iterator_writability_disabled
      , boost::detail::indirect_traits::is_reference_to_const<Reference>
      , is_const<ValueParam>
    >
-# else 
+# else
  : is_const<ValueParam>
-# endif 
+# endif
 {};


@ -96,7 +99,7 @@ struct iterator_facade_default_category
      , typename mpl::eval_if<
            mpl::and_<
                is_convertible<Traversal, single_pass_traversal_tag>
-                
+
                // check for readability
              , is_convertible<Reference, ValueParam>
            >
@ -132,7 +135,6 @@ template <class Category, class Traversal>
 struct iterator_category_with_traversal
  : Category, Traversal
 {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
    // Make sure this isn't used to build any categories where
    // convertibility to Traversal is redundant.  Should just use the
    // Category element in that case.
@ -147,8 +149,7 @@ struct iterator_category_with_traversal
    BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
 #  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
    BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
-#  endif 
-# endif 
+#  endif
 };

 // Computes an iterator_category tag whose traversal is Traversal and
@ -156,14 +157,12 @@ struct iterator_category_with_traversal
 template <class Traversal, class ValueParam, class Reference>
 struct facade_iterator_category_impl
 {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
-# endif 
-    
+
    typedef typename iterator_facade_default_category<
        Traversal,ValueParam,Reference
    >::type category;
-    
+
    typedef typename mpl::if_<
        is_same<
            Traversal
@ -187,7 +186,7 @@ struct facade_iterator_category
 {
 };

-}} // namespace boost::detail
+}}} // namespace boost::iterators::detail

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

--- a/include/boost/iterator/detail/minimum_category.hpp
+++ b/include/boost/iterator/detail/minimum_category.hpp
@ -4,113 +4,16 @@
 #ifndef MINIMUM_CATEGORY_DWA20031119_HPP
 # define MINIMUM_CATEGORY_DWA20031119_HPP

-# include <boost/type_traits/is_convertible.hpp>
-# include <boost/type_traits/is_same.hpp>
+# include <boost/iterator/minimum_category.hpp>

-# include <boost/mpl/aux_/lambda_support.hpp>
+namespace boost {

-namespace boost { namespace detail { 
-//
-// Returns the minimum category type or error_type
-// if T1 and T2 are unrelated.
-//
-// For compilers not supporting is_convertible this only
-// works with the new boost return and traversal category
-// types. The exact boost _types_ are required. No derived types
-// will work. 
-//
-//
-template <bool GreaterEqual, bool LessEqual>
-struct minimum_category_impl
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-{
-    template <class T1, class T2> struct apply
-    {
-        typedef T2 type;
-    };
-    typedef void type;
-}
-# endif 
-;
+// This import below (as well as the whole header) is for backward compatibility
+// with boost/token_iterator.hpp. It should be removed as soon as that header is fixed.
+namespace detail {
+using iterators::minimum_category;
+} // namespace detail

-template <class T1, class T2>
-struct error_not_related_by_convertibility;
-  
-template <>
-struct minimum_category_impl<true,false>
-{
-    template <class T1, class T2> struct apply
-    {
-        typedef T2 type;
-    };
-};
-
-template <>
-struct minimum_category_impl<false,true>
-{
-    template <class T1, class T2> struct apply
-    {
-        typedef T1 type;
-    };
-};
-
-template <>
-struct minimum_category_impl<true,true>
-{
-    template <class T1, class T2> struct apply
-    {
-        BOOST_STATIC_ASSERT((is_same<T1,T2>::value));
-        typedef T1 type;
-    };
-};
-
-template <>
-struct minimum_category_impl<false,false>
-{
-    template <class T1, class T2> struct apply
-    : error_not_related_by_convertibility<T1,T2>
-    {
-    };
-};
-
-template <class T1 = mpl::_1, class T2 = mpl::_2>
-struct minimum_category
-{
-    typedef minimum_category_impl< 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-        is_same<T2,int>::value ||
-# endif 
-        ::boost::is_convertible<T1,T2>::value
-      , ::boost::is_convertible<T2,T1>::value
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-        || is_same<T1,int>::value
-# endif 
-    > outer;
-
-    typedef typename outer::template apply<T1,T2> inner;
-    typedef typename inner::type type;
-      
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(2,minimum_category,(T1,T2))
-};
-    
-template <>
-struct minimum_category<mpl::_1,mpl::_2>
-{
-    template <class T1, class T2>
-    struct apply : minimum_category<T1,T2>
-    {};
-
-    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2))
-};
-
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-template <>
-struct minimum_category<int,int>
-{
-    typedef int type;
-};
-# endif
-    
-}} // namespace boost::detail
+} // namespace boost

 #endif // MINIMUM_CATEGORY_DWA20031119_HPP
--- a/include/boost/iterator/detail/operator_brackets_dispatch.hpp
+++ b/include/boost/iterator/detail/operator_brackets_dispatch.hpp
@ -1,88 +0,0 @@
-// (C) Copyright David Abrahams 2002.
-// (C) Copyright Jeremy Siek    2002.
-// (C) Copyright Thomas Witt    2002.
-// (C) Copyright Jeffrey Lee Hellrung, Jr. 2012.
-// 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_OPERATOR_BRACKETS_DISPATCH_07102012JLH_HPP
-#define BOOST_OPERATOR_BRACKETS_DISPATCH_07102012JLH_HPP
-
-#include <boost/iterator/detail/facade_iterator_category.hpp>
-
-#include <boost/type_traits/is_pod.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-#include <boost/mpl/if.hpp>
-
-namespace boost { namespace detail {
-
-// operator[] must return a proxy in case iterator destruction invalidates
-// referents.
-// To see why, consider the following implementation of operator[]:
-//   reference operator[](difference_type n) const
-//   { return *(*this + n); }
-// The problem here is that operator[] would return a reference created from
-// a temporary iterator.
-
-template <class Value>
-struct operator_brackets_value
-{
-    typedef Value result_type;
-    template <class Iterator>
-    static result_type apply(Iterator const & i)
-    { return *i; }
-};
-
-template <class Iterator, class Reference>
-struct operator_brackets_const_proxy
-{
-    class result_type
-    {
-        Iterator const m_i;
-        explicit result_type(Iterator const & i) : m_i(i) { }
-        friend struct operator_brackets_const_proxy;
-        void operator=(result_type&);
-    public:
-        operator Reference() const { return *m_i; }
-    };
-    static result_type apply(Iterator const & i)
-    { return result_type(i); }
-};
-
-template <class Iterator, class Reference>
-struct operator_brackets_proxy
-{
-    class result_type
-    {
-        Iterator const m_i;
-        explicit result_type(Iterator const & i) : m_i(i) { }
-        friend struct operator_brackets_proxy;
-        void operator=(result_type&);
-    public:
-        operator Reference() const { return *m_i; }
-        operator_brackets_proxy const & operator=(
-          typename Iterator::value_type const & x) const
-        { *m_i = x; return *this; }
-    };
-    static result_type apply(Iterator const & i)
-    { return result_type(i); }
-};
-
-template <class Iterator, class ValueType, class Reference>
-struct operator_brackets_dispatch
-{
-    typedef typename mpl::if_c<
-        iterator_writability_disabled<ValueType,Reference>::value,
-        typename mpl::if_c<
-            boost::is_POD<ValueType>::value,
-            operator_brackets_value<typename boost::remove_const<ValueType>::type>,
-            operator_brackets_const_proxy<Iterator,Reference>
-        >::type,
-        operator_brackets_proxy<Iterator,Reference>
-    >::type type;
-};
-
-} } // namespace detail / namespace boost
-
-#endif // #ifndef BOOST_OPERATOR_BRACKETS_DISPATCH_07102012JLH_HPP
--- a/include/boost/iterator/filter_iterator.hpp
+++ b/include/boost/iterator/filter_iterator.hpp
@ -14,8 +14,9 @@
 #include <boost/type_traits/is_class.hpp>
 #include <boost/static_assert.hpp>

-namespace boost
-{
+namespace boost {
+namespace iterators {
+
  template <class Predicate, class Iterator>
  class filter_iterator;

@ -39,7 +40,7 @@ namespace boost
        > type;
    };
  }
-  
+
  template <class Predicate, class Iterator>
  class filter_iterator
    : public detail::filter_iterator_base<Predicate, Iterator>::type
@ -68,7 +69,7 @@ namespace boost
          // Don't allow use of this constructor if Predicate is a
          // function pointer type, since it will be 0.
          BOOST_STATIC_ASSERT(is_class<Predicate>::value);
-#endif 
+#endif
          satisfy_predicate();
      }

@ -108,28 +109,29 @@ namespace boost
  };

  template <class Predicate, class Iterator>
-  filter_iterator<Predicate,Iterator>
+  inline filter_iterator<Predicate,Iterator>
  make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
  {
      return filter_iterator<Predicate,Iterator>(f,x,end);
  }

  template <class Predicate, class Iterator>
-  filter_iterator<Predicate,Iterator>
+  inline filter_iterator<Predicate,Iterator>
  make_filter_iterator(
      typename iterators::enable_if<
          is_class<Predicate>
        , Iterator
      >::type x
-    , Iterator end = Iterator()
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    , Predicate* = 0
-#endif 
-  )
+    , Iterator end = Iterator())
  {
      return filter_iterator<Predicate,Iterator>(x,end);
  }

+} // namespace iterators
+
+using iterators::filter_iterator;
+using iterators::make_filter_iterator;
+
 } // namespace boost

 #endif // BOOST_FILTER_ITERATOR_23022003THW_HPP
--- a/include/boost/iterator/function_input_iterator.hpp
+++ b/include/boost/iterator/function_input_iterator.hpp
@ -20,6 +20,8 @@

 namespace boost {

+namespace iterators {
+
    namespace impl {

        template <class Function, class Input>
@ -33,7 +35,7 @@ namespace boost {
        {
        public:
            function_input_iterator() {}
-            function_input_iterator(Function & f_, Input state_ = Input()) 
+            function_input_iterator(Function & f_, Input state_ = Input())
                : f(&f_), state(state_) {}

            void increment() {
@ -44,7 +46,7 @@ namespace boost {
                ++state;
            }

-            typename Function::result_type const & 
+            typename Function::result_type const &
                dereference() const {
                    return (value ? value : value = (*f)()).get();
            }
@ -109,7 +111,7 @@ namespace boost {
    } // namespace impl

    template <class Function, class Input>
-    class function_input_iterator 
+    class function_input_iterator
        : public mpl::if_<
            function_types::is_function_pointer<Function>,
            impl::function_pointer_input_iterator<Function,Input>,
@ -154,7 +156,14 @@ namespace boost {
        bool operator==(infinite &) const { return false; };
        bool operator==(infinite const &) const { return false; };
    };
-}
+
+} // namespace iterators
+
+using iterators::function_input_iterator;
+using iterators::make_function_input_iterator;
+using iterators::infinite;
+
+} // namespace boost

 #endif

--- a/include/boost/iterator/indirect_iterator.hpp
+++ b/include/boost/iterator/indirect_iterator.hpp
@ -30,12 +30,13 @@
 # include <boost/scoped_ptr.hpp>
 # include <boost/mpl/bool.hpp>
 # include <memory>
-#endif 
+#endif

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

-namespace boost
-{
+namespace boost {
+namespace iterators {
+
  template <class Iter, class Value, class Category, class Reference, class Difference>
  class indirect_iterator;

@ -44,8 +45,8 @@ namespace boost
    template <class Iter, class Value, class Category, class Reference, class Difference>
    struct indirect_base
    {
-        typedef typename iterator_traits<Iter>::value_type dereferenceable;
-        
+        typedef typename boost::detail::iterator_traits<Iter>::value_type dereferenceable;
+
        typedef iterator_adaptor<
            indirect_iterator<Iter, Value, Category, Reference, Difference>
          , Iter
@ -69,7 +70,7 @@ namespace boost
    struct indirect_base<int, int, int, int, int> {};
  } // namespace detail

-    
+
  template <
      class Iterator
    , class Value = use_default
@ -107,14 +108,14 @@ namespace boost
        : super_t(y.base())
      {}

-  private:    
+  private:
      typename super_t::reference dereference() const
      {
 # if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
          return const_cast<super_t::reference>(**this->base());
 # else
          return **this->base();
-# endif 
+# endif
      }
  };

@ -132,6 +133,11 @@ namespace boost
    return indirect_iterator<Iter, Traits>(x);
  }

+} // namespace iterators
+
+using iterators::indirect_iterator;
+using iterators::make_indirect_iterator;
+
 } // namespace boost

 #include <boost/iterator/detail/config_undef.hpp>
--- a/include/boost/iterator/interoperable.hpp
+++ b/include/boost/iterator/interoperable.hpp
@ -14,8 +14,8 @@

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

-namespace boost
-{
+namespace boost {
+namespace iterators {

  //
  // Meta function that determines whether two
@ -27,7 +27,7 @@ namespace boost
  // standards requirements on constant/mutable container
  // iterators (23.1 [lib.container.requirements]).
  //
-  // For compilers that don't support is_convertible 
+  // For compilers that don't support is_convertible
  // is_interoperable gives false positives. See comments
  // on operator implementation for consequences.
  //
@ -40,9 +40,13 @@ namespace boost
          is_convertible< A, B >
        , is_convertible< B, A > >
 # endif
-  { 
+  {
  };

+} // namespace iterators
+
+using iterators::is_interoperable;
+
 } // namespace boost

 # include <boost/iterator/detail/config_undef.hpp>
--- a/include/boost/iterator/is_lvalue_iterator.hpp
+++ b/include/boost/iterator/is_lvalue_iterator.hpp
@ -18,7 +18,9 @@
 #ifndef BOOST_NO_IS_CONVERTIBLE

 namespace boost {
- 
+
+namespace iterators {
+
 namespace detail
 {
 #ifndef BOOST_NO_LVALUE_RETURN_DETECTION
@ -26,20 +28,20 @@ namespace detail
  // to the expression's result if <expression> is an lvalue, or
  // not_an_lvalue() otherwise.
  struct not_an_lvalue {};
-  
+
  template <class T>
  T& lvalue_preserver(T&, int);
-  
+
  template <class U>
  not_an_lvalue lvalue_preserver(U const&, ...);
-  
+
 # define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0)
-  
+
 #else
-  
+
 # define BOOST_LVALUE_PRESERVER(expr) expr
-  
-#endif 
+
+#endif

  // Guts of is_lvalue_iterator.  Value is the iterator's value_type
  // and the result is computed in the nested rebind template.
@ -55,12 +57,12 @@ namespace detail

      static char tester(conversion_eater, int);
      static char (& tester(any_conversion_eater, ...) )[2];
-    
+
      template <class It>
      struct rebind
      {
          static It& x;
-          
+
          BOOST_STATIC_CONSTANT(
              bool
            , value = (
@ -75,7 +77,7 @@ namespace detail
  };

 #undef BOOST_LVALUE_PRESERVER
-  
+
  //
  // void specializations to handle std input and output iterators
  //
@ -135,11 +137,16 @@ namespace detail
 // Define the trait with full mpl lambda capability and various broken
 // compiler workarounds
 BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_lvalue_iterator,T,::boost::detail::is_readable_lvalue_iterator_impl<T>::value)
-    
+    is_lvalue_iterator,T,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value)
+
 BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_non_const_lvalue_iterator,T,::boost::detail::is_non_const_lvalue_iterator_impl<T>::value)
-    
+    is_non_const_lvalue_iterator,T,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value)
+
+} // namespace iterators
+
+using iterators::is_lvalue_iterator;
+using iterators::is_non_const_lvalue_iterator;
+
 } // namespace boost

 #endif
--- a/include/boost/iterator/is_readable_iterator.hpp
+++ b/include/boost/iterator/is_readable_iterator.hpp
@ -16,7 +16,9 @@
 #ifndef BOOST_NO_IS_CONVERTIBLE

 namespace boost {
- 
+
+namespace iterators {
+
 namespace detail
 {
  // Guts of is_readable_iterator.  Value is the iterator's value_type
@ -26,12 +28,12 @@ namespace detail
  {
      static char tester(Value&, int);
      static char (& tester(any_conversion_eater, ...) )[2];
-    
+
      template <class It>
      struct rebind
      {
          static It& x;
-          
+
          BOOST_STATIC_CONSTANT(
              bool
            , value = (
@ -44,7 +46,7 @@ namespace detail
  };

 #undef BOOST_READABLE_PRESERVER
-  
+
  //
  // void specializations to handle std input and output iterators
  //
@ -97,8 +99,12 @@ namespace detail
 // Define the trait with full mpl lambda capability and various broken
 // compiler workarounds
 BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_readable_iterator,T,::boost::detail::is_readable_iterator_impl2<T>::value)
-    
+    is_readable_iterator,T,::boost::iterators::detail::is_readable_iterator_impl2<T>::value)
+
+} // namespace iterators
+
+using iterators::is_readable_iterator;
+
 } // namespace boost

 #endif
--- a/include/boost/iterator/iterator_adaptor.hpp
+++ b/include/boost/iterator/iterator_adaptor.hpp
@ -31,28 +31,33 @@

 #include <boost/iterator/iterator_traits.hpp>

-namespace boost
-{
+namespace boost {
+namespace iterators {
+
  // Used as a default template argument internally, merely to
  // indicate "use the default", this can also be passed by users
  // explicitly in order to specify that the default should be used.
  struct use_default;
-  
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  // the incompleteness of use_default causes massive problems for
-  // is_convertible (naturally).  This workaround is fortunately not
-  // needed for vc6/vc7.
-  template<class To>
-  struct is_convertible<use_default,To>
-    : mpl::false_ {};
-# endif 
-  
+
+} // namespace iterators
+
+using iterators::use_default;
+
+// the incompleteness of use_default causes massive problems for
+// is_convertible (naturally).  This workaround is fortunately not
+// needed for vc6/vc7.
+template<class To>
+struct is_convertible<use_default,To>
+  : mpl::false_ {};
+
+namespace iterators {
+
  namespace detail
  {

-    // 
+    //
    // Result type used in enable_if_convertible meta function.
-    // This can be an incomplete type, as only pointers to 
+    // This can be an incomplete type, as only pointers to
    // enable_if_convertible< ... >::type are used.
    // We could have used void for this, but conversion to
    // void* is just to easy.
@ -73,7 +78,7 @@ namespace boost
  //   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
  // {
  // public:
-  //   
+  //
  //   ...
  //
  //   template <class OtherIterator>
@ -92,38 +97,23 @@ namespace boost
  // and not at the actual instantiation.
  //
  // enable_if_interoperable can be safely used in user code. It falls back to
-  // always enabled for compilers that don't support enable_if or is_convertible. 
-  // There is no need for compiler specific workarounds in user code. 
+  // always enabled for compilers that don't support enable_if or is_convertible.
+  // There is no need for compiler specific workarounds in user code.
  //
  // The operators implementation relies on boost::is_convertible not returning
  // false positives for user/library defined iterator types. See comments
  // on operator implementation for consequences.
  //
-#  if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-  
-  template<typename From, typename To>
-  struct enable_if_convertible
-  {
-     typedef typename mpl::if_<
-         mpl::or_<
-             is_same<From,To>
-           , is_convertible<From, To>
-         >
-      , boost::detail::enable_type
-      , int&
-     >::type type;
-  };
-  
-#  elif defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
-  
+#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
+
  template <class From, class To>
  struct enable_if_convertible
  {
-      typedef boost::detail::enable_type type;
+      typedef boost::iterators::detail::enable_type type;
  };
-  
-#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC > 1300
-  
+
+#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))
+
  // For some reason vc7.1 needs us to "cut off" instantiation
  // of is_convertible in a few cases.
  template<typename From, typename To>
@ -133,22 +123,22 @@ namespace boost
            is_same<From,To>
          , is_convertible<From, To>
        >
-      , boost::detail::enable_type
+      , boost::iterators::detail::enable_type
    >
  {};
-  
-#  else 
-  
+
+#  else
+
  template<typename From, typename To>
  struct enable_if_convertible
    : iterators::enable_if<
          is_convertible<From, To>
-        , boost::detail::enable_type
+        , boost::iterators::detail::enable_type
      >
  {};
-      
+
 # endif
-  
+
  //
  // Default template argument handling for iterator_adaptor
  //
@ -180,9 +170,9 @@ namespace boost
    {
        typedef iterator_facade<
            Derived
-            
+
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-          , typename boost::detail::ia_dflt_help<
+          , typename boost::iterators::detail::ia_dflt_help<
                Value
              , mpl::eval_if<
                    is_same<Reference,use_default>
@ -191,17 +181,17 @@ namespace boost
                >
            >::type
 # else
-          , typename boost::detail::ia_dflt_help<
+          , typename boost::iterators::detail::ia_dflt_help<
                Value, iterator_value<Base>
            >::type
 # endif
-            
-          , typename boost::detail::ia_dflt_help<
+
+          , typename boost::iterators::detail::ia_dflt_help<
                Traversal
              , iterator_traversal<Base>
            >::type

-          , typename boost::detail::ia_dflt_help<
+          , typename boost::iterators::detail::ia_dflt_help<
                Reference
              , mpl::eval_if<
                    is_same<Value,use_default>
@ -210,13 +200,13 @@ namespace boost
                >
            >::type

-          , typename boost::detail::ia_dflt_help<
+          , typename boost::iterators::detail::ia_dflt_help<
                Difference, iterator_difference<Base>
            >::type
        >
        type;
    };
-  
+
    // workaround for aC++ CR JAGaf33512
    template <class Tr1, class Tr2>
    inline void iterator_adaptor_assert_traversal ()
@ -224,7 +214,7 @@ namespace boost
      BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
    }
  }
-  
+
  //
  // Iterator Adaptor
  //
@ -259,14 +249,14 @@ namespace boost
    , class Difference   = use_default
  >
  class iterator_adaptor
-    : public boost::detail::iterator_adaptor_base<
+    : public boost::iterators::detail::iterator_adaptor_base<
        Derived, Base, Value, Traversal, Reference, Difference
      >::type
  {
      friend class iterator_core_access;

   protected:
-      typedef typename boost::detail::iterator_adaptor_base<
+      typedef typename boost::iterators::detail::iterator_adaptor_base<
          Derived, Base, Value, Traversal, Reference, Difference
      >::type super_t;
   public:
@ -285,7 +275,7 @@ namespace boost
   protected:
      // for convenience in derived classes
      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
-      
+
      //
      // lvalue access to the Base object for Derived
      //
@ -301,13 +291,13 @@ namespace boost
      // to prevent temptation for Derived classes to use it, which
      // will often result in an error.  Derived classes should use
      // base_reference(), above, to get direct access to m_iterator.
-      // 
+      //
      typename super_t::reference dereference() const
        { return *m_iterator; }

      template <
      class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
+      >
      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
      {
        // Maybe readd with same_distance
@ -322,17 +312,17 @@ namespace boost
      >::type my_traversal;

 # define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
-      boost::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
+      boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();

      void advance(typename super_t::difference_type n)
      {
          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
          m_iterator += n;
      }
-  
+
      void increment() { ++m_iterator; }

-      void decrement() 
+      void decrement()
      {
          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)
           --m_iterator;
@ -340,7 +330,7 @@ namespace boost

      template <
          class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
+      >
      typename super_t::difference_type distance_to(
          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
      {
@ -353,11 +343,16 @@ namespace boost
      }

 # undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL
-      
+
   private: // data members
      Base m_iterator;
  };

+} // namespace iterators
+
+using iterators::iterator_adaptor;
+using iterators::enable_if_convertible;
+
 } // namespace boost

 #include <boost/iterator/detail/config_undef.hpp>
--- a/include/boost/iterator/iterator_archetypes.hpp
+++ b/include/boost/iterator/iterator_archetypes.hpp
@ -20,7 +20,6 @@

 #include <boost/concept_archetype.hpp>

-#include <boost/mpl/aux_/msvc_eti_base.hpp>
 #include <boost/mpl/bitand.hpp>
 #include <boost/mpl/int.hpp>
 #include <boost/mpl/equal_to.hpp>
@ -32,6 +31,7 @@
 #include <cstddef>

 namespace boost {
+namespace iterators {

 template <class Value, class AccessCategory>
 struct access_archetype;
@ -39,7 +39,7 @@ struct access_archetype;
 template <class Derived, class Value, class AccessCategory, class TraversalCategory>
 struct traversal_archetype;

-namespace iterator_archetypes
+namespace archetypes
 {
  enum {
      readable_iterator_bit = 1
@ -51,19 +51,19 @@ namespace iterator_archetypes
  // Not quite tags, since dispatching wouldn't work.
  typedef mpl::int_<readable_iterator_bit>::type readable_iterator_t;
  typedef mpl::int_<writable_iterator_bit>::type writable_iterator_t;
-  
+
  typedef mpl::int_<
      (readable_iterator_bit|writable_iterator_bit)
          >::type readable_writable_iterator_t;
-  
+
  typedef mpl::int_<
      (readable_iterator_bit|lvalue_iterator_bit)
          >::type readable_lvalue_iterator_t;
-  
+
  typedef mpl::int_<
      (lvalue_iterator_bit|writable_iterator_bit)
          >::type writable_lvalue_iterator_t;
-  
+
  typedef mpl::int_<swappable_iterator_bit>::type swappable_iterator_t;
  typedef mpl::int_<lvalue_iterator_bit>::type lvalue_iterator_t;

@ -119,29 +119,27 @@ namespace detail

  template <class Value, class AccessCategory, class TraversalCategory>
  struct operator_brackets
-    : mpl::aux::msvc_eti_base<
-          typename mpl::eval_if<
-              is_convertible<TraversalCategory, random_access_traversal_tag>
-            , mpl::eval_if<
-                  iterator_archetypes::has_access<
-                      AccessCategory
-                    , iterator_archetypes::writable_iterator_t
-                  >
-                , mpl::identity<writable_operator_brackets<Value> >
-                , mpl::if_<
-                      iterator_archetypes::has_access<
-                          AccessCategory
-                        , iterator_archetypes::readable_iterator_t
-                      >
-                    , readable_operator_brackets<Value>
-                    , no_operator_brackets
-                  >
+    : mpl::eval_if<
+          is_convertible<TraversalCategory, random_access_traversal_tag>
+        , mpl::eval_if<
+              archetypes::has_access<
+                  AccessCategory
+                , archetypes::writable_iterator_t
              >
-            , mpl::identity<no_operator_brackets>
-          >::type
+            , mpl::identity<writable_operator_brackets<Value> >
+            , mpl::if_<
+                  archetypes::has_access<
+                      AccessCategory
+                    , archetypes::readable_iterator_t
+                  >
+                , readable_operator_brackets<Value>
+                , no_operator_brackets
+              >
+          >
+        , mpl::identity<no_operator_brackets>
      >::type
  {};
-  
+
  template <class TraversalCategory>
  struct traversal_archetype_impl
  {
@ -154,18 +152,16 @@ namespace detail

  template <class Derived, class Value, class TraversalCategory>
  struct traversal_archetype_
-    : mpl::aux::msvc_eti_base<
-          typename traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
-      >::type
+    : traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
  {
      typedef typename
        traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
      base;
-      
+
      traversal_archetype_() {}

      traversal_archetype_(ctor_arg arg)
-        : base(arg) 
+        : base(arg)
      {}
  };

@ -196,7 +192,7 @@ namespace detail
          explicit archetype(ctor_arg arg)
            : traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg)
          {}
-          
+
          typedef std::ptrdiff_t difference_type;
      };
  };
@ -204,13 +200,7 @@ namespace detail
  template <class Derived, class Value>
  bool operator==(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
                  traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
-  
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-  // doesn't seem to pick up != from equality_comparable
-  template <class Derived, class Value>
-  bool operator!=(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
-                  traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
-#endif 
+
  template <>
  struct traversal_archetype_impl<forward_traversal_tag>
  {
@ -218,7 +208,7 @@ namespace detail
      struct archetype
        : public traversal_archetype_<Derived, Value, single_pass_traversal_tag>
      {
-          archetype() 
+          archetype()
            : traversal_archetype_<Derived, Value, single_pass_traversal_tag>(ctor_arg())
          {}
      };
@ -241,7 +231,7 @@ namespace detail
  {
      template<class Derived, class Value>
      struct archetype
-        : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag> 
+        : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag>
      {
          Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); }
          Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); }
@ -300,7 +290,7 @@ namespace detail


 template <class> struct undefined;
-  
+
 template <class AccessCategory>
 struct iterator_access_archetype_impl
 {
@ -309,17 +299,15 @@ struct iterator_access_archetype_impl

 template <class Value, class AccessCategory>
 struct iterator_access_archetype
-  : mpl::aux::msvc_eti_base<
-        typename iterator_access_archetype_impl<
-            AccessCategory
-        >::template archetype<Value>
-    >::type
+  : iterator_access_archetype_impl<
+        AccessCategory
+    >::template archetype<Value>
 {
 };

 template <>
 struct iterator_access_archetype_impl<
-    iterator_archetypes::readable_iterator_t
+    archetypes::readable_iterator_t
 >
 {
    template <class Value>
@ -337,15 +325,13 @@ struct iterator_access_archetype_impl<

 template <>
 struct iterator_access_archetype_impl<
-    iterator_archetypes::writable_iterator_t
+    archetypes::writable_iterator_t
 >
 {
    template <class Value>
    struct archetype
    {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
        BOOST_STATIC_ASSERT(!is_const<Value>::value);
-# endif 
        typedef void value_type;
        typedef void reference;
        typedef void pointer;
@ -356,13 +342,13 @@ struct iterator_access_archetype_impl<

 template <>
 struct iterator_access_archetype_impl<
-    iterator_archetypes::readable_writable_iterator_t
+    archetypes::readable_writable_iterator_t
 >
 {
    template <class Value>
    struct archetype
      : public virtual iterator_access_archetype<
-            Value, iterator_archetypes::readable_iterator_t
+            Value, archetypes::readable_iterator_t
        >
    {
        typedef detail::read_write_proxy<Value>    reference;
@ -372,12 +358,12 @@ struct iterator_access_archetype_impl<
 };

 template <>
-struct iterator_access_archetype_impl<iterator_archetypes::readable_lvalue_iterator_t>
+struct iterator_access_archetype_impl<archetypes::readable_lvalue_iterator_t>
 {
    template <class Value>
    struct archetype
      : public virtual iterator_access_archetype<
-            Value, iterator_archetypes::readable_iterator_t
+            Value, archetypes::readable_iterator_t
        >
    {
        typedef Value&    reference;
@ -386,28 +372,26 @@ struct iterator_access_archetype_impl<iterator_archetypes::readable_lvalue_itera
        Value* operator->() const { return 0; }
    };
 };
-  
+
 template <>
-struct iterator_access_archetype_impl<iterator_archetypes::writable_lvalue_iterator_t>
+struct iterator_access_archetype_impl<archetypes::writable_lvalue_iterator_t>
 {
    template <class Value>
    struct archetype
      : public virtual iterator_access_archetype<
-            Value, iterator_archetypes::readable_lvalue_iterator_t
+            Value, archetypes::readable_lvalue_iterator_t
        >
    {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
        BOOST_STATIC_ASSERT((!is_const<Value>::value));
-# endif 
    };
 };
-  
+

 template <class Value, class AccessCategory, class TraversalCategory>
 struct iterator_archetype;
-  
+
 template <class Value, class AccessCategory, class TraversalCategory>
-struct traversal_archetype_base 
+struct traversal_archetype_base
  : detail::operator_brackets<
        typename remove_cv<Value>::type
      , AccessCategory
@ -429,12 +413,12 @@ namespace detail
    , traversal_archetype_base<Value, AccessCategory, TraversalCategory>
  {
      typedef iterator_access_archetype<Value, AccessCategory> access;
-      
+
      typedef typename detail::facade_iterator_category<
          TraversalCategory
        , typename mpl::eval_if<
-              iterator_archetypes::has_access<
-                  AccessCategory, iterator_archetypes::writable_iterator_t
+              archetypes::has_access<
+                  AccessCategory, archetypes::writable_iterator_t
              >
            , remove_const<Value>
            , add_const<Value>
@ -467,18 +451,18 @@ struct iterator_archetype
  , public detail::iterator_archetype_base<
        Value, AccessCategory, TraversalCategory
    >::workaround_iterator_base
-# endif 
+# endif
 {
    // Derivation from std::iterator above caused references to nested
    // types to be ambiguous, so now we have to redeclare them all
    // here.
 # if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310)           \
    || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101))
-    
+
    typedef detail::iterator_archetype_base<
        Value,AccessCategory,TraversalCategory
    > base;
-    
+
    typedef typename base::value_type value_type;
    typedef typename base::reference reference;
    typedef typename base::pointer pointer;
@ -509,7 +493,17 @@ struct iterator_archetype
 # endif
 };

+} // namespace iterators
+
+// Backward compatibility names
+namespace iterator_archetypes = iterators::archetypes;
+using iterators::access_archetype;
+using iterators::traversal_archetype;
+using iterators::iterator_archetype;
+using iterators::undefined;
+using iterators::iterator_access_archetype_impl;
+using iterators::traversal_archetype_base;
+
 } // namespace boost

-
 #endif // BOOST_ITERATOR_ARCHETYPES_HPP
--- a/include/boost/iterator/iterator_categories.hpp
+++ b/include/boost/iterator/iterator_categories.hpp
@ -22,6 +22,7 @@
 # include <boost/static_assert.hpp>

 namespace boost {
+namespace iterators {

 //
 // Traversal Categories
@ -29,34 +30,34 @@ namespace boost {

 struct no_traversal_tag {};

-struct incrementable_traversal_tag 
+struct incrementable_traversal_tag
  : no_traversal_tag
 {
 //     incrementable_traversal_tag() {}
 //     incrementable_traversal_tag(std::output_iterator_tag const&) {};
 };
-  
+
 struct single_pass_traversal_tag
  : incrementable_traversal_tag
 {
 //     single_pass_traversal_tag() {}
 //     single_pass_traversal_tag(std::input_iterator_tag const&) {};
 };
-  
+
 struct forward_traversal_tag
  : single_pass_traversal_tag
 {
 //     forward_traversal_tag() {}
 //     forward_traversal_tag(std::forward_iterator_tag const&) {};
 };
-  
+
 struct bidirectional_traversal_tag
  : forward_traversal_tag
 {
 //     bidirectional_traversal_tag() {};
 //     bidirectional_traversal_tag(std::bidirectional_iterator_tag const&) {};
 };
-  
+
 struct random_access_traversal_tag
  : bidirectional_traversal_tag
 {
@ -65,7 +66,7 @@ struct random_access_traversal_tag
 };

 namespace detail
-{  
+{
  //
  // Convert a "strictly old-style" iterator category to a traversal
  // tag.  This is broken out into a separate metafunction to reduce
@ -97,51 +98,8 @@ namespace detail
      >
  {};

-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-  template <>
-  struct old_category_to_traversal<int>
-  {
-      typedef int type;
-  };
-# endif
-
-  template <class Traversal>
-  struct pure_traversal_tag
-    : mpl::eval_if<
-          is_convertible<Traversal,random_access_traversal_tag>
-        , mpl::identity<random_access_traversal_tag>
-        , mpl::eval_if<
-              is_convertible<Traversal,bidirectional_traversal_tag>
-            , mpl::identity<bidirectional_traversal_tag>
-            , mpl::eval_if<
-                  is_convertible<Traversal,forward_traversal_tag>
-                , mpl::identity<forward_traversal_tag>
-                , mpl::eval_if<
-                      is_convertible<Traversal,single_pass_traversal_tag>
-                    , mpl::identity<single_pass_traversal_tag>
-                    , mpl::eval_if<
-                          is_convertible<Traversal,incrementable_traversal_tag>
-                        , mpl::identity<incrementable_traversal_tag>
-                        , void
-                      >
-                  >
-              >
-          >
-      >
-  {
-  };
-  
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-  template <>
-  struct pure_traversal_tag<int>
-  {
-      typedef int type;
-  };
-# endif
-
 } // namespace detail

-
 //
 // Convert an iterator category into a traversal tag
 //
@ -150,7 +108,7 @@ struct iterator_category_to_traversal
  : mpl::eval_if< // if already convertible to a traversal tag, we're done.
        is_convertible<Cat,incrementable_traversal_tag>
      , mpl::identity<Cat>
-      , boost::detail::old_category_to_traversal<Cat>
+      , boost::iterators::detail::old_category_to_traversal<Cat>
    >
 {};

@ -181,6 +139,82 @@ struct iterator_traversal<mpl::_>
 {};
 # endif

+//
+// Convert an iterator traversal to one of the traversal tags.
+//
+template <class Traversal>
+struct pure_traversal_tag
+  : mpl::eval_if<
+        is_convertible<Traversal,random_access_traversal_tag>
+      , mpl::identity<random_access_traversal_tag>
+      , mpl::eval_if<
+            is_convertible<Traversal,bidirectional_traversal_tag>
+          , mpl::identity<bidirectional_traversal_tag>
+          , mpl::eval_if<
+                is_convertible<Traversal,forward_traversal_tag>
+              , mpl::identity<forward_traversal_tag>
+              , mpl::eval_if<
+                    is_convertible<Traversal,single_pass_traversal_tag>
+                  , mpl::identity<single_pass_traversal_tag>
+                  , mpl::eval_if<
+                        is_convertible<Traversal,incrementable_traversal_tag>
+                      , mpl::identity<incrementable_traversal_tag>
+                      , void
+                    >
+                >
+            >
+        >
+    >
+{
+};
+
+// This import is needed for backward compatibility with Boost.Range:
+// boost/range/detail/demote_iterator_traversal_tag.hpp
+// It should be removed when that header is fixed.
+namespace detail {
+using iterators::pure_traversal_tag;
+} // namespace detail
+
+//
+// Trait to retrieve one of the iterator traversal tags from the iterator category or traversal.
+//
+template <class Iterator = mpl::_1>
+struct pure_iterator_traversal
+  : pure_traversal_tag<typename iterator_traversal<Iterator>::type>
+{};
+
+# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+template <>
+struct pure_iterator_traversal<mpl::_1>
+{
+    template <class T>
+    struct apply : pure_iterator_traversal<T>
+    {};
+};
+template <>
+struct pure_iterator_traversal<mpl::_>
+  : pure_iterator_traversal<mpl::_1>
+{};
+# endif
+
+} // namespace iterators
+
+using iterators::no_traversal_tag;
+using iterators::incrementable_traversal_tag;
+using iterators::single_pass_traversal_tag;
+using iterators::forward_traversal_tag;
+using iterators::bidirectional_traversal_tag;
+using iterators::random_access_traversal_tag;
+using iterators::iterator_category_to_traversal;
+using iterators::iterator_traversal;
+
+// This import is needed for backward compatibility with Boost.Range:
+// boost/range/detail/demote_iterator_traversal_tag.hpp
+// It should be removed when that header is fixed.
+namespace detail {
+using iterators::pure_traversal_tag;
+} // namespace detail
+
 } // namespace boost

 #include <boost/iterator/detail/config_undef.hpp>
--- a/include/boost/iterator/iterator_concepts.hpp
+++ b/include/boost/iterator/iterator_concepts.hpp
@ -56,7 +56,7 @@ namespace boost_concepts
  private:
      Iterator i;
  };
-  
+
  template <
      typename Iterator
    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
@ -78,7 +78,7 @@ namespace boost_concepts
    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
  >
  struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
-  
+
  BOOST_concept(SwappableIterator,(Iterator))
  {
      BOOST_CONCEPT_USAGE(SwappableIterator)
@ -93,7 +93,7 @@ namespace boost_concepts
  BOOST_concept(LvalueIterator,(Iterator))
  {
      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
-      
+
      BOOST_CONCEPT_USAGE(LvalueIterator)
      {
        value_type& r = const_cast<value_type&>(*i);
@ -103,7 +103,7 @@ namespace boost_concepts
      Iterator i;
  };

-  
+
  //===========================================================================
  // Iterator Traversal Concepts

@ -145,7 +145,7 @@ namespace boost_concepts
    , boost::DefaultConstructible<Iterator>
  {
      typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
-      
+
      BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
      BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);

@ -155,7 +155,7 @@ namespace boost_concepts
           , boost::forward_traversal_tag
          > ));
  };
-  
+
  BOOST_concept(BidirectionalTraversal,(Iterator))
    : ForwardTraversal<Iterator>
  {
@ -192,14 +192,14 @@ namespace boost_concepts
          i = i - n;
          n = i - j;
      }
-      
+
   private:
      typename BidirectionalTraversal<Iterator>::difference_type n;
      Iterator i, j;
  };

  //===========================================================================
-  // Iterator Interoperability 
+  // Iterator Interoperability

  namespace detail
  {
@ -248,19 +248,10 @@ namespace boost_concepts
  BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
  {
   private:
-      typedef typename boost::detail::pure_traversal_tag<
-          typename boost::iterator_traversal<
-              Iterator
-          >::type
-      >::type traversal_category;
+      typedef typename boost::iterators::pure_iterator_traversal<Iterator>::type traversal_category;
+      typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category;

-      typedef typename boost::detail::pure_traversal_tag<
-          typename boost::iterator_traversal<
-              ConstIterator
-          >::type
-      >::type const_traversal_category;
-      
-  public:
+   public:
      BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));
      BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));

@ -271,7 +262,7 @@ namespace boost_concepts

          ci = i;
      }
-      
+
   private:
      Iterator      i;
      ConstIterator ci;
--- a/include/boost/iterator/iterator_facade.hpp
+++ b/include/boost/iterator/iterator_facade.hpp
@ -7,9 +7,11 @@
 #ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP
 #define BOOST_ITERATOR_FACADE_23022003THW_HPP

+#include <boost/config.hpp>
 #include <boost/iterator.hpp>
 #include <boost/iterator/interoperable.hpp>
 #include <boost/iterator/iterator_traits.hpp>
+#include <boost/iterator/iterator_categories.hpp>

 #include <boost/iterator/detail/facade_iterator_category.hpp>
 #include <boost/iterator/detail/enable_if.hpp>
@ -36,8 +38,9 @@

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

-namespace boost
-{
+namespace boost {
+namespace iterators {
+
  // 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;
@ -56,6 +59,12 @@ namespace boost
        };
    };

+    // The type trait checks if the category or traversal is at least as advanced as the specified required traversal
+    template< typename CategoryOrTraversal, typename Required >
+    struct is_traversal_at_least :
+        public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
+    {};
+
    //
    // enable if for use in operator implementation.
    //
@ -64,28 +73,31 @@ namespace boost
      , 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>
-            >
+    struct enable_if_interoperable :
+        public boost::iterators::enable_if<
+            is_interoperable< Facade1, Facade2 >
+          , Return
+        >
+    {};
+
+    //
+    // enable if for use in implementation of operators specific for random access traversal.
+    //
+    template <
+        class Facade1
+      , class Facade2
+      , class Return
+    >
+    struct enable_if_interoperable_and_random_access_traversal :
+        public boost::iterators::enable_if<
+            mpl::and_<
+                is_interoperable< Facade1, Facade2 >
+              , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
+              , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
+            >
          , 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
@ -94,7 +106,7 @@ namespace boost
    template <
        class ValueParam
      , class CategoryOrTraversal
-      , class Reference 
+      , class Reference
      , class Difference
    >
    struct iterator_facade_types
@ -102,16 +114,16 @@ namespace boost
        typedef typename facade_iterator_category<
            CategoryOrTraversal, ValueParam, Reference
        >::type iterator_category;
-        
+
        typedef typename remove_const<ValueParam>::type value_type;
-        
+
        // Not the real associated pointer type
        typedef typename mpl::eval_if<
-            boost::detail::iterator_writability_disabled<ValueParam,Reference>
+            boost::iterators::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)))     \
@ -157,7 +169,7 @@ namespace boost
     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
@ -209,7 +221,7 @@ namespace boost
        {
            return stored_iterator;
        }
-        
+
     private:
        mutable value_type stored_value;
        Iterator stored_iterator;
@ -221,7 +233,7 @@ namespace boost
    struct is_non_proxy_reference_impl
    {
        static Reference r;
-        
+
        template <class R>
        static typename mpl::if_<
            is_convertible<
@ -231,17 +243,17 @@ namespace boost
          , 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 
+# else
    template <class Reference, class Value>
    struct is_non_proxy_reference
      : is_convertible<
@ -250,8 +262,8 @@ namespace boost
          , Value const volatile*
        >
    {};
-# endif 
-        
+# endif
+
    // A metafunction to choose the result type of postfix ++
    //
    // Because the C++98 input iterator requirements say that *r++ has
@ -273,7 +285,7 @@ namespace boost
            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_<
@ -325,15 +337,6 @@ namespace boost
        }
    };

-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    // Deal with ETI
-    template<>
-    struct operator_arrow_dispatch<int, int>
-    {
-        typedef int result_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)
@ -378,7 +381,7 @@ namespace boost
            >
        >
    {};
-        
+
    template <class Iterator, class Value, class Reference>
    struct operator_brackets_result
    {
@ -408,28 +411,34 @@ namespace boost
          :
 # 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 
+# else
          mpl::eval_if<
              is_convertible<I2,I1>
            , iterator_difference<I1>
            , iterator_difference<I2>
          >
-# endif 
+# endif
        {};

    };
+
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+      , bool IsBidirectionalTraversal
+      , bool IsRandomAccessTraversal
+    >
+    class iterator_facade_base;
+
  } // 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)       \
+#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler)       \
    template <                                                              \
        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
@ -438,24 +447,33 @@ namespace boost
    operator op(                                                            \
        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
-# else 
-#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)   \
+# else
+#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler)   \
    template <                                                          \
        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
    >                                                                   \
-    prefix typename boost::detail::enable_if_interoperable<             \
+    prefix typename enabler<                                            \
        Derived1, Derived2                                              \
      , typename mpl::apply2<result_type,Derived1,Derived2>::type       \
    >::type                                                             \
    operator op(                                                        \
        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
-# endif 
+# endif
+
+#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \
+    BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable)
+
+#  define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(prefix, op, result_type)       \
+    BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal)

 #  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
    template <class Derived, class V, class TC, class R, class D>   \
-    prefix Derived operator+ args
+    prefix typename boost::iterators::enable_if<                    \
+        boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >,  \
+        Derived                                                     \
+    >::type operator+ args

  //
  // Helper class for granting access to the iterator core interface.
@ -468,41 +486,49 @@ namespace boost
  //
  class iterator_core_access
  {
-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
      // 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;
+      template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal>
+      friend class detail::iterator_facade_base;

 #  define BOOST_ITERATOR_FACADE_RELATION(op)                                \
-      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::detail::always_bool2);
+      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::iterators::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, -, boost::detail::choose_difference_type)
+#  define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op)                                \
+      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2);
+
+      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<)
+      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>)
+      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=)
+      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=)
+
+#  undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
+
+      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(
+          friend, -, boost::iterators::detail::choose_difference_type)
      ;

      BOOST_ITERATOR_FACADE_PLUS_HEAD(
          friend inline
-          , (iterator_facade<Derived, V, TC, R, D> const&
-           , typename Derived::difference_type)
+        , (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&)
+        , iterator_facade<Derived, V, TC, R, D> const&)
      )
      ;

@ -573,11 +599,156 @@ namespace boost
          return *static_cast<I const*>(&facade);
      }

-   private:
      // objects of this class are useless
-      iterator_core_access(); //undefined
+      BOOST_DELETED_FUNCTION(iterator_core_access())
  };

+  namespace detail {
+
+    // Implementation for forward traversal iterators
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
+# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
+        : public boost::iterators::detail::iterator_facade_types<
+             Value, CategoryOrTraversal, Reference, Difference
+          >::base
+#  undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
+# endif
+    {
+    private:
+        typedef boost::iterators::detail::iterator_facade_types<
+            Value, CategoryOrTraversal, Reference, Difference
+        > associated_types;
+
+        typedef boost::iterators::detail::operator_arrow_dispatch<
+            Reference
+          , typename associated_types::pointer
+        > operator_arrow_dispatch_;
+
+    public:
+        typedef typename associated_types::value_type value_type;
+        typedef Reference reference;
+        typedef Difference difference_type;
+
+        typedef typename operator_arrow_dispatch_::result_type pointer;
+
+        typedef typename associated_types::iterator_category iterator_category;
+
+    public:
+        reference operator*() const
+        {
+            return iterator_core_access::dereference(this->derived());
+        }
+
+        pointer operator->() const
+        {
+            return operator_arrow_dispatch_::apply(*this->derived());
+        }
+
+        Derived& operator++()
+        {
+            iterator_core_access::increment(this->derived());
+            return this->derived();
+        }
+
+    protected:
+        //
+        // Curiously Recurring Template interface.
+        //
+        Derived& derived()
+        {
+            return *static_cast<Derived*>(this);
+        }
+
+        Derived const& derived() const
+        {
+            return *static_cast<Derived const*>(this);
+        }
+    };
+
+    // Implementation for bidirectional traversal iterators
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > :
+        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
+    {
+    public:
+        Derived& operator--()
+        {
+            iterator_core_access::decrement(this->derived());
+            return this->derived();
+        }
+
+        Derived operator--(int)
+        {
+            Derived tmp(this->derived());
+            --*this;
+            return tmp;
+        }
+    };
+
+    // Implementation for random access traversal iterators
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :
+        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >
+    {
+    private:
+        typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type;
+
+    public:
+        typedef typename base_type::reference reference;
+        typedef typename base_type::difference_type difference_type;
+
+    public:
+        typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type
+        operator[](difference_type n) const
+        {
+            typedef boost::iterators::detail::use_operator_brackets_proxy<Value, Reference> use_proxy;
+
+            return boost::iterators::detail::make_operator_brackets_result<Derived>(
+                this->derived() + n
+              , use_proxy()
+            );
+        }
+
+        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;
+        }
+    };
+
+  } // namespace detail
+
  //
  // iterator_facade - use as a public base class for defining new
  // standard-conforming iterators.
@ -589,151 +760,38 @@ namespace boost
    , class Reference   = Value&
    , class Difference  = std::ptrdiff_t
  >
-  class iterator_facade
-# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
-    : public boost::detail::iterator_facade_types<
-         Value, CategoryOrTraversal, Reference, Difference
-      >::base
-#  undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
-# endif
+  class iterator_facade :
+      public detail::iterator_facade_base<
+          Derived,
+          Value,
+          CategoryOrTraversal,
+          Reference,
+          Difference,
+          detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value,
+          detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value
+      >
  {
-   private:
-      //
-      // Curiously Recurring Template interface.
-      //
-      Derived& derived()
-      {
-          return *static_cast<Derived*>(this);
-      }
-
-      Derived const& derived() const
-      {
-          return *static_cast<Derived const*>(this);
-      }
-
-      typedef boost::detail::iterator_facade_types<
-         Value, CategoryOrTraversal, Reference, Difference
-      > associated_types;
-
-      typedef boost::detail::operator_arrow_dispatch<
-          Reference
-        , typename associated_types::pointer
-      > operator_arrow_dispatch_;
-
-   protected:
+  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 operator_arrow_dispatch_::result_type pointer;
-
-      typedef typename associated_types::iterator_category iterator_category;
-
-      reference operator*() const
-      {
-          return iterator_core_access::dereference(this->derived());
-      }
-
-      pointer operator->() const
-      {
-          return operator_arrow_dispatch_::apply(*this->derived());
-      }
-        
-      typename boost::detail::operator_brackets_result<Derived,Value,reference>::type
-      operator[](difference_type n) const
-      {
-          typedef boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy;
-          
-          return boost::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 boost::detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type
-      operator++(int)
-      {
-          typename boost::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 boost::detail::postfix_increment_result<I,V,R,TC>::type
+  inline typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
  operator++(
      iterator_facade<I,V,TC,R,D>& i
    , int
  )
  {
-      typename boost::detail::postfix_increment_result<I,V,R,TC>::type
+      typename boost::iterators::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
@ -824,7 +882,7 @@ namespace boost
 # define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
  BOOST_ITERATOR_FACADE_INTEROP(                                    \
      op                                                            \
-    , boost::detail::always_bool2                                   \
+    , boost::iterators::detail::always_bool2                                   \
    , return_prefix                                                 \
    , base_op                                                       \
  )
@ -832,21 +890,50 @@ namespace boost
  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

+
+# define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op, result_type, return_prefix, base_op) \
+  BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type)                   \
+  {                                                                             \
+      /* For those compilers that do not support enable_if */                   \
+      BOOST_STATIC_ASSERT((                                                     \
+          is_interoperable< Derived1, Derived2 >::value &&                      \
+          boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && \
+          boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::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_RANDOM_ACCESS_RELATION(op, return_prefix, base_op) \
+  BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(                                    \
+      op                                                            \
+    , boost::iterators::detail::always_bool2                                   \
+    , return_prefix                                                 \
+    , base_op                                                       \
+  )
+
+  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from)
+  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>, return 0 <, distance_from)
+  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=, return 0 >=, distance_from)
+  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=, return 0 <=, distance_from)
+
+# undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
+
  // operator- requires an additional part in the static assertion
-  BOOST_ITERATOR_FACADE_INTEROP(
+  BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(
      -
-    , boost::detail::choose_difference_type
+    , boost::iterators::detail::choose_difference_type
    , return
    , distance_from
  )
+
 # undef BOOST_ITERATOR_FACADE_INTEROP
-# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
+# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS

 # define BOOST_ITERATOR_FACADE_PLUS(args)           \
  BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args)     \
@ -855,18 +942,28 @@ namespace boost
      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((
+      iterator_facade<Derived, V, TC, R, D> const& i
+    , typename Derived::difference_type n
+  ))

-BOOST_ITERATOR_FACADE_PLUS((
-    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

+# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
+# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD
+# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL
+
+} // namespace iterators
+
+using iterators::iterator_core_access;
+using iterators::iterator_facade;
+
 } // namespace boost

 #include <boost/iterator/detail/config_undef.hpp>
--- a/include/boost/iterator/iterator_traits.hpp
+++ b/include/boost/iterator/iterator_traits.hpp
@ -8,20 +8,12 @@
 # include <boost/detail/iterator.hpp>
 # include <boost/detail/workaround.hpp>

-namespace boost { 
+namespace boost {
+namespace iterators {

-// Unfortunately, g++ 2.95.x chokes when we define a class template
-// iterator_category which has the same name as its
-// std::iterator_category() function, probably due in part to the
-// "std:: is visible globally" hack it uses.  Use
-// BOOST_ITERATOR_CATEGORY to write code that's portable to older
-// GCCs.
-
-# if BOOST_WORKAROUND(__GNUC__, <= 2)
-#  define BOOST_ITERATOR_CATEGORY iterator_category_
-# else
-#  define BOOST_ITERATOR_CATEGORY iterator_category
-# endif
+// Macro for supporting old compilers, no longer needed but kept
+// for backwards compatibility (it was documented).
+#define BOOST_ITERATOR_CATEGORY iterator_category


 template <class Iterator>
@ -29,20 +21,20 @@ struct iterator_value
 {
    typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
 };
-  
+
 template <class Iterator>
 struct iterator_reference
 {
    typedef typename boost::detail::iterator_traits<Iterator>::reference type;
 };
-  
-  
+
+
 template <class Iterator>
 struct iterator_pointer
 {
    typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
 };
-  
+
 template <class Iterator>
 struct iterator_difference
 {
@ -50,43 +42,19 @@ struct iterator_difference
 };

 template <class Iterator>
-struct BOOST_ITERATOR_CATEGORY
+struct iterator_category
 {
    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
 };

-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-template <>
-struct iterator_value<int>
-{
-    typedef void type;
-};
-  
-template <>
-struct iterator_reference<int>
-{
-    typedef void type;
-};
+} // namespace iterators

-template <>
-struct iterator_pointer<int>
-{
-    typedef void type;
-};
-  
-template <>
-struct iterator_difference<int>
-{
-    typedef void type;
-};
-  
-template <>
-struct BOOST_ITERATOR_CATEGORY<int>
-{
-    typedef void type;
-};
-# endif
+using iterators::iterator_value;
+using iterators::iterator_reference;
+using iterators::iterator_pointer;
+using iterators::iterator_difference;
+using iterators::iterator_category;

-} // namespace boost::iterator
+} // namespace boost

 #endif // ITERATOR_TRAITS_DWA200347_HPP
--- a/include/boost/iterator/minimum_category.hpp
+++ b/include/boost/iterator/minimum_category.hpp
@ -0,0 +1,95 @@
+// Copyright David Abrahams 2003. Use, modification and distribution is
+// subject to 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_MINIMUM_CATEGORY_HPP_INCLUDED_
+# define BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
+
+# include <boost/static_assert.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+# include <boost/type_traits/is_same.hpp>
+
+# include <boost/mpl/placeholders.hpp>
+# include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+template <bool GreaterEqual, bool LessEqual>
+struct minimum_category_impl;
+
+template <class T1, class T2>
+struct error_not_related_by_convertibility;
+
+template <>
+struct minimum_category_impl<true,false>
+{
+    template <class T1, class T2> struct apply
+    {
+        typedef T2 type;
+    };
+};
+
+template <>
+struct minimum_category_impl<false,true>
+{
+    template <class T1, class T2> struct apply
+    {
+        typedef T1 type;
+    };
+};
+
+template <>
+struct minimum_category_impl<true,true>
+{
+    template <class T1, class T2> struct apply
+    {
+        BOOST_STATIC_ASSERT((is_same<T1,T2>::value));
+        typedef T1 type;
+    };
+};
+
+template <>
+struct minimum_category_impl<false,false>
+{
+    template <class T1, class T2> struct apply
+      : error_not_related_by_convertibility<T1,T2>
+    {
+    };
+};
+
+} // namespace detail
+
+//
+// Returns the minimum category type or fails to compile
+// if T1 and T2 are unrelated.
+//
+template <class T1 = mpl::_1, class T2 = mpl::_2>
+struct minimum_category
+{
+    typedef boost::iterators::detail::minimum_category_impl<
+        ::boost::is_convertible<T1,T2>::value
+      , ::boost::is_convertible<T2,T1>::value
+    > outer;
+
+    typedef typename outer::template apply<T1,T2> inner;
+    typedef typename inner::type type;
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(2,minimum_category,(T1,T2))
+};
+
+template <>
+struct minimum_category<mpl::_1,mpl::_2>
+{
+    template <class T1, class T2>
+    struct apply : minimum_category<T1,T2>
+    {};
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2))
+};
+
+} // namespace iterators
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
--- a/include/boost/iterator/permutation_iterator.hpp
+++ b/include/boost/iterator/permutation_iterator.hpp
@ -13,28 +13,28 @@
 #include <boost/iterator/iterator_adaptor.hpp>


-namespace boost
-{
+namespace boost {
+namespace iterators {

 template< class ElementIterator
        , class IndexIterator>
 class permutation_iterator
-  : public iterator_adaptor< 
+  : public iterator_adaptor<
             permutation_iterator<ElementIterator, IndexIterator>
-           , IndexIterator, typename detail::iterator_traits<ElementIterator>::value_type
-           , use_default, typename detail::iterator_traits<ElementIterator>::reference>
+           , IndexIterator, typename boost::detail::iterator_traits<ElementIterator>::value_type
+           , use_default, typename boost::detail::iterator_traits<ElementIterator>::reference>
 {
-  typedef iterator_adaptor< 
+  typedef iterator_adaptor<
            permutation_iterator<ElementIterator, IndexIterator>
-          , IndexIterator, typename detail::iterator_traits<ElementIterator>::value_type
-          , use_default, typename detail::iterator_traits<ElementIterator>::reference> super_t;
+          , IndexIterator, typename boost::detail::iterator_traits<ElementIterator>::value_type
+          , use_default, typename boost::detail::iterator_traits<ElementIterator>::reference> super_t;

  friend class iterator_core_access;

 public:
  permutation_iterator() : m_elt_iter() {}

-  explicit permutation_iterator(ElementIterator x, IndexIterator y) 
+  explicit permutation_iterator(ElementIterator x, IndexIterator y)
      : super_t(y), m_elt_iter(x) {}

  template<class OtherElementIterator, class OtherIndexIterator>
@ -54,18 +54,22 @@ private:
    template <class,class> friend class permutation_iterator;
 #else
 public:
-#endif 
+#endif
    ElementIterator m_elt_iter;
 };


 template <class ElementIterator, class IndexIterator>
-permutation_iterator<ElementIterator, IndexIterator> 
+inline permutation_iterator<ElementIterator, IndexIterator>
 make_permutation_iterator( ElementIterator e, IndexIterator i )
 {
    return permutation_iterator<ElementIterator, IndexIterator>( e, i );
 }

+} // namespace iterators
+
+using iterators::permutation_iterator;
+using iterators::make_permutation_iterator;

 } // namespace boost

--- a/include/boost/iterator/reverse_iterator.hpp
+++ b/include/boost/iterator/reverse_iterator.hpp
@ -11,8 +11,8 @@
 #include <boost/iterator.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>

-namespace boost
-{
+namespace boost {
+namespace iterators {

  //
  //
@ -28,7 +28,7 @@ namespace boost
   public:
      reverse_iterator() {}

-      explicit reverse_iterator(Iterator x) 
+      explicit reverse_iterator(Iterator x)
          : super_t(x) {}

      template<class OtherIterator>
@ -41,7 +41,7 @@ namespace boost

   private:
      typename super_t::reference dereference() const { return *boost::prior(this->base()); }
-    
+
      void increment() { --this->base_reference(); }
      void decrement() { ++this->base_reference(); }

@ -59,11 +59,16 @@ namespace boost
  };

  template <class BidirectionalIterator>
-  reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
+  inline reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
  {
      return reverse_iterator<BidirectionalIterator>(x);
  }

+} // namespace iterators
+
+using iterators::reverse_iterator;
+using iterators::make_reverse_iterator;
+
 } // namespace boost

 #endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP
--- a/include/boost/iterator/transform_iterator.hpp
+++ b/include/boost/iterator/transform_iterator.hpp
@ -26,16 +26,17 @@
 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
 # include <boost/type_traits/is_base_and_derived.hpp>

-#endif 
+#endif
 #include <boost/iterator/detail/config_def.hpp>


-namespace boost
-{
+namespace boost {
+namespace iterators {
+
  template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
  class transform_iterator;

-  namespace detail 
+  namespace detail
  {
    // Compute the iterator_adaptor instantiation to be used for transform_iterator
    template <class UnaryFunc, class Iterator, class Reference, class Value>
@ -72,10 +73,10 @@ namespace boost

  template <class UnaryFunc, class Iterator, class Reference, class Value>
  class transform_iterator
-    : public boost::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
+    : public boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
  {
    typedef typename
-    boost::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
+    boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
    super_t;

    friend class iterator_core_access;
@ -95,7 +96,7 @@ namespace boost
        // don't provide this constructor if UnaryFunc is a
        // function pointer type, since it will be 0.  Too dangerous.
        BOOST_STATIC_ASSERT(is_class<UnaryFunc>::value);
-#endif 
+#endif
    }

    template <
@ -108,7 +109,7 @@ namespace boost
       , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
       , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0
-#endif 
+#endif
    )
      : super_t(t.base()), m_f(t.functor())
   {}
@ -126,7 +127,7 @@ namespace boost
  };

  template <class UnaryFunc, class Iterator>
-  transform_iterator<UnaryFunc, Iterator>
+  inline transform_iterator<UnaryFunc, Iterator>
  make_transform_iterator(Iterator it, UnaryFunc fun)
  {
      return transform_iterator<UnaryFunc, Iterator>(it, fun);
@ -140,16 +141,9 @@ namespace boost
  // function pointer in the iterator be 0, leading to a runtime
  // crash.
  template <class UnaryFunc, class Iterator>
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-  typename mpl::if_<
-#else 
-  typename iterators::enable_if<
-#endif 
+  inline typename iterators::enable_if<
      is_class<UnaryFunc>   // We should probably find a cheaper test than is_class<>
    , transform_iterator<UnaryFunc, Iterator>
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    , int[3]
-#endif 
  >::type
  make_transform_iterator(Iterator it)
  {
@ -158,13 +152,18 @@ namespace boost

 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
  template <class Return, class Argument, class Iterator>
-  transform_iterator< Return (*)(Argument), Iterator, Return>
+  inline transform_iterator< Return (*)(Argument), Iterator, Return>
  make_transform_iterator(Iterator it, Return (*fun)(Argument))
  {
    return transform_iterator<Return (*)(Argument), Iterator, Return>(it, fun);
  }
 #endif

+} // namespace iterators
+
+using iterators::transform_iterator;
+using iterators::make_transform_iterator;
+
 } // namespace boost

 #include <boost/iterator/detail/config_undef.hpp>
--- a/include/boost/iterator/zip_iterator.hpp
+++ b/include/boost/iterator/zip_iterator.hpp
@ -14,7 +14,7 @@
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/detail/iterator.hpp>

-#include <boost/iterator/detail/minimum_category.hpp>
+#include <boost/iterator/minimum_category.hpp>

 #include <boost/tuple/tuple.hpp>

@ -27,6 +27,7 @@
 #include <boost/mpl/aux_/lambda_support.hpp>

 namespace boost {
+namespace iterators {

  // Zip iterator forward declaration for zip_iterator_base
  template<typename IteratorTuple>
@ -60,7 +61,7 @@ namespace boost {
    {
    public:
      advance_iterator(DiffType step) : m_step(step) {}
-      
+
      template<typename Iterator>
      void operator()(Iterator& it) const
      { it += m_step; }
@ -87,9 +88,9 @@ namespace boost {
    {
      template<typename Iterator>
      struct apply
-      { 
+      {
        typedef typename
-          iterator_traits<Iterator>::reference
+          boost::detail::iterator_traits<Iterator>::reference
        type;
      };

@ -97,7 +98,7 @@ namespace boost {
        typename apply<Iterator>::type operator()(Iterator const& it)
      { return *it; }
    };
-           
+

    // The namespace tuple_impl_specific provides two meta-
    // algorithms and two algorithms for tuples.
@ -108,7 +109,7 @@ namespace boost {
      //
      template<typename Tuple, class UnaryMetaFun>
      struct tuple_meta_transform;
-      
+
      template<typename Tuple, class UnaryMetaFun>
      struct tuple_meta_transform_impl
      {
@ -119,7 +120,7 @@ namespace boost {
              >::type
            , typename tuple_meta_transform<
                  typename Tuple::tail_type
-                , UnaryMetaFun 
+                , UnaryMetaFun
              >::type
          > type;
      };
@ -133,14 +134,14 @@ namespace boost {
        >
      {
      };
-      
-      // Meta-accumulate algorithm for tuples. Note: The template 
-      // parameter StartType corresponds to the initial value in 
+
+      // Meta-accumulate algorithm for tuples. Note: The template
+      // parameter StartType corresponds to the initial value in
      // ordinary accumulation.
      //
      template<class Tuple, class BinaryMetaFun, class StartType>
      struct tuple_meta_accumulate;
-      
+
      template<
          typename Tuple
        , class BinaryMetaFun
@ -154,7 +155,7 @@ namespace boost {
           , typename tuple_meta_accumulate<
                 typename Tuple::tail_type
               , BinaryMetaFun
-               , StartType 
+               , StartType
             >::type
         >::type type;
      };
@ -166,14 +167,7 @@ namespace boost {
      >
      struct tuple_meta_accumulate
        : mpl::eval_if<
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-              mpl::or_<
-#endif 
                  boost::is_same<Tuple, tuples::null_type>
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-                , boost::is_same<Tuple,int>
-              >
-#endif 
            , mpl::identity<StartType>
            , tuple_meta_accumulate_impl<
                  Tuple
@ -182,7 +176,7 @@ namespace boost {
              >
          >
      {
-      };  
+      };

 #if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)                            \
    || (                                                                    \
@ -190,17 +184,17 @@ namespace boost {
    )
 // Not sure why intel's partial ordering fails in this case, but I'm
 // assuming int's an MSVC bug-compatibility feature.
-      
+
 # define BOOST_TUPLE_ALGO_DISPATCH
 # define BOOST_TUPLE_ALGO(algo) algo##_impl
 # define BOOST_TUPLE_ALGO_TERMINATOR , int
 # define BOOST_TUPLE_ALGO_RECURSE , ...
-#else 
+#else
 # define BOOST_TUPLE_ALGO(algo) algo
 # define BOOST_TUPLE_ALGO_TERMINATOR
 # define BOOST_TUPLE_ALGO_RECURSE
 #endif
-      
+
      // transform algorithm for tuples. The template parameter Fun
      // must be a unary functor which is also a unary metafunction
      // class that computes its return type based on its argument
@ -218,22 +212,22 @@ namespace boost {
      //     Arg* operator()(Arg x);
      // };
      template<typename Fun>
-      tuples::null_type BOOST_TUPLE_ALGO(tuple_transform)
+      inline tuples::null_type BOOST_TUPLE_ALGO(tuple_transform)
          (tuples::null_type const&, Fun BOOST_TUPLE_ALGO_TERMINATOR)
      { return tuples::null_type(); }

      template<typename Tuple, typename Fun>
-      typename tuple_meta_transform<
+      inline typename tuple_meta_transform<
          Tuple
        , Fun
      >::type
-      
+
      BOOST_TUPLE_ALGO(tuple_transform)(
-        const Tuple& t, 
+        const Tuple& t,
        Fun f
        BOOST_TUPLE_ALGO_RECURSE
      )
-      { 
+      {
          typedef typename tuple_meta_transform<
              BOOST_DEDUCED_TYPENAME Tuple::tail_type
            , Fun
@ -244,58 +238,58 @@ namespace boost {
                Fun, BOOST_DEDUCED_TYPENAME Tuple::head_type
             >::type
           , transformed_tail_type
-        >( 
+        >(
            f(boost::tuples::get<0>(t)), tuple_transform(t.get_tail(), f)
        );
      }

 #ifdef BOOST_TUPLE_ALGO_DISPATCH
      template<typename Tuple, typename Fun>
-      typename tuple_meta_transform<
+      inline typename tuple_meta_transform<
          Tuple
        , Fun
      >::type
-      
+
      tuple_transform(
-        const Tuple& t, 
+        const Tuple& t,
        Fun f
      )
      {
          return tuple_transform_impl(t, f, 1);
      }
 #endif
-      
+
      // for_each algorithm for tuples.
      //
      template<typename Fun>
-      Fun BOOST_TUPLE_ALGO(tuple_for_each)(
+      inline Fun BOOST_TUPLE_ALGO(tuple_for_each)(
          tuples::null_type
        , Fun f BOOST_TUPLE_ALGO_TERMINATOR
      )
      { return f; }

-      
+
      template<typename Tuple, typename Fun>
-      Fun BOOST_TUPLE_ALGO(tuple_for_each)(
+      inline Fun BOOST_TUPLE_ALGO(tuple_for_each)(
          Tuple& t
        , Fun f BOOST_TUPLE_ALGO_RECURSE)
-      { 
+      {
          f( t.get_head() );
          return tuple_for_each(t.get_tail(), f);
      }
-      
+
 #ifdef BOOST_TUPLE_ALGO_DISPATCH
      template<typename Tuple, typename Fun>
-      Fun
+      inline Fun
      tuple_for_each(
-        Tuple& t, 
+        Tuple& t,
        Fun f
      )
      {
          return tuple_for_each_impl(t, f, 1);
      }
 #endif
-      
+
      // Equality of tuples. NOTE: "==" for tuples currently (7/2003)
      // has problems under some compilers, so I just do my own.
      // No point in bringing in a bunch of #ifdefs here. This is
@ -305,12 +299,9 @@ namespace boost {
      { return true; }

      template<typename Tuple1, typename Tuple2>
-        bool tuple_equal(
-            Tuple1 const& t1, 
-            Tuple2 const& t2
-        )
-      { 
-          return t1.get_head() == t2.get_head() && 
+      inline bool tuple_equal(Tuple1 const& t1, Tuple2 const& t2)
+      {
+          return t1.get_head() == t2.get_head() &&
          tuple_equal(t1.get_tail(), t2.get_tail());
      }
    }
@ -320,7 +311,7 @@ namespace boost {
    template<typename Iterator>
    struct iterator_reference
    {
-        typedef typename iterator_traits<Iterator>::reference type;
+        typedef typename boost::detail::iterator_traits<Iterator>::reference type;
    };

 #ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
@ -336,14 +327,14 @@ namespace boost {
        struct apply : iterator_reference<T> {};
    };
 #endif
-    
+
    // Metafunction to obtain the type of the tuple whose element types
    // are the reference types of an iterator tuple.
    //
    template<typename IteratorTuple>
    struct tuple_of_references
      : tuple_impl_specific::tuple_meta_transform<
-            IteratorTuple, 
+            IteratorTuple,
            iterator_reference<mpl::_1>
          >
    {
@ -359,7 +350,7 @@ namespace boost {
          IteratorTuple
        , pure_traversal_tag<iterator_traversal<> >
      >::type tuple_of_traversal_tags;
-          
+
      typedef typename tuple_impl_specific::tuple_meta_accumulate<
          tuple_of_traversal_tags
        , minimum_category<>
@ -367,14 +358,6 @@ namespace boost {
      >::type type;
    };

-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-      template <>
-      struct minimum_traversal_category_in_iterator_tuple<int>
-      {
-          typedef int type;
-      };
-#endif
-      
      // We need to call tuple_meta_accumulate with mpl::and_ as the
      // accumulating functor. To this end, we need to wrap it into
      // a struct that has exactly two arguments (that is, template
@ -385,7 +368,7 @@ namespace boost {
        : mpl::and_<Arg1, Arg2>
      {
      };
-    
+
 # ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
  // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
  // out well.  In this case I think it's an MPL bug
@ -396,13 +379,13 @@ namespace boost {
          struct apply : mpl::and_<A1,A2>
          {};
      };
-# endif 
+# endif

    ///////////////////////////////////////////////////////////////////
    //
    // Class zip_iterator_base
    //
-    // Builds and exposes the iterator facade type from which the zip 
+    // Builds and exposes the iterator facade type from which the zip
    // iterator will be derived.
    //
    template<typename IteratorTuple>
@ -411,30 +394,30 @@ namespace boost {
     private:
        // Reference type is the type of the tuple obtained from the
        // iterators' reference types.
-        typedef typename 
+        typedef typename
        detail::tuple_of_references<IteratorTuple>::type reference;
-      
+
        // Value type is the same as reference type.
        typedef reference value_type;
-      
+
        // Difference type is the first iterator's difference type
-        typedef typename iterator_traits<
+        typedef typename boost::detail::iterator_traits<
            typename tuples::element<0, IteratorTuple>::type
            >::difference_type difference_type;
-      
-        // Traversal catetgory is the minimum traversal category in the 
+
+        // Traversal catetgory is the minimum traversal category in the
        // iterator tuple.
-        typedef typename 
+        typedef typename
        detail::minimum_traversal_category_in_iterator_tuple<
            IteratorTuple
        >::type traversal_category;
     public:
-      
+
        // The iterator facade type from which the zip iterator will
        // be derived.
        typedef iterator_facade<
            zip_iterator<IteratorTuple>,
-            value_type,  
+            value_type,
            traversal_category,
            reference,
            difference_type
@ -447,34 +430,34 @@ namespace boost {
        typedef int type;
    };
  }
-  
+
  /////////////////////////////////////////////////////////////////////
  //
  // zip_iterator class definition
  //
  template<typename IteratorTuple>
-  class zip_iterator : 
+  class zip_iterator :
    public detail::zip_iterator_base<IteratorTuple>::type
-  {  
+  {

-   // Typedef super_t as our base class. 
-   typedef typename 
+   // Typedef super_t as our base class.
+   typedef typename
     detail::zip_iterator_base<IteratorTuple>::type super_t;

   // iterator_core_access is the iterator's best friend.
   friend class iterator_core_access;

  public:
-    
+
    // Construction
    // ============
-    
+
    // Default constructor
    zip_iterator() { }

    // Constructor from iterator tuple
-    zip_iterator(IteratorTuple iterator_tuple) 
-      : m_iterator_tuple(iterator_tuple) 
+    zip_iterator(IteratorTuple iterator_tuple)
+      : m_iterator_tuple(iterator_tuple)
    { }

    // Copy constructor
@ -493,15 +476,15 @@ namespace boost {
    { return m_iterator_tuple; }

  private:
-    
+
    // Implementation of Iterator Operations
    // =====================================
-    
+
    // Dereferencing returns a tuple built from the dereferenced
    // iterators in the iterator tuple.
    typename super_t::reference dereference() const
-    { 
-      return detail::tuple_impl_specific::tuple_transform( 
+    {
+      return detail::tuple_impl_specific::tuple_transform(
        get_iterator_tuple(),
        detail::dereference_iterator()
       );
@ -517,7 +500,7 @@ namespace boost {
    // under several compilers. No point in bringing in a bunch
    // of #ifdefs here.
    //
-    template<typename OtherIteratorTuple>   
+    template<typename OtherIteratorTuple>
    bool equal(const zip_iterator<OtherIteratorTuple>& other) const
    {
      return detail::tuple_impl_specific::tuple_equal(
@ -529,7 +512,7 @@ namespace boost {
    // Advancing a zip iterator means to advance all iterators in the
    // iterator tuple.
    void advance(typename super_t::difference_type n)
-    { 
+    {
      detail::tuple_impl_specific::tuple_for_each(
          m_iterator_tuple,
          detail::advance_iterator<BOOST_DEDUCED_TYPENAME super_t::difference_type>(n)
@ -538,48 +521,53 @@ namespace boost {
    // Incrementing a zip iterator means to increment all iterators in
    // the iterator tuple.
    void increment()
-    { 
+    {
      detail::tuple_impl_specific::tuple_for_each(
        m_iterator_tuple,
        detail::increment_iterator()
        );
    }
-    
+
    // Decrementing a zip iterator means to decrement all iterators in
    // the iterator tuple.
    void decrement()
-    { 
+    {
      detail::tuple_impl_specific::tuple_for_each(
        m_iterator_tuple,
        detail::decrement_iterator()
        );
    }
-    
+
    // Distance is calculated using the first iterator in the tuple.
    template<typename OtherIteratorTuple>
      typename super_t::difference_type distance_to(
        const zip_iterator<OtherIteratorTuple>& other
        ) const
-    { 
-        return boost::tuples::get<0>(other.get_iterator_tuple()) - 
+    {
+        return boost::tuples::get<0>(other.get_iterator_tuple()) -
            boost::tuples::get<0>(this->get_iterator_tuple());
    }
-  
+
    // Data Members
    // ============
-    
+
    // The iterator tuple.
    IteratorTuple m_iterator_tuple;
- 
+
  };

  // Make function for zip iterator
  //
-  template<typename IteratorTuple> 
-  zip_iterator<IteratorTuple> 
+  template<typename IteratorTuple>
+  inline zip_iterator<IteratorTuple>
  make_zip_iterator(IteratorTuple t)
  { return zip_iterator<IteratorTuple>(t); }

-}
+} // namespace iterators
+
+using iterators::zip_iterator;
+using iterators::make_zip_iterator;
+
+} // namespace boost

 #endif
--- a/include/boost/pending/detail/int_iterator.hpp
+++ b/include/boost/pending/detail/int_iterator.hpp
@ -15,6 +15,7 @@

 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
 namespace boost {
+namespace iterators {
 #endif

 // this should use random_access_iterator_helper but I've had
@ -61,13 +62,19 @@ inline int_iterator<IntT>
 operator+(IntT n, int_iterator<IntT> t) { t += n; return t; }

 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+} /* namespace iterators */
+
+using iterators::int_iterator;
+
 } /* namespace boost */
 #endif

 #ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
 namespace boost {
-  using ::int_iterator;
-}
+using ::int_iterator;
+namespace iterators {
+using ::int_iterator;
+}}
 #endif


--- a/include/boost/pending/iterator_tests.hpp
+++ b/include/boost/pending/iterator_tests.hpp
@ -29,11 +29,11 @@
 namespace boost {

  // use this for the value type
-struct dummyT { 
+struct dummyT {
  dummyT() { }
  dummyT(detail::dummy_constructor) { }
  dummyT(int x) : m_x(x) { }
-  int foo() const { return m_x; } 
+  int foo() const { return m_x; }
  bool operator==(const dummyT& d) const { return m_x == d.m_x; }
  int m_x;
 };
@ -41,9 +41,10 @@ struct dummyT {
 }

 namespace boost {
+namespace iterators {

 // Tests whether type Iterator satisfies the requirements for a
-// TrivialIterator. 
+// TrivialIterator.
 // Preconditions: i != j, *i == val
 template <class Iterator, class T>
 void trivial_iterator_test(const Iterator i, const Iterator j, T val)
@ -84,7 +85,7 @@ void mutable_trivial_iterator_test(const Iterator i, const Iterator j, T val)

 // Preconditions: *i == v1, *++i == v2
 template <class Iterator, class T>
-void input_iterator_test(Iterator i, T v1, T v2) 
+void input_iterator_test(Iterator i, T v1, T v2)
 {
  Iterator i1(i);

@ -150,7 +151,7 @@ template <> struct lvalue_test<true> {
 #endif

 template <class Iterator, class T>
-void forward_iterator_test(Iterator i, T v1, T v2) 
+void forward_iterator_test(Iterator i, T v1, T v2)
 {
  input_iterator_test(i, v1, v2);

@ -215,7 +216,7 @@ void random_access_iterator_test(Iterator i, int N, TrueVals vals)
  int c;

  typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
-  
+
  for (c = 0; c < N-1; ++c) {
    assert(i == j + c);
    assert(*i == vals[c]);
@ -234,7 +235,7 @@ void random_access_iterator_test(Iterator i, int N, TrueVals vals)
    assert(i == k - c);
    assert(*i == vals[N - 1 - c]);
    assert(*i == boost::implicit_cast<value_type>(j[N - 1 - c]));
-    Iterator q = k - c; 
+    Iterator q = k - c;
    assert(*i == *q);
    assert(i > j);
    assert(i >= j);
@ -260,6 +261,18 @@ void const_nonconst_iterator_test(Iterator i, ConstIterator j)
  assert(i == k);
 }

+} // namespace iterators
+
+using iterators::undefined;
+using iterators::trivial_iterator_test;
+using iterators::mutable_trivial_iterator_test;
+using iterators::input_iterator_test;
+using iterators::lvalue_test;
+using iterators::forward_iterator_test;
+using iterators::bidirectional_iterator_test;
+using iterators::random_access_iterator_test;
+using iterators::const_nonconst_iterator_test;
+
 } // namespace boost

 #endif // BOOST_ITERATOR_TESTS_HPP
--- a/include/boost/pointee.hpp
+++ b/include/boost/pointee.hpp
@ -20,7 +20,7 @@
 # include <boost/mpl/if.hpp>
 # include <boost/mpl/eval_if.hpp>

-namespace boost { 
+namespace boost {

 namespace detail
 {
@ -34,25 +34,25 @@ namespace detail
  struct iterator_pointee
  {
      typedef typename iterator_traits<Iterator>::value_type value_type;
-      
+
      struct impl
      {
          template <class T>
          static char test(T const&);
-          
+
          static char (& test(value_type&) )[2];
-          
+
          static Iterator& x;
      };
-      
+
      BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
-      
+
      typedef typename mpl::if_c<
 #  if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
          ::boost::detail::iterator_pointee<Iterator>::is_constant
 #  else
          is_constant
-#  endif 
+#  endif
        , typename add_const<value_type>::type
        , value_type
      >::type type;
@ -68,7 +68,7 @@ struct pointee
    >
 {
 };
-  
+
 } // namespace boost

 #endif // POINTEE_DWA200415_HPP
--- a/include/boost/shared_container_iterator.hpp
+++ b/include/boost/shared_container_iterator.hpp
@ -13,6 +13,7 @@
 #include <utility>

 namespace boost {
+namespace iterators {

 template <typename Container>
 class shared_container_iterator : public iterator_adaptor<
@ -37,7 +38,7 @@ public:
 };

 template <typename Container>
-shared_container_iterator<Container>
+inline shared_container_iterator<Container>
 make_shared_container_iterator(typename Container::iterator iter,
                               boost::shared_ptr<Container> const& container) {
  typedef shared_container_iterator<Container> iterator;
@ -47,7 +48,7 @@ make_shared_container_iterator(typename Container::iterator iter,


 template <typename Container>
-std::pair<
+inline std::pair<
  shared_container_iterator<Container>,
  shared_container_iterator<Container> >
 make_shared_container_range(boost::shared_ptr<Container> const& container) {
@ -57,6 +58,12 @@ make_shared_container_range(boost::shared_ptr<Container> const& container) {
      make_shared_container_iterator(container->end(),container));
 }

+} // namespace iterators
+
+using iterators::shared_container_iterator;
+using iterators::make_shared_container_iterator;
+using iterators::make_shared_container_range;

 } // namespace boost
+
 #endif  // SHARED_CONTAINER_ITERATOR_RG08102002_HPP
--- a/index.html
+++ b/index.html
--- a/meta/libraries.json
+++ b/meta/libraries.json
@ -0,0 +1,18 @@
+{
+    "key": "iterator",
+    "name": "Iterator",
+    "authors": [
+        "Dave Abrahams",
+        "Jeremy Siek",
+        "Thomas Witt"
+    ],
+    "description": "The Boost Iterator Library contains two parts. The first is a system of concepts which extend the C++ standard iterator requirements. The second is a framework of components for building iterators based on these extended concepts and includes several useful iterator adaptors.",
+    "category": [
+        "Iterators"
+    ],
+    "maintainers": [
+        "David Abrahams <dave -at- boost-consulting.com>",
+        "Thomas Witt <witt - at - acm.org>",
+        "Jeffrey Lee Hellrung Jr. <jeffrey.hellrung -at- gmail.com>"
+    ]
+}
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -3,28 +3,28 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

 test-suite iterator
-  : 
+  :
    # These first two tests will run last, and are expected to fail
    # for many less-capable compilers.
-  
+
    [ compile-fail interoperable_fail.cpp ]
    # test uses expected success, so that we catch unrelated
    # compilation problems.
-    [ run is_convertible_fail.cpp ]  
+    [ run is_convertible_fail.cpp ]

    [ run zip_iterator_test.cpp
-        : : : 
-        
+        : : :
+
        # stlport's debug mode generates long symbols which overwhelm
        # vc6
-        #<msvc-stlport><*><runtime-build>release 
+        #<msvc-stlport><*><runtime-build>release
    ]
-      
+
    # These tests should work for just about everything.
    [ compile is_lvalue_iterator.cpp ]
    [ compile is_readable_iterator.cpp ]
    [ compile pointee.cpp ]
-      
+
    [ run unit_tests.cpp ]
    [ run concept_tests.cpp ]
    [ run iterator_adaptor_cc.cpp ]
@ -41,8 +41,12 @@ test-suite iterator
    [ run counting_iterator_test.cpp ]
    [ run interoperable.cpp ]
    [ run iterator_traits_test.cpp ]
-    [ run permutation_iterator_test.cpp : : : # <stlport-iostream>on 
+    [ run permutation_iterator_test.cpp : : : # <stlport-iostream>on
    ]
    [ run function_input_iterator_test.cpp ]
-      
+
+    [ run generator_iterator_test.cpp ]
+
+    [ run minimum_category.cpp ]
+    [ compile-fail minimum_category_compile_fail.cpp ]
 ;
--- a/test/constant_iter_arrow.cpp
+++ b/test/constant_iter_arrow.cpp
--- a/test/constant_iter_arrow_fail.cpp
+++ b/test/constant_iter_arrow_fail.cpp
--- a/test/interoperable.cpp
+++ b/test/interoperable.cpp
--- a/test/iter_archetype_default_ctor.cpp
+++ b/test/iter_archetype_default_ctor.cpp
--- a/test/minimum_category.cpp
+++ b/test/minimum_category.cpp
@ -0,0 +1,22 @@
+// Copyright Andrey Semashev 2014.
+//
+// Use, modification and distribution is subject to
+// 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)
+
+#include <boost/iterator/minimum_category.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <iterator>
+
+using boost::is_same;
+using boost::iterators::minimum_category;
+
+int main(int, char*[])
+{
+    BOOST_TEST_TRAIT_TRUE((is_same<minimum_category<std::forward_iterator_tag, std::random_access_iterator_tag>::type, std::forward_iterator_tag>));
+    BOOST_TEST_TRAIT_TRUE((is_same<minimum_category<std::random_access_iterator_tag, std::forward_iterator_tag>::type, std::forward_iterator_tag>));
+    BOOST_TEST_TRAIT_TRUE((is_same<minimum_category<std::random_access_iterator_tag, std::random_access_iterator_tag>::type, std::random_access_iterator_tag>));
+
+    return boost::report_errors();
+}
--- a/test/minimum_category_compile_fail.cpp
+++ b/test/minimum_category_compile_fail.cpp
@ -0,0 +1,19 @@
+// Copyright Andrey Semashev 2014.
+//
+// Use, modification and distribution is subject to
+// 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)
+
+#include <boost/iterator/minimum_category.hpp>
+
+using boost::iterators::minimum_category;
+
+struct A {};
+struct B {};
+
+int main(int, char*[])
+{
+    minimum_category<A, B>::type cat;
+
+    return 0;
+}
--- a/test/unit_tests.cpp
+++ b/test/unit_tests.cpp
@ -7,7 +7,7 @@

 #include "static_assert_same.hpp"

-#include <boost/iterator/detail/minimum_category.hpp>
+#include <boost/iterator/minimum_category.hpp>

 struct X { int a; };

@ -29,30 +29,30 @@ void operator_arrow_test()
 template <class T, class U, class Min>
 struct static_assert_min_cat
  : static_assert_same<
-       typename boost::detail::minimum_category<T,U>::type, Min
+       typename boost::iterators::minimum_category<T,U>::type, Min
    >
 {};

 void category_test()
 {
-    using namespace boost;
-    using namespace boost::detail;
-    
+    using namespace boost::iterators;
+    using namespace boost::iterators::detail;
+
    BOOST_STATIC_ASSERT((
        !boost::is_convertible<
            std::input_iterator_tag
          , input_output_iterator_tag>::value));
-    
+
    BOOST_STATIC_ASSERT((
        !boost::is_convertible<
            std::output_iterator_tag
          , input_output_iterator_tag>::value));
-    
+
    BOOST_STATIC_ASSERT((
        boost::is_convertible<
            input_output_iterator_tag
          , std::input_iterator_tag>::value));
-    
+
    BOOST_STATIC_ASSERT((
        boost::is_convertible<
            input_output_iterator_tag
@ -64,7 +64,7 @@ void category_test()
        boost::is_convertible<
            std::forward_iterator_tag
          , input_output_iterator_tag>::value));
-#endif 
+#endif

    int test = static_assert_min_cat<
        std::input_iterator_tag,input_output_iterator_tag, std::input_iterator_tag
@ -78,7 +78,7 @@ void category_test()
    test = static_assert_min_cat<
        input_output_iterator_tag,std::forward_iterator_tag, input_output_iterator_tag
    >::value;
-#endif 
+#endif

    test = static_assert_min_cat<
        std::input_iterator_tag,std::forward_iterator_tag, std::input_iterator_tag
@ -93,8 +93,8 @@ void category_test()
    test = static_assert_min_cat<
        std::output_iterator_tag,std::random_access_iterator_tag, std::output_iterator_tag
    >::value;
-#endif 
-    
+#endif
+
    (void)test;
 }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Noel Belcourt	46f9e1753f	Merge pull request #9 from boostorg/develop Merge develop into master Tested with gcc-4.2.1 on Darwin.	2014-09-06 11:18:28 -06:00
Noel Belcourt	adee905c51	Merge pull request #8 from Lastique/add_docs Add docs for iterator category and traversal manipulation tools. Thanks Andrey.	2014-08-23 16:14:52 -06:00
Andrey Semashev	82779f78ec	Added docs for iterator category and traversal manipulation tools.	2014-08-24 01:55:25 +04:00
Noel Belcourt	a569c97969	Merge pull request #6 from Lastique/publish-details Publish some of the implementation details Tested with clang-5.1 on darwin.	2014-08-23 14:08:11 -06:00
Noel Belcourt	aad821d28d	Merge pull request #7 from danieljames/metadata Create metadata file.	2014-08-23 13:53:06 -06:00
Daniel James	23934d7c0d	Add metadata file.	2014-08-18 15:00:20 +01:00
Andrey Semashev	1073b7f7bc	Adjustments for compatibility with commit `48dfb68045`.	2014-07-30 23:00:35 +04:00
Andrey Semashev	f158dba6ad	Moved minimum_category to the public namespace. Added tests.	2014-07-19 21:39:49 +04:00
Andrey Semashev	8fe632d6b1	Copied minimum_category.hpp to public headers.	2014-07-19 21:03:11 +04:00
Andrey Semashev	810b58cfb0	Moved pure_traversal_tag to public namespace. Also added an import into the boost::detail namespace for backward compatibility with Boost.Range. Added a pure_iterator_traversal metafunction that automatically converts iterator category as well.	2014-07-19 20:57:42 +04:00
Noel Belcourt	785680d929	Merge pull request #5 from Lastique/adl-protect Moved most components of the library to iterators:: namespace. Thanks Andrey.	2014-07-10 11:33:50 -06:00
Andrey Semashev	269de2691a	Added a workaround for boost/token_iteratpr.hpp which uses an implementation detail of this library.	2014-07-07 22:22:28 +04:00
Andrey Semashev	4a403cd3eb	Trim spaces.	2014-07-03 00:36:44 +04:00
Andrey Semashev	dc96d371fa	Moved most components of the library to iterators:: namespace. This change excludes boost:: and boost::detail:: namespaces from ADL for unqualified function calls (e.g. algorithms). This reduces the possibility of name clashes with other libraries and user's code. One of the effects should be fixing test failures on gcc 4.2 and 4.4 due to clashed with Boost.TypeTraits. Also some of the functions marked with inline keyword.	2014-07-03 00:22:45 +04:00
Noel Belcourt	e000b676cc	Merge pull request #4 from Lastique/sfinae-based-operators Make iterator operators conditionally defined depending on its category. Looks okay and fixes several known problems, thanks Andrey.	2014-06-30 16:49:53 -06:00
Daniel James	045a05f81f	Run generator_iterator_test.cpp I accidentally removed it in `8e5b8025d8`.	2014-06-30 10:59:03 +01:00
Daniel James	25139e1311	Remove operator_brackets_dispatch.hpp I should have removed it in `8e5b8025d8`.	2014-06-30 10:53:35 +01:00
Andrey Semashev	7fa65a4278	Made iterator operators conditionally defined depending on its category. This makes iterators defined using iterator_facade more friendly to type inspection and fixes its use with next()/prior() since commit `651a869d4f`. The arithmetic, indexing and relational operators are only defined if the iterator category or traversal permits that. Note that the implementation requires partial template specialization support now.	2014-06-30 00:05:38 +04:00
Andrey Semashev	fd94cc7d78	Removed executable flags from docs, tests and examples.	2014-06-29 15:49:05 +04:00
Andrey Semashev	36988fcf98	Removed executable flags from headers.	2014-06-29 15:42:47 +04:00
Daniel James	91f782ec52	Merge branch 'feature/remove-old-compiler-support' into develop	2014-06-26 11:46:39 +01:00
Daniel James	e88b3f475c	Remove the the broken compiler notes. Now that the workarounds have been removed, they no longer apply.	2014-06-06 23:03:04 +01:00
Daniel James	01cffbed98	Rebuild iterator_traits.html using latest docutils.	2014-06-06 23:03:04 +01:00
Daniel James	187bc896f6	BOOST_ITERATOR_CATEGORY shouldn't be removed. Since it was documented, it should be kept for backwards compatiblity.	2014-06-06 23:03:03 +01:00
Stephen Kelly	6883d083d2	Iterator: Remove obsolete MSVC version checks. [SVN r86082] Conflicts: include/boost/iterator/iterator_facade.hpp	2014-06-06 23:03:03 +01:00
Stephen Kelly	0345db959b	Remove use of BOOST_ITERATOR_CATEGORY [SVN r86056]	2014-06-06 23:03:03 +01:00
Stephen Kelly	d814423414	Iterator: Remove obsolete GCC version check. [SVN r86055]	2014-06-06 23:03:03 +01:00
Stephen Kelly	eb288b2908	Iterator: Remove use of eti baseclass workaround. [SVN r85940]	2014-06-06 23:03:03 +01:00