Merge remote-tracking branch 'origin/develop'

2026-01-23 17:42:50 +00:00 · 2014-06-26 11:53:43 +01:00
123 changed files with 2188 additions and 2456 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.11: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.5: http://docutils.sourceforge.net/" />
 <title>Iterator Traits</title>
 <meta name="author" content="David Abrahams" />
 <meta name="organization" content="Boost Consulting" />
-<meta name="date" content="$Date$" />
+<meta name="date" content="2006-09-11" />
 <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>$Date$</td></tr>
+<td>2006-09-11</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">&lt;boost/iterator/iterator_traits.hpp&gt;</tt> provides
+<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
 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">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,
+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,
 such a &quot;multi-valued&quot; traits template can be difficult to use in a
-metaprogramming context.  <tt class="docutils literal">&lt;boost/iterator/iterator_traits.hpp&gt;</tt>
+metaprogramming context.  <tt class="docutils literal"><span class="pre">&lt;boost/iterator/iterator_traits.hpp&gt;</span></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">&lt;boost/iterator/iterator_traits.hpp&gt;</tt>:</p>
+<p>Header <tt class="docutils literal"><span class="pre">&lt;boost/iterator/iterator_traits.hpp&gt;</span></tt>:</p>
 <pre class="literal-block">
 template &lt;class Iterator&gt;
 struct iterator_value
@@ -98,6 +98,21 @@ 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,3 +75,24 @@ 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/adaptor.qbk
+++ b/doc/quickbook/adaptor.qbk
@@ -132,7 +132,7 @@ above are defined as follows:

  iterator_adaptor();

-[*Requires:] The `Base` type must be Default Constructible.[br]
+[*Requires:] The `Base` type must be Default Constructible.\n
 [*Returns:] An instance of `iterator_adaptor` with 
    `m_iterator` default constructed.

@@ -206,7 +206,7 @@ we're going to pick up right where it left off.
 .. |fac_tut| replace:: `iterator_facade` tutorial
 .. _fac_tut: iterator_facade.html#tutorial-example

-[blurb [*`node_base*` really *is* an iterator][br][br]
+[blurb [*`node_base*` really *is* an iterator]\n\n
  It's not really a very interesting iterator, since `node_base`
  is an abstract class: a pointer to a `node_base` just points
  at some base subobject of an instance of some other class, and
--- a/doc/quickbook/concepts.qbk
+++ b/doc/quickbook/concepts.qbk
@@ -156,7 +156,7 @@ semantics.
  [
    [`++r`]
    [`X&`]
-    [pre:[br]`r` is dereferenceable;[br]post:[br]`r` is dereferenceable or[br]`r` is past-the-end]
+    [pre:\n`r` is dereferenceable;\npost:\n`r` is dereferenceable or\n`r` is past-the-end]
  ]
  [
    [`a == b`]
@@ -227,7 +227,7 @@ the stated semantics.
  [
    [`--r`]
    [`X&`]
-    [pre: there exists `s` such that `r == ++s`.[br] post: `s` is dereferenceable. `--(++r) == r`. `--r == --s` implies `r == s`. `&r == &--r`.]
+    [pre: there exists `s` such that `r == ++s`.\n post: `s` is dereferenceable. `--(++r) == r`. `--r == --s` implies `r == s`. `&r == &--r`.]
  ]
  [
    [`r--`]
--- a/doc/quickbook/counting_iterator.qbk
+++ b/doc/quickbook/counting_iterator.qbk
@@ -152,7 +152,7 @@ operations.

  counting_iterator();

-[*Requires: ] `Incrementable` is Default Constructible.[br]
+[*Requires: ] `Incrementable` is Default Constructible.\n
 [*Effects: ] Default construct the member `m_inc`.


@@ -174,13 +174,13 @@ operations.

  counting_iterator& operator++();

-[*Effects: ] `++m_inc`[br]
+[*Effects: ] `++m_inc`\n
 [*Returns: ] `*this`


  counting_iterator& operator--();

-[*Effects: ] `--m_inc`[br]
+[*Effects: ] `--m_inc`\n
 [*Returns: ] `*this`  


--- a/doc/quickbook/facade.qbk
+++ b/doc/quickbook/facade.qbk
@@ -68,7 +68,6 @@ requirements.
  [
    [`i.dereference()`]
    [Access the value referred to]
-  ]
  [
    [`i.equal(j)`]
    [Compare for equality with `j`]
@@ -84,7 +83,6 @@ requirements.
  [
    [`i.advance(n)`]
    [Advance by `n` positions]
-  ]
  [
    [`i.distance_to(j)`]
    [Measure the distance to `j`]
@@ -489,8 +487,7 @@ w.m)` for some temporary object `w` of type `value_type`.
              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);

 [*Returns:]
-
-[pre
+ 
  if `is_convertible<Dr2,Dr1>::value`

  then 
@@ -498,7 +495,6 @@ w.m)` for some temporary object `w` of type `value_type`.

  Otherwise, 
    `((Dr2 const&)rhs).equal((Dr1 const&)lhs)`.
-]


  template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -509,7 +505,6 @@ w.m)` for some temporary object `w` of type `value_type`.

 [*Returns:]
 
-[pre
  if `is_convertible<Dr2,Dr1>::value`

  then 
@@ -517,7 +512,6 @@ w.m)` for some temporary object `w` of type `value_type`.

  Otherwise, 
    `!((Dr2 const&)rhs).equal((Dr1 const&)lhs)`.
-]


  template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -528,7 +522,6 @@ w.m)` for some temporary object `w` of type `value_type`.

 [*Returns:]
 
-[pre
  if `is_convertible<Dr2,Dr1>::value`

  then 
@@ -536,7 +529,6 @@ w.m)` for some temporary object `w` of type `value_type`.

  Otherwise, 
    `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) > 0`.
-]


  template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -547,7 +539,6 @@ w.m)` for some temporary object `w` of type `value_type`.

 [*Returns:]
 
-[pre
  if `is_convertible<Dr2,Dr1>::value`

  then 
@@ -555,7 +546,6 @@ w.m)` for some temporary object `w` of type `value_type`.

  Otherwise, 
    `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) >= 0`.
-]


  template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -566,7 +556,6 @@ w.m)` for some temporary object `w` of type `value_type`.

 [*Returns:]
 
-[pre
  if `is_convertible<Dr2,Dr1>::value`

  then 
@@ -574,7 +563,6 @@ w.m)` for some temporary object `w` of type `value_type`.

  Otherwise, 
    `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) < 0`.
-]


  template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -585,7 +573,6 @@ w.m)` for some temporary object `w` of type `value_type`.

 [*Returns:]
 
-[pre
  if `is_convertible<Dr2,Dr1>::value`

  then 
@@ -593,7 +580,6 @@ w.m)` for some temporary object `w` of type `value_type`.

  Otherwise, 
    `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) <= 0`.
-]

 .. _minus:

@@ -606,7 +592,6 @@ w.m)` for some temporary object `w` of type `value_type`.

 [*Return Type:]
 
-[pre
  if `is_convertible<Dr2,Dr1>::value`

   then 
@@ -615,11 +600,9 @@ w.m)` for some temporary object `w` of type `value_type`.

   Otherwise 
    `difference` shall be `iterator_traits<Dr2>::difference_type`
-]

 [*Returns:]
 
-[pre
  if `is_convertible<Dr2,Dr1>::value`

  then 
@@ -627,7 +610,6 @@ w.m)` for some temporary object `w` of type `value_type`.

  Otherwise, 
    `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs)`.
-]


 [endsect]
--- a/doc/quickbook/facade_tutorial.qbk
+++ b/doc/quickbook/facade_tutorial.qbk
@@ -261,17 +261,17 @@ __ ../example/node_iterator1.cpp

 [h2 A constant `node_iterator`]

-[blurb *Constant and Mutable iterators*[br][br]
+[blurb *Constant and Mutable iterators*\n\n
 The term **mutable iterator** means an iterator through which
 the object it references (its "referent") can be modified.  A
 **constant iterator** is one which doesn't allow modification of
-its referent.[br][br]  
+its referent.\n\n  
 The words *constant* and *mutable* don't refer to the ability to
 modify the iterator itself.  For example, an `int const*` is a
 non-\ `const` *constant iterator*, which can be incremented
 but doesn't allow modification of its referent, and `int*
 const` is a `const` *mutable iterator*, which cannot be
-modified but which allows modification of its referent.[br][br]
+modified but which allows modification of its referent.\n\n
 Confusing?  We agree, but those are the standard terms.  It
 probably doesn't help much that a container's constant iterator
 is called `const_iterator`.
@@ -312,7 +312,7 @@ changes:
      node_base **const**\ * m_node;
  };

-[blurb `const` and an iterator's `value_type`[br][br]
+[blurb `const` and an iterator's `value_type`\n\n
 The C++ standard requires an iterator's `value_type` *not* be
 `const`\ -qualified, so `iterator_facade` strips the
 `const` from its `Value` parameter in order to produce the
--- a/doc/quickbook/filter_iterator.qbk
+++ b/doc/quickbook/filter_iterator.qbk
@@ -178,7 +178,7 @@ operations.

  filter_iterator();

-[*Requires: ]`Predicate` and `Iterator` must be Default Constructible.[br]
+[*Requires: ]`Predicate` and `Iterator` must be Default Constructible.\n
 [*Effects: ] Constructs a `filter_iterator` whose`m_pred`,  `m_iter`, and `m_end` 
  members are a default constructed.

@@ -195,7 +195,7 @@ operations.
  filter_iterator(Iterator x, Iterator end = Iterator());

 [*Requires: ] `Predicate` must be Default Constructible and
-  `Predicate` is a class type (not a function pointer).[br]
+  `Predicate` is a class type (not a function pointer).\n
 [*Effects: ] Constructs a `filter_iterator` where `m_iter` is either
    the first position in the range `[x,end)` such that `m_pred(*m_iter) == true` 
    or else`m_iter == end`. The member `m_pred` is default constructed.
@@ -205,9 +205,9 @@ operations.
    filter_iterator(
        filter_iterator<Predicate, OtherIterator> const& t
        , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
-        );
+        );`

-[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.[br]
+[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.\n
 [*Effects: ] Constructs a filter iterator whose members are copied from `t`.


@@ -235,7 +235,7 @@ operations.

 [*Effects: ] Increments `m_iter` and then continues to
  increment `m_iter` until either `m_iter == m_end`
-  or `m_pred(*m_iter) == true`.[br]
+  or `m_pred(*m_iter) == true`.\n
 [*Returns: ] `*this`  


--- a/doc/quickbook/indirect_iterator.qbk
+++ b/doc/quickbook/indirect_iterator.qbk
@@ -203,7 +203,7 @@ following operations:

  indirect_iterator();

-[*Requires: ] `Iterator` must be Default Constructible.[br]
+[*Requires: ] `Iterator` must be Default Constructible.\n
 [*Effects: ] Constructs an instance of `indirect_iterator` with 
   a default-constructed `m_iterator`.

@@ -225,7 +225,7 @@ following operations:
    , typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
  );

-[*Requires: ] `Iterator2` is implicitly convertible to `Iterator`.[br]
+[*Requires: ] `Iterator2` is implicitly convertible to `Iterator`.\n
 [*Effects: ] Constructs an instance of `indirect_iterator` whose 
    `m_iterator` subobject is constructed from `y.base()`.

@@ -242,13 +242,13 @@ following operations:

  indirect_iterator& operator++();

-[*Effects: ] `++m_iterator`[br]
+[*Effects: ] `++m_iterator`\n
 [*Returns: ] `*this`


  indirect_iterator& operator--();

-[*Effects: ] `--m_iterator`[br]
+[*Effects: ] `--m_iterator`\n
 [*Returns: ] `*this`

 [endsect]
--- a/doc/quickbook/iterator.qbk
+++ b/doc/quickbook/iterator.qbk
@@ -1,7 +1,6 @@

 [library Boost.Iterator
    [/ version 1.0.1]
-    [quickbook 1.6]
    [authors [Abrahams, David], [Siek, Jeremy], [Witt, Thomas]]
    [copyright 2003 2005 David Abrahams Jeremy Siek Thomas Witt]
    [category iterator]
@@ -100,7 +99,7 @@ adaptors`_ mentioned below have been proposed for standardization

 The iterator library supplies a useful suite of standard-conforming
 iterator templates based on the Boost [link
-iterator.intro.iterator_facade_and_adaptor iterator facade and adaptor]
+intro.iterator_facade_and_adaptor iterator facade and adaptor]
 templates.

 [def _counting_    [@./counting_iterator.html         `counting_iterator`]]
--- a/doc/quickbook/permutation_iterator.qbk
+++ b/doc/quickbook/permutation_iterator.qbk
@@ -189,7 +189,7 @@ following operations.

  permutation_iterator& operator++();

-[*Effects: ] `++m_order`[br]
+[*Effects: ] `++m_order`\n
 [*Returns: ] `*this`


--- a/doc/quickbook/reverse_iterator.qbk
+++ b/doc/quickbook/reverse_iterator.qbk
@@ -115,7 +115,7 @@ operations.

  reverse_iterator();

-[*Requires: ] `Iterator` must be Default Constructible.[br]
+[*Requires: ] `Iterator` must be Default Constructible.\n
 [*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator` 
  default constructed.

@@ -131,7 +131,7 @@ operations.
      , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
    );

-[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.[br]
+[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.\n
 [*Effects: ] Constructs instance of `reverse_iterator` whose 
    `m_iterator` subobject is constructed from `y.base()`.

@@ -149,12 +149,12 @@ operations.

  reverse_iterator& operator++();

-[*Effects: ] `--m_iterator`[br]
+[*Effects: ] `--m_iterator`\n
 [*Returns: ] `*this`

  reverse_iterator& operator--();

-[*Effects: ] `++m_iterator`[br]
+[*Effects: ] `++m_iterator`\n
 [*Returns: ] `*this`

 [endsect]
--- a/doc/quickbook/traits.qbk
+++ b/doc/quickbook/traits.qbk
@@ -52,4 +52,21 @@ Header `<boost/iterator/iterator_traits.hpp>`:
      type;
  };

-[endsect]
+[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]
--- a/doc/quickbook/transform_iterator.qbk
+++ b/doc/quickbook/transform_iterator.qbk
@@ -85,7 +85,7 @@ The source code for this example can be found


 If `Reference` is `use_default` then the `reference` member of
-`transform_iterator` is[br]
+`transform_iterator` is\n
 `result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
 Otherwise, `reference` is `Reference`.

@@ -160,7 +160,7 @@ interoperable with `Y`.

 [h3 Operations]

-In addition to the operations required by the [link iterator.specialized.transform.concepts concepts] modeled by
+In addition to the operations required by the [link transform.concepts concepts] modeled by
 `transform_iterator`, `transform_iterator` provides the following
 operations:

@@ -183,7 +183,7 @@ operations:

 [*Returns: ] An instance of `transform_iterator` with `m_f`
  initialized to `t.functor()` and `m_iterator` initialized to
-  `t.base()`.[br]
+  `t.base()`.\n
 [*Requires: ]  `OtherIterator` is implicitly convertible to `Iterator`.


@@ -204,13 +204,13 @@ operations:

 transform_iterator& operator++();

-[*Effects: ] `++m_iterator`[br]
+[*Effects: ] `++m_iterator`\n
 [*Returns: ]  `*this`


  transform_iterator& operator--();

-[*Effects: ]  `--m_iterator`[br]
+[*Effects: ]  `--m_iterator`\n
 [*Returns: ] `*this`

 [endsect]
--- a/doc/quickbook/utilities.qbk
+++ b/doc/quickbook/utilities.qbk
@@ -49,40 +49,11 @@ 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 iterator.specialized.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`.
+[link indirecct `indirect_iterator`].

 [h2 Reference]

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

  template <class Dereferenceable>
  struct pointee
@@ -103,9 +74,9 @@ or not), these additional tags are not considered.

  if ( ++x is ill-formed )
  {
-      return Dereferenceable::element_type
+      return `Dereferenceable::element_type`
  }
-  else if (*x is a mutable reference to
+  else if (`*x` is a mutable reference to
           std::iterator_traits<Dereferenceable>::value_type)
  {
      return iterator_traits<Dereferenceable>::value_type
@@ -135,81 +106,10 @@ or not), these additional tags are not considered.
 `x` is an object of type `Dereferenceable`:

  if ( ++x is ill-formed )
-      return pointee<Dereferenceable>::type&
+      return `pointee<Dereferenceable>::type&`
  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]

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

 [endsect]

-[endsect]
+[endsect]
--- a/doc/quickbook/zip_iterator.qbk
+++ b/doc/quickbook/zip_iterator.qbk
@@ -8,16 +8,6 @@ the zip iterator moves all the iterators in parallel.
 Dereferencing the zip iterator returns a tuple that contains
 the results of dereferencing the individual iterators. 

-The tuple of iterators is now implemented in terms of a Boost fusion sequence. 
-Because of this the 'tuple' may be any Boost fusion sequence and, for backwards
-compatibility through a Boost fusion sequence adapter, a Boost tuple. Because the 
-'tuple' may be any boost::fusion sequence the 'tuple' may also be any type for which a 
-Boost fusion adapter exists. This includes, among others, a std::tuple and a std::pair.
-Just remember to include the appropriate Boost fusion adapter header files for these
-other Boost fusion adapters. The zip_iterator header file already includes the
-Boost fusion adapter header file for Boost tuple, so you need not include it yourself
-to use a Boost tuple as your 'tuple'.
-
 [section:zip_example Example]

 There are two main types of applications of the `zip_iterator`. The first
@@ -228,7 +218,7 @@ operations.
              , IteratorTuple>::type* = 0     // exposition only
    );

-[*Returns:] An instance of `zip_iterator` that is a copy of `other`.[br]
+[*Returns:] An instance of `zip_iterator` that is a copy of `other`.\n
 [*Requires:] `OtherIteratorTuple` is implicitly convertible to `IteratorTuple`.


@@ -245,13 +235,13 @@ operations.

  zip_iterator& operator++();

-[*Effects:] Increments each iterator in `m_iterator_tuple`.[br]
+[*Effects:] Increments each iterator in `m_iterator_tuple`.\n
 [*Returns:] `*this`


  zip_iterator& operator--();

-[*Effects:] Decrements each iterator in `m_iterator_tuple`.[br]
+[*Effects:] Decrements each iterator in `m_iterator_tuple`.\n
 [*Returns:] `*this`

    template<typename IteratorTuple> 
--- 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
@@ -8,13 +8,3 @@ iterator is constructed from a tuple of iterators. Moving
 the zip iterator moves all the iterators in parallel.
 Dereferencing the zip iterator returns a tuple that contains
 the results of dereferencing the individual iterators. 
-
-The tuple of iterators is now implemented in terms of a Boost fusion sequence. 
-Because of this the 'tuple' may be any Boost fusion sequence and, for backwards
-compatibility through a Boost fusion sequence adapter, a Boost tuple. Because the 
-'tuple' may be any boost::fusion sequence the 'tuple' may also be any type for which a 
-Boost fusion adapter exists. This includes, among others, a std::tuple and a std::pair.
-Just remember to include the appropriate Boost fusion adapter header files for these
-other Boost fusion adapters. The zip_iterator header file already includes the
-Boost fusion adapter header file for Boost tuple, so you need not include it yourself
-to use a Boost tuple as your 'tuple'.
--- 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,7 +14,6 @@
 #include <iterator>

 namespace boost {
-namespace iterators {

  template <class UnaryFunction>
  class function_output_iterator {
@@ -34,13 +33,13 @@ namespace iterators {
    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;
@@ -52,11 +51,6 @@ namespace iterators {
    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,7 +17,6 @@
 #include <boost/ref.hpp>

 namespace boost {
-namespace iterators {

 template<class Generator>
 class generator_iterator
@@ -34,7 +33,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)()) {}
@@ -74,12 +73,8 @@ 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,7 +13,6 @@
 # include <boost/mpl/eval_if.hpp>

 namespace boost {
-namespace iterators {

 template <
    class Incrementable
@@ -31,13 +30,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 = (
@@ -47,20 +46,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::iterators::detail::is_numeric_impl<T>::value)>
+    : mpl::bool_<(::boost::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_ {};
@@ -70,7 +69,7 @@ namespace detail
  template <>
  struct is_numeric<wchar_t>
    : mpl::true_ {};
-
+  
  template <class T>
  struct numeric_difference
  {
@@ -78,7 +77,7 @@ namespace detail
  };

  BOOST_STATIC_ASSERT(is_numeric<int>::value);
-
+  
  template <class Incrementable, class CategoryOrTraversal, class Difference>
  struct counting_iterator_base
  {
@@ -90,7 +89,7 @@ namespace detail
            , iterator_traversal<Incrementable>
          >
      >::type traversal;
-
+      
      typedef typename detail::ia_dflt_help<
          Difference
        , mpl::eval_if<
@@ -99,7 +98,7 @@ namespace detail
            , iterator_difference<Incrementable>
          >
      >::type difference;
-
+      
      typedef iterator_adaptor<
          counting_iterator<Incrementable, CategoryOrTraversal, Difference> // self
        , Incrementable                                           // Base
@@ -107,7 +106,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
@@ -137,7 +136,7 @@ namespace detail
  {
      static Difference distance(Incrementable1 x, Incrementable2 y)
      {
-          return boost::detail::numeric_distance(x, y);
+          return numeric_distance(x, y);
      }
  };
 }
@@ -155,14 +154,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)
@@ -178,10 +177,10 @@ class counting_iterator
    )
      : super_t(t.base())
    {}
-# endif
+# endif 

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

-} // namespace iterators

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

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

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

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

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

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

 #endif

-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                      \
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                       \
+    || 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))
@@ -87,7 +88,8 @@
 #  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
 #endif

-#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
+#if BOOST_WORKAROUND(__GNUC__, == 2)                                                                            \
+    || 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:

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

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

-// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
+# 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
 // 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,6 +14,7 @@
 #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,8 +70,11 @@ 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,13 +30,10 @@
 // iterator_category deduction for iterator_facade
 //

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

-namespace detail {
+namespace boost { namespace detail  {

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


@@ -99,7 +96,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>
            >
@@ -135,6 +132,7 @@ 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.
@@ -149,7 +147,8 @@ 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
@@ -157,12 +156,14 @@ 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
@@ -186,7 +187,7 @@ struct facade_iterator_category
 {
 };

-}}} // namespace boost::iterators::detail
+}} // namespace boost::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,16 +4,113 @@
 #ifndef MINIMUM_CATEGORY_DWA20031119_HPP
 # define MINIMUM_CATEGORY_DWA20031119_HPP

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

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

-// 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
+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 
+;

-} // namespace boost
+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

 #endif // MINIMUM_CATEGORY_DWA20031119_HPP
--- a/include/boost/iterator/detail/operator_brackets_dispatch.hpp
+++ b/include/boost/iterator/detail/operator_brackets_dispatch.hpp
@@ -0,0 +1,88 @@
+// (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,9 +14,8 @@
 #include <boost/type_traits/is_class.hpp>
 #include <boost/static_assert.hpp>

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

@@ -40,7 +39,7 @@ namespace iterators {
        > type;
    };
  }
-
+  
  template <class Predicate, class Iterator>
  class filter_iterator
    : public detail::filter_iterator_base<Predicate, Iterator>::type
@@ -69,7 +68,7 @@ namespace iterators {
          // 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();
      }

@@ -109,29 +108,28 @@ namespace iterators {
  };

  template <class Predicate, class Iterator>
-  inline filter_iterator<Predicate,Iterator>
+  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>
-  inline filter_iterator<Predicate,Iterator>
+  filter_iterator<Predicate,Iterator>
  make_filter_iterator(
      typename iterators::enable_if<
          is_class<Predicate>
        , Iterator
      >::type x
-    , Iterator end = Iterator())
+    , Iterator end = Iterator()
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    , Predicate* = 0
+#endif 
+  )
  {
      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,8 +20,6 @@

 namespace boost {

-namespace iterators {
-
    namespace impl {

        template <class Function, class Input>
@@ -35,7 +33,7 @@ namespace iterators {
        {
        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() {
@@ -46,7 +44,7 @@ namespace iterators {
                ++state;
            }

-            typename Function::result_type const &
+            typename Function::result_type const & 
                dereference() const {
                    return (value ? value : value = (*f)()).get();
            }
@@ -111,7 +109,7 @@ namespace iterators {
    } // 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>,
@@ -156,14 +154,7 @@ namespace iterators {
        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,13 +30,12 @@
 # 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 iterators {
-
+namespace boost
+{
  template <class Iter, class Value, class Category, class Reference, class Difference>
  class indirect_iterator;

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

-
+    
  template <
      class Iterator
    , class Value = use_default
@@ -108,14 +107,14 @@ namespace iterators {
        : 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 
      }
  };

@@ -133,11 +132,6 @@ namespace iterators {
    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 iterators {
+namespace boost
+{

  //
  // Meta function that determines whether two
@@ -27,7 +27,7 @@ namespace iterators {
  // 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,13 +40,9 @@ namespace iterators {
          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
@@ -9,21 +9,16 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/detail/iterator.hpp>

-#include <boost/type_traits/add_lvalue_reference.hpp>
 #include <boost/iterator/detail/any_conversion_eater.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/aux_/lambda_support.hpp>

 // should be the last #includes
-#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/detail/bool_trait_def.hpp>
 #include <boost/iterator/detail/config_def.hpp>

 #ifndef BOOST_NO_IS_CONVERTIBLE

 namespace boost {
-
-namespace iterators {
-
+ 
 namespace detail
 {
 #ifndef BOOST_NO_LVALUE_RETURN_DETECTION
@@ -31,20 +26,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,17 +50,17 @@ namespace detail
      // convertible to Value const&
      struct conversion_eater
      {
-          conversion_eater(typename add_lvalue_reference<Value>::type);
+          conversion_eater(Value&);
      };

      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 = (
@@ -80,7 +75,7 @@ namespace detail
  };

 #undef BOOST_LVALUE_PRESERVER
-
+  
  //
  // void specializations to handle std input and output iterators
  //
@@ -137,29 +132,19 @@ namespace detail
  {};
 } // namespace detail

-template< typename T > struct is_lvalue_iterator
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value>
-{
-public:
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_lvalue_iterator,(T))
-};
-
-template< typename T > struct is_non_const_lvalue_iterator
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value>
-{
-public:
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_non_const_lvalue_iterator,(T))
-};
-
-} // namespace iterators
-
-using iterators::is_lvalue_iterator;
-using iterators::is_non_const_lvalue_iterator;
-
+// 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)
+    
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+    is_non_const_lvalue_iterator,T,::boost::detail::is_non_const_lvalue_iterator_impl<T>::value)
+    
 } // namespace boost

 #endif

 #include <boost/iterator/detail/config_undef.hpp>
+#include <boost/type_traits/detail/bool_trait_undef.hpp>

 #endif // IS_LVALUE_ITERATOR_DWA2003112_HPP
--- a/include/boost/iterator/is_readable_iterator.hpp
+++ b/include/boost/iterator/is_readable_iterator.hpp
@@ -5,22 +5,18 @@
 # define IS_READABLE_ITERATOR_DWA2003112_HPP

 #include <boost/mpl/bool.hpp>
-#include <boost/mpl/aux_/lambda_support.hpp>
 #include <boost/detail/iterator.hpp>
-#include <boost/type_traits/add_lvalue_reference.hpp>

+#include <boost/type_traits/detail/bool_trait_def.hpp>
 #include <boost/iterator/detail/any_conversion_eater.hpp>

 // should be the last #include
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/iterator/detail/config_def.hpp>

 #ifndef BOOST_NO_IS_CONVERTIBLE

 namespace boost {
-
-namespace iterators {
-
+ 
 namespace detail
 {
  // Guts of is_readable_iterator.  Value is the iterator's value_type
@@ -28,14 +24,14 @@ namespace detail
  template <class Value>
  struct is_readable_iterator_impl
  {
-      static char tester(typename add_lvalue_reference<Value>::type, int);
+      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 = (
@@ -48,7 +44,7 @@ namespace detail
  };

 #undef BOOST_READABLE_PRESERVER
-
+  
  //
  // void specializations to handle std input and output iterators
  //
@@ -98,17 +94,11 @@ namespace detail
  {};
 } // namespace detail

-template< typename T > struct is_readable_iterator
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value>
-{
-public:
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_readable_iterator,(T))
-};
-
-} // namespace iterators
-
-using iterators::is_readable_iterator;
-
+// 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)
+    
 } // namespace boost

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

 #include <boost/iterator/iterator_traits.hpp>

-namespace boost {
-namespace iterators {
-
+namespace boost
+{
  // 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;
-
-} // 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 {
-
+  
+# 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 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.
@@ -78,7 +73,7 @@ namespace iterators {
  //   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
  // {
  // public:
-  //
+  //   
  //   ...
  //
  //   template <class OtherIterator>
@@ -97,23 +92,38 @@ namespace iterators {
  // 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 defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
-
+#  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)
+  
  template <class From, class To>
  struct enable_if_convertible
  {
-      typedef boost::iterators::detail::enable_type type;
+      typedef boost::detail::enable_type type;
  };
-
-#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))
-
+  
+#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC > 1300
+  
  // For some reason vc7.1 needs us to "cut off" instantiation
  // of is_convertible in a few cases.
  template<typename From, typename To>
@@ -123,22 +133,22 @@ namespace iterators {
            is_same<From,To>
          , is_convertible<From, To>
        >
-      , boost::iterators::detail::enable_type
+      , boost::detail::enable_type
    >
  {};
-
-#  else
-
+  
+#  else 
+  
  template<typename From, typename To>
  struct enable_if_convertible
    : iterators::enable_if<
          is_convertible<From, To>
-        , boost::iterators::detail::enable_type
+        , boost::detail::enable_type
      >
  {};
-
+      
 # endif
-
+  
  //
  // Default template argument handling for iterator_adaptor
  //
@@ -170,9 +180,9 @@ namespace iterators {
    {
        typedef iterator_facade<
            Derived
-
+            
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-          , typename boost::iterators::detail::ia_dflt_help<
+          , typename boost::detail::ia_dflt_help<
                Value
              , mpl::eval_if<
                    is_same<Reference,use_default>
@@ -181,17 +191,17 @@ namespace iterators {
                >
            >::type
 # else
-          , typename boost::iterators::detail::ia_dflt_help<
+          , typename boost::detail::ia_dflt_help<
                Value, iterator_value<Base>
            >::type
 # endif
-
-          , typename boost::iterators::detail::ia_dflt_help<
+            
+          , typename boost::detail::ia_dflt_help<
                Traversal
              , iterator_traversal<Base>
            >::type

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

-          , typename boost::iterators::detail::ia_dflt_help<
+          , typename boost::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 ()
@@ -214,7 +224,7 @@ namespace iterators {
      BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
    }
  }
-
+  
  //
  // Iterator Adaptor
  //
@@ -249,14 +259,14 @@ namespace iterators {
    , class Difference   = use_default
  >
  class iterator_adaptor
-    : public boost::iterators::detail::iterator_adaptor_base<
+    : public boost::detail::iterator_adaptor_base<
        Derived, Base, Value, Traversal, Reference, Difference
      >::type
  {
      friend class iterator_core_access;

   protected:
-      typedef typename boost::iterators::detail::iterator_adaptor_base<
+      typedef typename boost::detail::iterator_adaptor_base<
          Derived, Base, Value, Traversal, Reference, Difference
      >::type super_t;
   public:
@@ -275,7 +285,7 @@ namespace iterators {
   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
      //
@@ -291,13 +301,13 @@ namespace iterators {
      // 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
@@ -312,17 +322,17 @@ namespace iterators {
      >::type my_traversal;

 # define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
-      boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
+      boost::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;
@@ -330,7 +340,7 @@ namespace iterators {

      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
      {
@@ -343,16 +353,11 @@ namespace iterators {
      }

 # 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,6 +20,7 @@

 #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>
@@ -31,7 +32,6 @@
 #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 archetypes
+namespace iterator_archetypes
 {
  enum {
      readable_iterator_bit = 1
@@ -51,19 +51,19 @@ namespace 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,27 +119,29 @@ namespace detail

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

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

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

@@ -192,7 +196,7 @@ namespace detail
          explicit archetype(ctor_arg arg)
            : traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg)
          {}
-
+          
          typedef std::ptrdiff_t difference_type;
      };
  };
@@ -200,7 +204,13 @@ 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>
  {
@@ -208,7 +218,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())
          {}
      };
@@ -231,7 +241,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(); }
@@ -290,7 +300,7 @@ namespace detail


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

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

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

 template <>
 struct iterator_access_archetype_impl<
-    archetypes::writable_iterator_t
+    iterator_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;
@@ -342,13 +356,13 @@ struct iterator_access_archetype_impl<

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

 template <>
-struct iterator_access_archetype_impl<archetypes::readable_lvalue_iterator_t>
+struct iterator_access_archetype_impl<iterator_archetypes::readable_lvalue_iterator_t>
 {
    template <class Value>
    struct archetype
      : public virtual iterator_access_archetype<
-            Value, archetypes::readable_iterator_t
+            Value, iterator_archetypes::readable_iterator_t
        >
    {
        typedef Value&    reference;
@@ -372,26 +386,28 @@ struct iterator_access_archetype_impl<archetypes::readable_lvalue_iterator_t>
        Value* operator->() const { return 0; }
    };
 };
-
+  
 template <>
-struct iterator_access_archetype_impl<archetypes::writable_lvalue_iterator_t>
+struct iterator_access_archetype_impl<iterator_archetypes::writable_lvalue_iterator_t>
 {
    template <class Value>
    struct archetype
      : public virtual iterator_access_archetype<
-            Value, archetypes::readable_lvalue_iterator_t
+            Value, iterator_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
@@ -413,12 +429,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<
-              archetypes::has_access<
-                  AccessCategory, archetypes::writable_iterator_t
+              iterator_archetypes::has_access<
+                  AccessCategory, iterator_archetypes::writable_iterator_t
              >
            , remove_const<Value>
            , add_const<Value>
@@ -451,18 +467,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;
@@ -493,17 +509,7 @@ 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,7 +22,6 @@
 # include <boost/static_assert.hpp>

 namespace boost {
-namespace iterators {

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

 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
 {
@@ -66,7 +65,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
@@ -98,8 +97,51 @@ 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
 //
@@ -108,7 +150,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::iterators::detail::old_category_to_traversal<Cat>
+      , boost::detail::old_category_to_traversal<Cat>
    >
 {};

@@ -139,75 +181,6 @@ 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
-                    >
-                >
-            >
-        >
-    >
-{
-};
-
-//
-// 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,10 +248,19 @@ namespace boost_concepts
  BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
  {
   private:
-      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<
+              Iterator
+          >::type
+      >::type traversal_category;

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

@@ -262,7 +271,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,11 +7,9 @@
 #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>
@@ -22,7 +20,6 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_pointer.hpp>
-#include <boost/type_traits/add_lvalue_reference.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/is_convertible.hpp>
@@ -39,9 +36,8 @@

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

-namespace boost {
-namespace iterators {
-
+namespace boost
+{
  // This forward declaration is required for the friend declaration
  // in iterator_core_access
  template <class I, class V, class TC, class R, class D> class iterator_facade;
@@ -60,12 +56,6 @@ namespace iterators {
        };
    };

-    // 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.
    //
@@ -74,31 +64,28 @@ namespace iterators {
      , class Facade2
      , class Return
    >
-    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 >
+    struct enable_if_interoperable
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    {
+        typedef typename mpl::if_<
+            mpl::or_<
+                is_convertible<Facade1, Facade2>
+              , is_convertible<Facade2, Facade1>
            >
          , Return
+          , int[3]
+        >::type type;
+    };        
+#else
+      : ::boost::iterators::enable_if<
+           mpl::or_<
+               is_convertible<Facade1, Facade2>
+             , is_convertible<Facade2, Facade1>
+           >
+         , Return
        >
    {};
+#endif 

    //
    // Generates associated types for an iterator_facade with the
@@ -107,7 +94,7 @@ namespace iterators {
    template <
        class ValueParam
      , class CategoryOrTraversal
-      , class Reference
+      , class Reference 
      , class Difference
    >
    struct iterator_facade_types
@@ -115,16 +102,16 @@ namespace iterators {
        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::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
+            boost::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)))     \
@@ -170,7 +157,7 @@ namespace iterators {
     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
@@ -222,7 +209,7 @@ namespace iterators {
        {
            return stored_iterator;
        }
-
+        
     private:
        mutable value_type stored_value;
        Iterator stored_iterator;
@@ -234,7 +221,7 @@ namespace iterators {
    struct is_non_proxy_reference_impl
    {
        static Reference r;
-
+        
        template <class R>
        static typename mpl::if_<
            is_convertible<
@@ -244,17 +231,17 @@ namespace iterators {
          , 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<
@@ -263,8 +250,8 @@ namespace iterators {
          , 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
@@ -285,16 +272,8 @@ namespace iterators {
      : mpl::eval_if<
            mpl::and_<
                // A proxy is only needed for readable iterators
-                is_convertible<
-                    Reference
-                    // Use add_lvalue_reference to form `reference to Value` due to
-                    // some (strict) C++03 compilers (e.g. `gcc -std=c++03`) reject
-                    // 'reference-to-reference' in the template which described in CWG
-                    // DR106.
-                    // http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_defects.html#106
-                  , typename add_lvalue_reference<Value const>::type
-                >
-
+                is_convertible<Reference,Value const&>
+                
                // No multipass iterator can have values that disappear
                // before positions can be re-visited
              , mpl::not_<
@@ -346,6 +325,15 @@ namespace iterators {
        }
    };

+# 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)
@@ -390,7 +378,7 @@ namespace iterators {
            >
        >
    {};
-
+        
    template <class Iterator, class Value, class Reference>
    struct operator_brackets_result
    {
@@ -420,34 +408,28 @@ namespace iterators {
          :
 # ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
          iterator_difference<I1>
-# else
+# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+          mpl::if_<
+              is_convertible<I2,I1>
+            , typename I1::difference_type
+            , typename I2::difference_type
+          >
+# else 
          mpl::eval_if<
              is_convertible<I2,I1>
            , iterator_difference<I1>
            , iterator_difference<I2>
          >
-# endif
+# 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_IMPL(prefix, op, result_type, enabler)       \
+#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \
    template <                                                              \
        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
@@ -456,33 +438,24 @@ namespace iterators {
    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_IMPL(prefix, op, result_type, enabler)   \
+# else 
+#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)   \
    template <                                                          \
        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
    >                                                                   \
-    prefix typename enabler<                                            \
+    prefix typename boost::detail::enable_if_interoperable<             \
        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
-
-#  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)
+# endif 

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

  //
  // Helper class for granting access to the iterator core interface.
@@ -495,49 +468,41 @@ namespace iterators {
  //
  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::iterators::detail::always_bool2);
+      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::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

-#  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_INTEROP_HEAD(
+          friend, -, boost::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&)
      )
      ;

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

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

-  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.
@@ -769,38 +589,151 @@ namespace iterators {
    , class Reference   = Value&
    , class Difference  = std::ptrdiff_t
  >
-  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
-      >
+  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
  {
-  protected:
+   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:
      // 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::iterators::detail::postfix_increment_result<I,V,R,TC>::type
+  inline typename boost::detail::postfix_increment_result<I,V,R,TC>::type
  operator++(
      iterator_facade<I,V,TC,R,D>& i
    , int
  )
  {
-      typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
+      typename boost::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
@@ -891,7 +824,7 @@ namespace iterators {
 # define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
  BOOST_ITERATOR_FACADE_INTEROP(                                    \
      op                                                            \
-    , boost::iterators::detail::always_bool2                                   \
+    , boost::detail::always_bool2                                   \
    , return_prefix                                                 \
    , base_op                                                       \
  )
@@ -899,50 +832,21 @@ namespace iterators {
  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_RANDOM_ACCESS(
+  BOOST_ITERATOR_FACADE_INTEROP(
      -
-    , boost::iterators::detail::choose_difference_type
+    , boost::detail::choose_difference_type
    , return
    , distance_from
  )
-
 # undef BOOST_ITERATOR_FACADE_INTEROP
-# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS
+# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD

 # define BOOST_ITERATOR_FACADE_PLUS(args)           \
  BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args)     \
@@ -951,28 +855,18 @@ namespace iterators {
      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,12 +8,20 @@
 # include <boost/detail/iterator.hpp>
 # include <boost/detail/workaround.hpp>

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

-// Macro for supporting old compilers, no longer needed but kept
-// for backwards compatibility (it was documented).
-#define BOOST_ITERATOR_CATEGORY iterator_category
+// 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


 template <class Iterator>
@@ -21,20 +29,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
 {
@@ -42,19 +50,43 @@ struct iterator_difference
 };

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

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

-using iterators::iterator_value;
-using iterators::iterator_reference;
-using iterators::iterator_pointer;
-using iterators::iterator_difference;
-using iterators::iterator_category;
+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

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

 #endif // ITERATOR_TRAITS_DWA200347_HPP
--- a/include/boost/iterator/minimum_category.hpp
+++ b/include/boost/iterator/minimum_category.hpp
@@ -1,95 +0,0 @@
-// 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 iterators {
+namespace boost
+{

 template< class ElementIterator
        , class IndexIterator>
 class permutation_iterator
-  : public iterator_adaptor<
+  : public iterator_adaptor< 
             permutation_iterator<ElementIterator, IndexIterator>
-           , IndexIterator, typename boost::detail::iterator_traits<ElementIterator>::value_type
-           , use_default, typename boost::detail::iterator_traits<ElementIterator>::reference>
+           , IndexIterator, typename detail::iterator_traits<ElementIterator>::value_type
+           , use_default, typename detail::iterator_traits<ElementIterator>::reference>
 {
-  typedef iterator_adaptor<
+  typedef iterator_adaptor< 
            permutation_iterator<ElementIterator, IndexIterator>
-          , IndexIterator, typename boost::detail::iterator_traits<ElementIterator>::value_type
-          , use_default, typename boost::detail::iterator_traits<ElementIterator>::reference> super_t;
+          , IndexIterator, typename detail::iterator_traits<ElementIterator>::value_type
+          , use_default, typename 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,22 +54,18 @@ private:
    template <class,class> friend class permutation_iterator;
 #else
 public:
-#endif
+#endif 
    ElementIterator m_elt_iter;
 };


 template <class ElementIterator, class IndexIterator>
-inline permutation_iterator<ElementIterator, IndexIterator>
+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 iterators {
+namespace boost
+{

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

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

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

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

@@ -59,16 +59,11 @@ namespace iterators {
  };

  template <class BidirectionalIterator>
-  inline reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
+  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,17 +26,16 @@
 #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 iterators {
-
+namespace boost
+{
  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>
@@ -73,10 +72,10 @@ namespace iterators {

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

    friend class iterator_core_access;
@@ -96,7 +95,7 @@ namespace iterators {
        // 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 <
@@ -109,7 +108,7 @@ namespace iterators {
       , 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())
   {}
@@ -127,7 +126,7 @@ namespace iterators {
  };

  template <class UnaryFunc, class Iterator>
-  inline transform_iterator<UnaryFunc, Iterator>
+  transform_iterator<UnaryFunc, Iterator>
  make_transform_iterator(Iterator it, UnaryFunc fun)
  {
      return transform_iterator<UnaryFunc, Iterator>(it, fun);
@@ -141,9 +140,16 @@ namespace iterators {
  // function pointer in the iterator be 0, leading to a runtime
  // crash.
  template <class UnaryFunc, class Iterator>
-  inline typename iterators::enable_if<
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+  typename mpl::if_<
+#else 
+  typename iterators::enable_if<
+#endif 
      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)
  {
@@ -152,18 +158,13 @@ namespace iterators {

 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
  template <class Return, class Argument, class Iterator>
-  inline transform_iterator< Return (*)(Argument), Iterator, Return>
+  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
@@ -1,8 +1,6 @@
-// Copyright David Abrahams and Thomas Becker 2000-2006.
-// Copyright Kohei Takahashi 2012-2014.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
+// Copyright David Abrahams and Thomas Becker 2000-2006. 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_ZIP_ITERATOR_TMB_07_13_2003_HPP_
@@ -14,34 +12,44 @@
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/iterator_adaptor.hpp> // for enable_if_convertible
 #include <boost/iterator/iterator_categories.hpp>
+#include <boost/detail/iterator.hpp>

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

-#include <utility> // for std::pair
-#include <boost/fusion/adapted/boost_tuple.hpp> // for backward compatibility
+#include <boost/tuple/tuple.hpp>

-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/fold.hpp>
-#include <boost/mpl/transform.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/lambda.hpp>
 #include <boost/mpl/placeholders.hpp>
-
-#include <boost/fusion/algorithm/iteration/for_each.hpp>
-#include <boost/fusion/algorithm/transformation/transform.hpp>
-#include <boost/fusion/sequence/convert.hpp>
-#include <boost/fusion/sequence/intrinsic/at_c.hpp>
-#include <boost/fusion/sequence/comparison/equal_to.hpp>
-#include <boost/fusion/support/tag_of_fwd.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>

 namespace boost {
-namespace iterators {

  // Zip iterator forward declaration for zip_iterator_base
  template<typename IteratorTuple>
  class zip_iterator;

+  // One important design goal of the zip_iterator is to isolate all
+  // functionality whose implementation relies on the current tuple
+  // implementation. This goal has been achieved as follows: Inside
+  // the namespace detail there is a namespace tuple_impl_specific.
+  // This namespace encapsulates all functionality that is specific
+  // to the current Boost tuple implementation. More precisely, the
+  // namespace tuple_impl_specific provides the following tuple
+  // algorithms and meta-algorithms for the current Boost tuple
+  // implementation:
+  //
+  // tuple_meta_transform
+  // tuple_meta_accumulate
+  // tuple_transform
+  // tuple_for_each
+  //
+  // If the tuple implementation changes, all that needs to be
+  // replaced is the implementation of these four (meta-)algorithms.
+
  namespace detail
  {

@@ -52,7 +60,7 @@ namespace iterators {
    {
    public:
      advance_iterator(DiffType step) : m_step(step) {}
-
+      
      template<typename Iterator>
      void operator()(Iterator& it) const
      { it += m_step; }
@@ -64,102 +72,337 @@ namespace iterators {
    struct increment_iterator
    {
      template<typename Iterator>
-      void operator()(Iterator& it) const
+      void operator()(Iterator& it)
      { ++it; }
    };
    //
    struct decrement_iterator
    {
      template<typename Iterator>
-      void operator()(Iterator& it) const
+      void operator()(Iterator& it)
      { --it; }
    };
    //
    struct dereference_iterator
    {
-      template<typename>
-      struct result;
-
-      template<typename This, typename Iterator>
-      struct result<This(Iterator)>
-      {
+      template<typename Iterator>
+      struct apply
+      { 
        typedef typename
-          remove_reference<typename remove_cv<Iterator>::type>::type
-        iterator;
-
-        typedef typename iterator_reference<iterator>::type type;
+          iterator_traits<Iterator>::reference
+        type;
      };

      template<typename Iterator>
-        typename result<dereference_iterator(Iterator)>::type
-        operator()(Iterator const& it) const
+        typename apply<Iterator>::type operator()(Iterator const& it)
      { return *it; }
    };
+           

+    // The namespace tuple_impl_specific provides two meta-
+    // algorithms and two algorithms for tuples.
+    //
+    namespace tuple_impl_specific
+    {
+      // Meta-transform algorithm for tuples
+      //
+      template<typename Tuple, class UnaryMetaFun>
+      struct tuple_meta_transform;
+      
+      template<typename Tuple, class UnaryMetaFun>
+      struct tuple_meta_transform_impl
+      {
+          typedef tuples::cons<
+              typename mpl::apply1<
+                  typename mpl::lambda<UnaryMetaFun>::type
+                , typename Tuple::head_type
+              >::type
+            , typename tuple_meta_transform<
+                  typename Tuple::tail_type
+                , UnaryMetaFun 
+              >::type
+          > type;
+      };
+
+      template<typename Tuple, class UnaryMetaFun>
+      struct tuple_meta_transform
+        : mpl::eval_if<
+              boost::is_same<Tuple, tuples::null_type>
+            , mpl::identity<tuples::null_type>
+            , tuple_meta_transform_impl<Tuple, UnaryMetaFun>
+        >
+      {
+      };
+      
+      // 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
+        , typename StartType
+      >
+      struct tuple_meta_accumulate_impl
+      {
+         typedef typename mpl::apply2<
+             typename mpl::lambda<BinaryMetaFun>::type
+           , typename Tuple::head_type
+           , typename tuple_meta_accumulate<
+                 typename Tuple::tail_type
+               , BinaryMetaFun
+               , StartType 
+             >::type
+         >::type type;
+      };
+
+      template<
+          typename Tuple
+        , class BinaryMetaFun
+        , typename StartType
+      >
+      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
+                , BinaryMetaFun
+                , StartType
+              >
+          >
+      {
+      };  
+
+#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)                            \
+    || (                                                                    \
+      BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, != 0) && defined(_MSC_VER)  \
+    )
+// 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 
+# 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
+      // type. For example:
+      //
+      // struct to_ptr
+      // {
+      //     template <class Arg>
+      //     struct apply
+      //     {
+      //          typedef Arg* type;
+      //     }
+      //
+      //     template <class Arg>
+      //     Arg* operator()(Arg x);
+      // };
+      template<typename Fun>
+      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<
+          Tuple
+        , Fun
+      >::type
+      
+      BOOST_TUPLE_ALGO(tuple_transform)(
+        const Tuple& t, 
+        Fun f
+        BOOST_TUPLE_ALGO_RECURSE
+      )
+      { 
+          typedef typename tuple_meta_transform<
+              BOOST_DEDUCED_TYPENAME Tuple::tail_type
+            , Fun
+          >::type transformed_tail_type;
+
+        return tuples::cons<
+            BOOST_DEDUCED_TYPENAME mpl::apply1<
+                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<
+          Tuple
+        , Fun
+      >::type
+      
+      tuple_transform(
+        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)(
+          tuples::null_type
+        , Fun f BOOST_TUPLE_ALGO_TERMINATOR
+      )
+      { return f; }
+
+      
+      template<typename Tuple, typename Fun>
+      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
+      tuple_for_each(
+        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
+      // going to go away with the next tuple implementation anyway.
+      //
+      inline bool tuple_equal(tuples::null_type, tuples::null_type)
+      { return true; }
+
+      template<typename Tuple1, typename Tuple2>
+        bool tuple_equal(
+            Tuple1 const& t1, 
+            Tuple2 const& t2
+        )
+      { 
+          return t1.get_head() == t2.get_head() && 
+          tuple_equal(t1.get_tail(), t2.get_tail());
+      }
+    }
+    //
+    // end namespace tuple_impl_specific
+
+    template<typename Iterator>
+    struct iterator_reference
+    {
+        typedef typename iterator_traits<Iterator>::reference type;
+    };
+
+#ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+    // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
+    // out well.  Instantiating the nested apply template also
+    // requires instantiating iterator_traits on the
+    // placeholder. Instead we just specialize it as a metafunction
+    // class.
+    template<>
+    struct iterator_reference<mpl::_1>
+    {
+        template <class T>
+        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
-      : mpl::transform<
-            IteratorTuple,
+      : tuple_impl_specific::tuple_meta_transform<
+            IteratorTuple, 
            iterator_reference<mpl::_1>
          >
    {
    };

-    // Specialization for std::pair
-    template<typename Iterator1, typename Iterator2>
-    struct tuple_of_references<std::pair<Iterator1, Iterator2> >
-    {
-        typedef std::pair<
-            typename iterator_reference<Iterator1>::type
-          , typename iterator_reference<Iterator2>::type
-        > type;
-    };
-
    // Metafunction to obtain the minimal traversal tag in a tuple
    // of iterators.
    //
    template<typename IteratorTuple>
    struct minimum_traversal_category_in_iterator_tuple
    {
-      typedef typename mpl::transform<
+      typedef typename tuple_impl_specific::tuple_meta_transform<
          IteratorTuple
        , pure_traversal_tag<iterator_traversal<> >
      >::type tuple_of_traversal_tags;
-
-      typedef typename mpl::fold<
+          
+      typedef typename tuple_impl_specific::tuple_meta_accumulate<
          tuple_of_traversal_tags
-        , random_access_traversal_tag
        , minimum_category<>
+        , random_access_traversal_tag
      >::type type;
    };

-    template<typename Iterator1, typename Iterator2>
-    struct minimum_traversal_category_in_iterator_tuple<std::pair<Iterator1, Iterator2> >
-    {
-        typedef typename pure_traversal_tag<
-            typename iterator_traversal<Iterator1>::type
-        >::type iterator1_traversal;
-        typedef typename pure_traversal_tag<
-            typename iterator_traversal<Iterator2>::type
-        >::type iterator2_traversal;
-
-        typedef typename minimum_category<
-            iterator1_traversal
-          , typename minimum_category<
-                iterator2_traversal
-              , random_access_traversal_tag
-            >::type
-        >::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
+      // parameters) and not five, like mpl::and_ does.
+      //
+      template<typename Arg1, typename Arg2>
+      struct and_with_two_args
+        : 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
+      template<>
+      struct and_with_two_args<mpl::_1,mpl::_2>
+      {
+          template <class A1, class A2>
+          struct apply : mpl::and_<A1,A2>
+          {};
+      };
+# 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>
@@ -168,30 +411,30 @@ namespace iterators {
     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_difference<
-            typename mpl::at_c<IteratorTuple, 0>::type
-        >::type difference_type;
-
-        // Traversal catetgory is the minimum traversal category in the
+        typedef typename iterator_traits<
+            typename tuples::element<0, IteratorTuple>::type
+            >::difference_type difference_type;
+      
+        // 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
@@ -203,59 +446,35 @@ namespace iterators {
    {
        typedef int type;
    };
-
-    template <typename reference>
-    struct converter
-    {
-        template <typename Seq>
-        static reference call(Seq seq)
-        {
-            typedef typename fusion::traits::tag_of<reference>::type tag;
-            return fusion::convert<tag>(seq);
-        }
-    };
-
-    template <typename Reference1, typename Reference2>
-    struct converter<std::pair<Reference1, Reference2> >
-    {
-        typedef std::pair<Reference1, Reference2> reference;
-        template <typename Seq>
-        static reference call(Seq seq)
-        {
-            return reference(
-                fusion::at_c<0>(seq)
-              , fusion::at_c<1>(seq));
-        }
-    };
  }
-
+  
  /////////////////////////////////////////////////////////////////////
  //
  // 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
@@ -274,19 +493,18 @@ namespace iterators {
    { 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
-    {
-        typedef typename super_t::reference reference;
-        typedef detail::converter<reference> gen;
-        return gen::call(fusion::transform(
-          get_iterator_tuple(),
-          detail::dereference_iterator()));
+    { 
+      return detail::tuple_impl_specific::tuple_transform( 
+        get_iterator_tuple(),
+        detail::dereference_iterator()
+       );
    }

    // Two zip iterators are equal if all iterators in the iterator
@@ -299,70 +517,69 @@ namespace iterators {
    // 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 fusion::equal_to(
-          get_iterator_tuple(),
-          other.get_iterator_tuple());
+      return detail::tuple_impl_specific::tuple_equal(
+        get_iterator_tuple(),
+        other.get_iterator_tuple()
+        );
    }

    // Advancing a zip iterator means to advance all iterators in the
    // iterator tuple.
    void advance(typename super_t::difference_type n)
-    {
-        fusion::for_each(
+    { 
+      detail::tuple_impl_specific::tuple_for_each(
          m_iterator_tuple,
-          detail::advance_iterator<BOOST_DEDUCED_TYPENAME super_t::difference_type>(n));
+          detail::advance_iterator<BOOST_DEDUCED_TYPENAME super_t::difference_type>(n)
+          );
    }
    // Incrementing a zip iterator means to increment all iterators in
    // the iterator tuple.
    void increment()
-    {
-        fusion::for_each(
-          m_iterator_tuple,
-          detail::increment_iterator());
+    { 
+      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()
-    {
-        fusion::for_each(
-          m_iterator_tuple,
-          detail::decrement_iterator());
+    { 
+      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 fusion::at_c<0>(other.get_iterator_tuple()) -
-            fusion::at_c<0>(this->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>
-  inline zip_iterator<IteratorTuple>
+  template<typename IteratorTuple> 
+  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,7 +15,6 @@

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

 // this should use random_access_iterator_helper but I've had
@@ -62,19 +61,13 @@ 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;
-namespace iterators {
-using ::int_iterator;
-}}
+  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,10 +41,9 @@ 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)
@@ -85,7 +84,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);

@@ -151,7 +150,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);

@@ -216,7 +215,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]);
@@ -235,7 +234,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);
@@ -261,18 +260,6 @@ 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/Show More
+++ b/Show More