v2, v3, integration branch

[SVN r62649]

.travis.yml

@@ -1,40 +0,0 @@
-# Copyright 2016 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-os:
-  - linux
-  - osx
-
-branches:
-  only:
-    - master
-    - develop
-
-install:
-  - cd ..
-  - git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init --depth 1 tools/build
-  - git submodule update --init --depth 1 libs/config
-  - git submodule update --init --depth 1 tools/boostdep
-  - cp -r $TRAVIS_BUILD_DIR/* libs/iterator
-  - python tools/boostdep/depinst/depinst.py iterator
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - TOOLSET=gcc,clang
-  - if [ $TRAVIS_OS_NAME == osx ]; then TOOLSET=clang; fi
-  - ./b2 --verbose-test libs/config/test//config_info toolset=$TOOLSET || true
-  - ./b2 libs/iterator/test toolset=$TOOLSET
-
-notifications:
-  email:
-    on_success: always

doc/Jamfile.v2

@@ -13,15 +13,10 @@ boostbook standalone
   : 
     iterator 
   :
-    <xsl:param>boost.root=../../../..
     <xsl:param>toc.max.depth=3
     <xsl:param>toc.section.depth=3
     <xsl:param>chunk.section.depth=4
     <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/iterator/doc
   ;
 
-###############################################################################
+
-alias boostdoc ;
-explicit boostdoc ;
-alias boostrelease : standalone ;
-explicit boostrelease ;

doc/facade-and-adaptor.html

@@ -26,7 +26,7 @@
 Lab</a>, <a class="last reference external" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
 <td>2006-09-11</td></tr>
-<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html">N1530</a>=03-0113, which was
+<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html">N1530</a>=03-0113, which was
 accepted for Technical Report 1 by the C++ standard
 committee's library working group.</td>
 </tr>
@@ -239,29 +239,29 @@ Iterator Concepts.</p>
 <div class="section" id="iterator-concepts">
 <h2><a class="toc-backref" href="#id18">Iterator Concepts</a></h2>
 <p>This proposal is formulated in terms of the new <tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">concepts</span></tt>
-as proposed in <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>, since user-defined and especially adapted
+as proposed in <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>, since user-defined and especially adapted
 iterators suffer from the well known categorization problems that are
 inherent to the current iterator categories.</p>
-<p>This proposal does not strictly depend on proposal <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>, as there
+<p>This proposal does not strictly depend on proposal <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>, as there
 is a direct mapping between new and old categories. This proposal
-could be reformulated using this mapping if <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a> was not accepted.</p>
+could be reformulated using this mapping if <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a> was not accepted.</p>
 </div>
 <div class="section" id="interoperability">
 <h2><a class="toc-backref" href="#id19">Interoperability</a></h2>
 <p>The question of iterator interoperability is poorly addressed in the
 current standard.  There are currently two defect reports that are
 concerned with interoperability issues.</p>
-<p>Issue <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a> concerns the fact that mutable container iterator types
+<p>Issue <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a> concerns the fact that mutable container iterator types
 are only required to be convertible to the corresponding constant
 iterator types, but objects of these types are not required to
 interoperate in comparison or subtraction expressions.  This situation
 is tedious in practice and out of line with the way built in types
 work.  This proposal implements the proposed resolution to issue
-<a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>, as most standard library implementations do nowadays. In other
+<a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>, as most standard library implementations do nowadays. In other
 words, if an iterator type A has an implicit or user defined
 conversion to an iterator type B, the iterator types are interoperable
 and the usual set of operators are available.</p>
-<p>Issue <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#280">280</a> concerns the current lack of interoperability between
+<p>Issue <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280">280</a> concerns the current lack of interoperability between
 reverse iterator types. The proposed new reverse_iterator template
 fixes the issues raised in 280. It provides the desired
 interoperability without introducing unwanted overloads.</p>
@@ -422,8 +422,8 @@ member (e.g. <a class="reference internal" href="#counting"><tt class="docutils
 into the temporary iterator <tt class="docutils literal"><span class="pre">p+n</span></tt>, which is destroyed when
 <tt class="docutils literal"><span class="pre">operator[]</span></tt> returns.</p>
 <p>Writable iterators built with <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> implement the
-semantics required by the preferred resolution to <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
+semantics required by the preferred resolution to <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
-adopted by proposal <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
+adopted by proposal <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
 convertible to the iterator's <tt class="docutils literal"><span class="pre">value_type</span></tt>, and <tt class="docutils literal"><span class="pre">p[n]</span> <span class="pre">=</span> <span class="pre">x</span></tt> is
 equivalent to <tt class="docutils literal"><span class="pre">*(p</span> <span class="pre">+</span> <span class="pre">n)</span> <span class="pre">=</span> <span class="pre">x</span></tt> (Note: This result object may be
 implemented as a proxy containing a copy of <tt class="docutils literal"><span class="pre">p+n</span></tt>).  This approach

doc/facade-and-adaptor.rst

@@ -19,7 +19,7 @@
 .. Version 1.9 of this ReStructuredText document corresponds to
    n1530_, the paper accepted by the LWG.
 
-.. _n1530: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html
+.. _n1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
 
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
@@ -140,7 +140,7 @@ as proposed in n1550_, since user-defined and especially adapted
 iterators suffer from the well known categorization problems that are
 inherent to the current iterator categories.
 
-.. _n1550: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm
+.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
 
 This proposal does not strictly depend on proposal n1550_, as there
 is a direct mapping between new and old categories. This proposal
@@ -169,8 +169,8 @@ reverse iterator types. The proposed new reverse_iterator template
 fixes the issues raised in 280. It provides the desired
 interoperability without introducing unwanted overloads.
 
-.. _179: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179
+.. _179: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179
-.. _280: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#280
+.. _280: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280
 
 
 Iterator Facade

doc/function_input_iterator.rst

@@ -1,13 +1,10 @@
 :Author:
-    `Dean Michael Berris <mailto:me@deanberris.com>`_
+    `Dean Michael Berris <mailto:mikhailberis@gmail.com>`_
 
 :License:
     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)
 
-:Copyright:
-    Copyright 2012 Google, Inc.
-
 Function Input Iterator
 =======================
 
@@ -18,14 +15,11 @@ the iterator has been incremented. A Function Input Iterator models the
 
 .. _InputIterator: http://www.sgi.com/tech/stl/InputIterator.html
 
-The Function Input Iterator takes a function that models the Generator_ concept
+Like the Generator Iterator, the Function Input Iterator takes a function
-(which is basically a nullary or 0-arity function object). The first dereference
+that models the Generator_ concept (which is basically a nullary or 0-arity
-of the iterator at a given position invokes the generator function and stores
+function object). Each increment of the function Function Input Iterator
-and returns the result; subsequent dereferences at the same position simply
+invokes the generator function and stores the value in the iterator. When
-return the same stored result. Incrementing the iterator places it at a new
+the iterator is dereferenced the stored value is returned.
-position, hence a subsequent dereference will generate a new value via another
-invokation of the generator function. This ensures the generator function is
-invoked precisely when the iterator is requested to return a (new) value.
 
 .. _Generator: http://www.sgi.com/tech/stl/Generator.html
 
@@ -64,7 +58,7 @@ Synopsis
 
         template <class Function, class State>
         typename function_input_iterator<Function, State>
-        make_function_input_iterator(Function & f, State s);
+        make_function_input_iterator(Function & f);
 
         struct infinite;
     }
@@ -118,7 +112,7 @@ it with the ``boost::infinite`` helper class.
     copy(
             make_function_input_iterator(f,infinite()),
             make_function_input_iterator(f,infinite()),
-            ostream_iterator<int>(cout, " ")
+            ostream_iterator<int>(count, " ")
         );
    
 Above, instead of creating a huge vector we rely on the STL copy algorithm

doc/generator_iterator.htm

@@ -1,163 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-<head>
-  <meta http-equiv="Content-Language" content="en-us">
-  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-
-  <title>Generator Iterator Adaptor Documentation</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-  <img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle"
-  width="277" height="86">
-
-  <h1>Generator Iterator Adaptor</h1>
-
-  <p>Defined in header <a href=
-  "../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>
-
-  <p>The generator iterator adaptor makes it easier to create custom input
-  iterators from 0-ary functions and function objects. The adaptor takes a
-  <a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> and
-  creates a model of <a href=
-  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>. Each
-  increment retrieves an item from the generator and makes it available to be
-  retrieved by dereferencing. The motivation for this iterator is that some
-  concepts can be more naturally expressed as a generator, while most STL
-  algorithms expect an iterator. An example is the <a href=
-  "../random/index.html">Random Number</a> library.</p>
-
-  <h2>Synopsis</h2>
-
-  <blockquote>
-    <pre>
-namespace boost {
-  template &lt;class Generator&gt;
-  class generator_iterator_policies;
-
-  template &lt;class Generator&gt;
-  class generator_iterator_generator;
-
-  template &lt;class Generator&gt;
-  typename generator_iterator_generator&lt;Generator&gt;::type
-  make_generator_iterator(Generator &amp; gen);
-}
-</pre>
-  </blockquote>
-  <hr>
-
-  <h2>The Generator Iterator Generator Class</h2>
-
-  <p>The class generator_iterator_generator is a helper class whose purpose
-  is to construct a generator iterator type. The template parameter for this
-  class is the Generator function object type that is being wrapped. The
-  generator iterator adaptor only holds a reference (or pointer) to the
-  function object, therefore the function object must outlive the generator
-  iterator adaptor constructed from it.</p>
-  <pre>
-template &lt;class Generator&gt;
-class generator_iterator_generator
-{
-public:
-  typedef <i>unspecified</i> type; // the resulting generator iterator type 
-}
-</pre>
-
-  <h3>Template Parameters</h3>
-
-  <table border summary="">
-    <tr>
-      <th>Parameter</th>
-
-      <th>Description</th>
-    </tr>
-
-    <tr>
-      <td><tt><a href=
-      "http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>
-
-      <td>The generator (0-ary function object) type being wrapped. The
-      return type of the function must be defined as
-      <tt>Generator::result_type</tt>. The function object must be a model of
-      <a href=
-      "http://www.sgi.com/tech/stl/Generator.html">Generator</a>.</td>
-    </tr>
-  </table>
-
-  <h3>Concept Model</h3>
-
-  <p>The generator iterator class is a model of <a href=
-  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.</p>
-
-  <h3>Members</h3>
-
-  <p>The generator iterator implements the member functions and operators
-  required of the <a href=
-  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
-  concept.<br></p>
-  <hr>
-
-  <h2><a name="make_generator_iterator" id="make_generator_iterator">The
-  Generator Iterator Object Generator</a></h2>
-
-  <p>The <tt>make_generator_iterator()</tt> function provides a convenient
-  way to create generator iterator objects. The function saves the user the
-  trouble of explicitly writing out the iterator types.</p>
-
-  <blockquote>
-    <pre>
-template &lt;class Generator&gt;
-typename generator_iterator_generator&lt;Generator&gt;::type
-make_generator_iterator(Generator &amp; gen);
-</pre>
-  </blockquote>
-  <hr>
-
-  <h3>Example</h3>
-
-  <p>The following program shows how <code>generator_iterator</code>
-  transforms a generator into an input iterator.</p>
-
-  <blockquote>
-    <pre>
-#include &lt;iostream&gt;
-#include &lt;boost/generator_iterator.hpp&gt;
-
-class my_generator
-{
-public:
-  typedef int result_type;
-  my_generator() : state(0) { }
-  int operator()() { return ++state; }
-private:
-  int state;
-};
-
-int main()
-{
-  my_generator gen;
-  boost::generator_iterator_generator&lt;my_generator&gt;::type it = boost::make_generator_iterator(gen);
-  for(int i = 0; i &lt; 10; ++i, ++it)
-    std::cout &lt;&lt; *it &lt;&lt; std::endl;
-}
-</pre>
-  </blockquote>
-  <hr>
-
-  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
-  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
-  height="31" width="88"></a></p>
-
-  <p>Revised 
-  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
-
-  <p><i>Copyright &copy; 2001 <a href=
-  "http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a></i></p>
-
-  <p><i>Distributed under the Boost Software License, Version 1.0. (See
-  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
-  copy at <a href=
-  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
-</body>
-</html>

doc/index.rst

@@ -115,8 +115,8 @@ __ iterator_facade.pdf
 __ iterator_adaptor.pdf
 
 Both |facade| and |adaptor| as well as many of the `specialized
-adaptors`_ mentioned below have been proposed for standardization;
+adaptors`_ mentioned below have been proposed for standardization,
-see our
+and accepted into the first C++ technical report; see our
 
    `Standard Proposal For Iterator Facade and Adaptor`__ (PDF__)
 

doc/issues.rst

@@ -3,7 +3,7 @@
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 .. _N1550: http://www.boost-consulting.com/writing/n1550.html
-.. _N1530: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html
+.. _N1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
 
 :Author: David Abrahams and Jeremy Siek
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu

doc/iterator_facade.html

@@ -242,8 +242,8 @@ member (e.g. <a class="reference external" href="counting_iterator.html"><tt cla
 into the temporary iterator <tt class="docutils literal"><span class="pre">p+n</span></tt>, which is destroyed when
 <tt class="docutils literal"><span class="pre">operator[]</span></tt> returns.</p>
 <p>Writable iterators built with <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> implement the
-semantics required by the preferred resolution to <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
+semantics required by the preferred resolution to <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
-adopted by proposal <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
+adopted by proposal <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
 convertible to the iterator's <tt class="docutils literal"><span class="pre">value_type</span></tt>, and <tt class="docutils literal"><span class="pre">p[n]</span> <span class="pre">=</span> <span class="pre">x</span></tt> is
 equivalent to <tt class="docutils literal"><span class="pre">*(p</span> <span class="pre">+</span> <span class="pre">n)</span> <span class="pre">=</span> <span class="pre">x</span></tt> (Note: This result object may be
 implemented as a proxy containing a copy of <tt class="docutils literal"><span class="pre">p+n</span></tt>).  This approach

doc/iterator_facade_body.rst

@@ -167,9 +167,9 @@ the implementation of her iterator is free to implement an
 class; it will hide the one supplied by ``iterator_facade`` from
 clients of her iterator.
 
-.. _n1550: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm
+.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
 
-.. _`issue 299`: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299
+.. _`issue 299`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299
 
 .. _`operator arrow`:
 

doc/iterator_facade_ref.rst

@@ -106,7 +106,7 @@ The ``iterator_category`` member of ``iterator_facade`` is
 
 .. parsed-literal::
 
-  *iterator-category*\ (CategoryOrTraversal, reference, value_type)
+  *iterator-category*\ (CategoryOrTraversal, value_type, reference)
 
 where *iterator-category* is defined as follows:
 

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>,
+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">iterator_category</tt>, and <tt class="docutils literal">difference_type</tt>.  Unfortunately,
+<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" />

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
+

doc/new-iter-concepts.html

@@ -27,10 +27,10 @@
 Lab</a>, <a class="last reference external" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
 <td>2006-09-11</td></tr>
-<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1550.htm">n1550</a>=03-0133, which was
+<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1550.html">n1550</a>=03-0133, which was
 accepted for Technical Report 1 by the C++ standard
 committee's library working group. This proposal is a
-revision of paper <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2001/n1297.html">n1297</a>, <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1477.html">n1477</a>, and <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1531.html">n1531</a>.</td>
+revision of paper <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2001/n1297.html">n1297</a>, <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1477.html">n1477</a>, and <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1531.html">n1531</a>.</td>
 </tr>
 <tr><th class="docinfo-name">Copyright:</th>
 <td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt
@@ -127,12 +127,12 @@ requirements in the iterator categories.</p>
 <td><tt class="docutils literal"><span class="pre">*i</span></tt> is convertible to <tt class="docutils literal"><span class="pre">T</span></tt></td>
 </tr>
 <tr><td>Forward Iterator</td>
-<td><tt class="docutils literal"><span class="pre">*i</span></tt> is <tt class="docutils literal"><span class="pre">T&amp;</span></tt> (or <tt class="docutils literal"><span class="pre">const</span> <span class="pre">T&amp;</span></tt> once <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 200</a>
+<td><tt class="docutils literal"><span class="pre">*i</span></tt> is <tt class="docutils literal"><span class="pre">T&amp;</span></tt> (or <tt class="docutils literal"><span class="pre">const</span> <span class="pre">T&amp;</span></tt> once <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 200</a>
 is resolved)</td>
 </tr>
 <tr><td>Random Access Iterator</td>
 <td><tt class="docutils literal"><span class="pre">i[n]</span></tt> is convertible to <tt class="docutils literal"><span class="pre">T</span></tt> (also <tt class="docutils literal"><span class="pre">i[n]</span> <span class="pre">=</span> <span class="pre">t</span></tt>
-is required for mutable iterators once <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>
+is required for mutable iterators once <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>
 is resolved)</td>
 </tr>
 </tbody>
@@ -141,7 +141,7 @@ is resolved)</td>
 single hierarchy, many useful iterators can not be appropriately
 categorized. For example, <tt class="docutils literal"><span class="pre">vector&lt;bool&gt;::iterator</span></tt> is almost a
 random access iterator, but the return type is not <tt class="docutils literal"><span class="pre">bool&amp;</span></tt> (see
-<a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 96</a> and Herb Sutter's paper J16/99-0008 = WG21
+<a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 96</a> and Herb Sutter's paper J16/99-0008 = WG21
 N1185). Therefore, the iterators of <tt class="docutils literal"><span class="pre">vector&lt;bool&gt;</span></tt> only meet the
 requirements of input iterator and output iterator.  This is so
 nonintuitive that the C++ standard contradicts itself on this point.
@@ -344,7 +344,7 @@ approach for specifying <tt class="docutils literal"><span class="pre">operator[
 direction would mean that an iterator satisfying the old Random Access
 Iterator requirements would not necessarily be a model of Readable or
 Writable Lvalue Iterator.  Instead we have chosen a design that
-matches the preferred resolution of <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>: <tt class="docutils literal"><span class="pre">operator[]</span></tt> is
+matches the preferred resolution of <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>: <tt class="docutils literal"><span class="pre">operator[]</span></tt> is
 only required to return something convertible to the <tt class="docutils literal"><span class="pre">value_type</span></tt>
 (for a Readable Iterator), and is required to support assignment
 <tt class="docutils literal"><span class="pre">i[n]</span> <span class="pre">=</span> <span class="pre">t</span></tt> (for a Writable Iterator).</p>
@@ -976,7 +976,7 @@ struct random_access_traversal_tag : bidirectional_traversal_tag { };
 <div class="section" id="addition-to-lib-iterator-traits">
 <h2><a class="toc-backref" href="#id23">Addition to [lib.iterator.traits]</a></h2>
 <p>The <tt class="docutils literal"><span class="pre">is_readable_iterator</span></tt> class
-template satisfies the <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">UnaryTypeTrait</a> requirements.</p>
+template satisfies the <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">UnaryTypeTrait</a> requirements.</p>
 <p>Given an iterator type <tt class="docutils literal"><span class="pre">X</span></tt>, <tt class="docutils literal"><span class="pre">is_readable_iterator&lt;X&gt;::value</span></tt>
 yields <tt class="docutils literal"><span class="pre">true</span></tt> if, for an object <tt class="docutils literal"><span class="pre">a</span></tt> of type <tt class="docutils literal"><span class="pre">X</span></tt>, <tt class="docutils literal"><span class="pre">*a</span></tt> is
 convertible to <tt class="docutils literal"><span class="pre">iterator_traits&lt;X&gt;::value_type</span></tt>, and <tt class="docutils literal"><span class="pre">false</span></tt>
@@ -1007,7 +1007,7 @@ otherwise.</p>
 </div>
 <div class="section" id="footnotes">
 <h1><a class="toc-backref" href="#id24">Footnotes</a></h1>
-<p>The UnaryTypeTrait concept is defined in <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">n1519</a>; the LWG is
+<p>The UnaryTypeTrait concept is defined in <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">n1519</a>; the LWG is
 considering adding the requirement that specializations are derived
 from their nested <tt class="docutils literal"><span class="pre">::type</span></tt>.</p>
 <!-- LocalWords:  Abrahams Siek Witt const bool Sutter's WG int UL LI href Lvalue

doc/new-iter-concepts.rst

@@ -38,10 +38,10 @@
           
 .. contents:: Table of Contents
 
-.. _n1297: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2001/n1297.html
+.. _n1297: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2001/n1297.html
-.. _n1477: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1477.html
+.. _n1477: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1477.html
-.. _n1531: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1531.html
+.. _n1531: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1531.html
-.. _n1550: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1550.htm
+.. _n1550: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1550.html
 
 ============
  Motivation
@@ -76,8 +76,8 @@ requirements in the iterator categories.
 |                        |is resolved)                                         |
 +------------------------+-----------------------------------------------------+
 
-.. _issue 200: http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#200
+.. _issue 200: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#200
-.. _issue 299: http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#299
+.. _issue 299: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299
 
 
 Because iterator traversal and value access are mixed together in a
@@ -91,7 +91,7 @@ nonintuitive that the C++ standard contradicts itself on this point.
 In paragraph 23.2.4/1 it says that a ``vector`` is a sequence that
 supports random access iterators.
 
-.. _issue 96: http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#96
+.. _issue 96: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96
 
 Another difficult-to-categorize iterator is the transform iterator, an
 adaptor which applies a unary function object to the dereferenced
@@ -791,7 +791,7 @@ The UnaryTypeTrait concept is defined in n1519_; the LWG is
 considering adding the requirement that specializations are derived
 from their nested ``::type``.
 
-.. _n1519: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1519.htm
+.. _n1519: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm
 
 ..
  LocalWords:  Abrahams Siek Witt const bool Sutter's WG int UL LI href Lvalue

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

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--`]

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`  
 
 

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`]
@@ -167,9 +165,9 @@ the implementation of her iterator is free to implement an
 class; it will hide the one supplied by `iterator_facade` from
 clients of her iterator.
 
-.. _n1550: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm
+.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
 
-.. _`issue 299`: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299
+.. _`issue 299`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299
 
 .. _`operator arrow`:
 
@@ -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]

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

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`  
 
 

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]

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`]]

doc/quickbook/permutation_iterator.qbk

@@ -189,7 +189,7 @@ following operations.
 
   permutation_iterator& operator++();
 
-[*Effects: ] `++m_order`[br]
+[*Effects: ] `++m_order`\n
 [*Returns: ] `*this`
 
 

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]

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]

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]

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

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> 

doc/ref_problem.rst

@@ -3,7 +3,7 @@
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 .. _N1550: http://www.boost-consulting.com/writing/n1550.html
-.. _N1530: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html
+.. _N1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
 
 :Author: David Abrahams and Jeremy Siek
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu

doc/transform_iterator.html

@@ -99,7 +99,7 @@ private:
 </pre>
 <p>If <tt class="docutils literal"><span class="pre">Reference</span></tt> is <tt class="docutils literal"><span class="pre">use_default</span></tt> then the <tt class="docutils literal"><span class="pre">reference</span></tt> member of
 <tt class="docutils literal"><span class="pre">transform_iterator</span></tt> is
-<tt class="docutils literal"><span class="pre">result_of&lt;const UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.
+<tt class="docutils literal"><span class="pre">result_of&lt;UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.
 Otherwise, <tt class="docutils literal"><span class="pre">reference</span></tt> is <tt class="docutils literal"><span class="pre">Reference</span></tt>.</p>
 <p>If <tt class="docutils literal"><span class="pre">Value</span></tt> is <tt class="docutils literal"><span class="pre">use_default</span></tt> then the <tt class="docutils literal"><span class="pre">value_type</span></tt> member is
 <tt class="docutils literal"><span class="pre">remove_cv&lt;remove_reference&lt;reference&gt;</span> <span class="pre">&gt;::type</span></tt>.  Otherwise,
@@ -117,10 +117,10 @@ convertible to <tt class="docutils literal"><span class="pre">input_iterator_tag
 <div class="section" id="transform-iterator-requirements">
 <h1><a class="toc-backref" href="#id3"><tt class="docutils literal"><span class="pre">transform_iterator</span></tt> requirements</a></h1>
 <p>The type <tt class="docutils literal"><span class="pre">UnaryFunction</span></tt> must be Assignable, Copy Constructible, and
-the expression <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be valid where <tt class="docutils literal"><span class="pre">f</span></tt> is a const object of
+the expression <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be valid where <tt class="docutils literal"><span class="pre">f</span></tt> is an object of
 type <tt class="docutils literal"><span class="pre">UnaryFunction</span></tt>, <tt class="docutils literal"><span class="pre">i</span></tt> is an object of type <tt class="docutils literal"><span class="pre">Iterator</span></tt>, and
 where the type of <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be
-<tt class="docutils literal"><span class="pre">result_of&lt;const UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.</p>
+<tt class="docutils literal"><span class="pre">result_of&lt;UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.</p>
 <p>The argument <tt class="docutils literal"><span class="pre">Iterator</span></tt> shall model Readable Iterator.</p>
 </div>
 <div class="section" id="transform-iterator-models">

doc/transform_iterator_ref.rst

@@ -41,7 +41,7 @@
 
 If ``Reference`` is ``use_default`` then the ``reference`` member of
 ``transform_iterator`` is
-``result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
+``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
 Otherwise, ``reference`` is ``Reference``.
 
 If ``Value`` is ``use_default`` then the ``value_type`` member is
@@ -64,10 +64,10 @@ convertible to ``input_iterator_tag``.
 ...................................
 
 The type ``UnaryFunction`` must be Assignable, Copy Constructible, and
-the expression ``f(*i)`` must be valid where ``f`` is a const object of
+the expression ``f(*i)`` must be valid where ``f`` is an object of
 type ``UnaryFunction``, ``i`` is an object of type ``Iterator``, and
 where the type of ``f(*i)`` must be
-``result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
+``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
 
 The argument ``Iterator`` shall model Readable Iterator.  
 

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'.

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);
+        m_f(value); 
-        return *this;
+        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

include/boost/generator_iterator.hpp

@@ -1,85 +0,0 @@
-// (C) Copyright Jens Maurer 2001.
-// 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)
-//
-// Revision History:
-
-// 15 Nov 2001   Jens Maurer
-//      created.
-
-//  See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation.
-
-#ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
-#define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
-
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/ref.hpp>
-
-namespace boost {
-namespace iterators {
-
-template<class Generator>
-class generator_iterator
-  : public iterator_facade<
-        generator_iterator<Generator>
-      , typename Generator::result_type
-      , single_pass_traversal_tag
-      , typename Generator::result_type const&
-    >
-{
-    typedef iterator_facade<
-        generator_iterator<Generator>
-      , typename Generator::result_type
-      , 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)()) {}
-
-    void increment()
-    {
-        m_value = (*m_g)();
-    }
-
-    const typename Generator::result_type&
-    dereference() const
-    {
-        return m_value;
-    }
-
-    bool equal(generator_iterator const& y) const
-    {
-        return this->m_g == y.m_g && this->m_value == y.m_value;
-    }
-
- private:
-    Generator* m_g;
-    typename Generator::result_type m_value;
-};
-
-template<class Generator>
-struct generator_iterator_generator
-{
-  typedef generator_iterator<Generator> type;
-};
-
-template <class Generator>
-inline generator_iterator<Generator>
-make_generator_iterator(Generator & gen)
-{
-  typedef generator_iterator<Generator> result_t;
-  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

include/boost/indirect_reference.hpp

@@ -1,43 +0,0 @@
-#ifndef INDIRECT_REFERENCE_DWA200415_HPP
-# define INDIRECT_REFERENCE_DWA200415_HPP
-
-//
-// Copyright David Abrahams 2004. 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)
-//
-// typename indirect_reference<P>::type provides the type of *p.
-//
-// http://www.boost.org/libs/iterator/doc/pointee.html
-//
-
-# include <boost/detail/is_incrementable.hpp>
-# include <boost/iterator/iterator_traits.hpp>
-# include <boost/type_traits/remove_cv.hpp>
-# include <boost/mpl/eval_if.hpp>
-# include <boost/pointee.hpp>
-
-namespace boost {
-
-namespace detail
-{
-  template <class P>
-  struct smart_ptr_reference
-  {
-      typedef typename boost::pointee<P>::type& type;
-  };
-}
-
-template <class P>
-struct indirect_reference
-  : mpl::eval_if<
-        detail::is_incrementable<P>
-      , iterator_reference<P>
-      , detail::smart_ptr_reference<P>
-    >
-{
-};
-
-} // namespace boost
-
-#endif // INDIRECT_REFERENCE_DWA200415_HPP

include/boost/iterator.hpp

@@ -0,0 +1,59 @@
+//  iterator.hpp workarounds for non-conforming standard libraries  ---------//
+
+//  (C) Copyright Beman Dawes 2000. 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)
+
+//  See http://www.boost.org/libs/utility for documentation.
+
+//  Revision History
+//  12 Jan 01 added <cstddef> for std::ptrdiff_t (Jens Maurer)
+//  28 Jun 00 Workarounds to deal with known MSVC bugs (David Abrahams)
+//  26 Jun 00 Initial version (Jeremy Siek)
+
+#ifndef BOOST_ITERATOR_HPP
+#define BOOST_ITERATOR_HPP
+
+#include <iterator>
+#include <cstddef>           // std::ptrdiff_t
+#include <boost/config.hpp>
+
+namespace boost
+{
+# if defined(BOOST_NO_STD_ITERATOR) && !defined(BOOST_MSVC_STD_ITERATOR)
+  template <class Category, class T,
+    class Distance = std::ptrdiff_t,
+    class Pointer = T*, class Reference = T&>
+  struct iterator
+  {
+    typedef T         value_type;
+    typedef Distance  difference_type;
+    typedef Pointer   pointer;
+    typedef Reference reference;
+    typedef Category  iterator_category;
+  };
+# else
+
+  // declare iterator_base in namespace detail to work around MSVC bugs which
+  // prevent derivation from an identically-named class in a different namespace.
+  namespace detail {
+   template <class Category, class T, class Distance, class Pointer, class Reference>
+#  if !defined(BOOST_MSVC_STD_ITERATOR)
+   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
+#  else
+   struct iterator_base : std::iterator<Category, T, Distance>
+   {
+     typedef Reference reference;
+     typedef Pointer pointer;
+     typedef Distance difference_type;
+   };
+#  endif
+  }
+
+  template <class Category, class T, class Distance = std::ptrdiff_t,
+            class Pointer = T*, class Reference = T&>
+  struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
+# endif
+} // namespace boost
+
+#endif // BOOST_ITERATOR_HPP

include/boost/iterator/advance.hpp

@@ -1,84 +0,0 @@
-// Copyright (C) 2017 Michel Morin.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ITERATOR_ADVANCE_HPP
-#define BOOST_ITERATOR_ADVANCE_HPP
-
-#include <boost/config.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-
-namespace boost {
-namespace iterators {
-
-    namespace detail {
-        template <typename InputIterator, typename Distance>
-        inline BOOST_CXX14_CONSTEXPR void
-        advance_impl(
-            InputIterator& it
-          , Distance n
-          , incrementable_traversal_tag
-        )
-        {
-            while (n > 0) {
-                ++it;
-                --n;
-            }
-        }
-
-        template <typename BidirectionalIterator, typename Distance>
-        inline BOOST_CXX14_CONSTEXPR void
-        advance_impl(
-            BidirectionalIterator& it
-          , Distance n
-          , bidirectional_traversal_tag
-        )
-        {
-            if (n >= 0) {
-                while (n > 0) {
-                    ++it;
-                    --n;
-                }
-            }
-            else {
-                while (n < 0) {
-                    --it;
-                    ++n;
-                }
-            }
-        }
-
-        template <typename RandomAccessIterator, typename Distance>
-        inline BOOST_CXX14_CONSTEXPR void
-        advance_impl(
-            RandomAccessIterator& it
-          , Distance n
-          , random_access_traversal_tag
-        )
-        {
-            it += n;
-        }
-    }
-
-    namespace advance_adl_barrier {
-        template <typename InputIterator, typename Distance>
-        inline BOOST_CXX14_CONSTEXPR void
-        advance(InputIterator& it, Distance n)
-        {
-            detail::advance_impl(
-                it, n, typename iterator_traversal<InputIterator>::type()
-            );
-        }
-    }
-
-    using namespace advance_adl_barrier;
-
-} // namespace iterators
-
-using iterators::advance;
-
-} // namespace boost
-
-#endif

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;
+} // namespace boost::iterator
-using iterators::make_counting_iterator;
-
-} // namespace boost
 
 #endif // COUNTING_ITERATOR_DWA200348_HPP

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 boost { namespace detail {
-namespace iterators {
-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

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

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
 

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

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 
 {};
 
 
@@ -76,10 +73,16 @@ struct iterator_writability_disabled
 // Convert an iterator_facade's traversal category, Value parameter,
 // and ::reference type to an appropriate old-style category.
 //
-// Due to changeset 21683, this now never results in a category convertible
+// If writability has been disabled per the above metafunction, the
-// to output_iterator_tag.
+// result will not be convertible to output_iterator_tag.
+//
+// Otherwise, if Traversal == single_pass_traversal_tag, the following
+// conditions will result in a tag that is convertible both to
+// input_iterator_tag and output_iterator_tag:
+//
+//    1. Reference is a reference to non-const
+//    2. Reference is not a reference and is convertible to Value
 //
-// Change at: https://svn.boost.org/trac/boost/changeset/21683
 template <class Traversal, class ValueParam, class Reference>
 struct iterator_facade_default_category
   : mpl::eval_if<
@@ -99,7 +102,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 +138,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 +153,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 +162,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 +193,7 @@ struct facade_iterator_category
 {
 };
 
-}}} // namespace boost::iterators::detail
+}} // namespace boost::detail
 
 # include <boost/iterator/detail/config_undef.hpp>
 

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
+namespace boost { namespace detail { 
-// with boost/token_iterator.hpp. It should be removed as soon as that header is fixed.
+//
-namespace detail {
+// Returns the minimum category type or error_type
-using iterators::minimum_category;
+// if T1 and T2 are unrelated.
-} // namespace detail
+//
+// 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

include/boost/iterator/distance.hpp

@@ -1,65 +0,0 @@
-// Copyright (C) 2017 Michel Morin.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ITERATOR_DISTANCE_HPP
-#define BOOST_ITERATOR_DISTANCE_HPP
-
-#include <boost/config.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-namespace boost {
-namespace iterators {
-
-    namespace detail {
-        template <typename SinglePassIterator>
-        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
-        distance_impl(
-            SinglePassIterator first
-          , SinglePassIterator last
-          , single_pass_traversal_tag
-        )
-        {
-            typename iterator_difference<SinglePassIterator>::type n = 0;
-            while (first != last) {
-                ++first;
-                ++n;
-            }
-            return n;
-        }
-
-        template <typename RandomAccessIterator>
-        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<RandomAccessIterator>::type
-        distance_impl(
-            RandomAccessIterator first
-          , RandomAccessIterator last
-          , random_access_traversal_tag
-        )
-        {
-            return last - first;
-        }
-    }
-
-    namespace distance_adl_barrier {
-        template <typename SinglePassIterator>
-        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
-        distance(SinglePassIterator first, SinglePassIterator last)
-        {
-            return detail::distance_impl(
-                first, last, typename iterator_traversal<SinglePassIterator>::type()
-            );
-        }
-    }
-
-    using namespace distance_adl_barrier;
-
-} // namespace iterators
-
-using iterators::distance;
-
-} // namespace boost
-
-#endif

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 boost
-namespace iterators {
+{
-
   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

include/boost/iterator/function_input_iterator.hpp

@@ -1,6 +1,4 @@
 // Copyright 2009 (C) Dean Michael Berris <me@deanberris.com>
-// Copyright 2012 (C) Google, Inc.
-// Copyright 2012 (C) Jeffrey Lee Hellrung, Jr.
 // 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)
@@ -9,48 +7,32 @@
 #ifndef BOOST_FUNCTION_INPUT_ITERATOR
 #define BOOST_FUNCTION_INPUT_ITERATOR
 
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/function_types/is_function_pointer.hpp>
-#include <boost/function_types/is_function_reference.hpp>
-#include <boost/function_types/result_type.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/none.hpp>
-#include <boost/optional/optional.hpp>
-#include <boost/utility/result_of.hpp>
 
 namespace boost {
 
-namespace iterators {
+    template <class Function, class Input>
-
-    namespace impl {
-
-        template <class Function, class Input>
         class function_input_iterator
-            : public iterator_facade<
+        : public iterator_facade<
             function_input_iterator<Function, Input>,
-            BOOST_DEDUCED_TYPENAME result_of<Function ()>::type,
+            typename Function::result_type,
             single_pass_traversal_tag,
-            BOOST_DEDUCED_TYPENAME result_of<Function ()>::type const &
+            typename Function::result_type const &
             >
-        {
+    {
         public:
             function_input_iterator() {}
-            function_input_iterator(Function & f_, Input state_ = Input())
+            function_input_iterator(Function * f_, Input state_ = Input()) 
-                : f(&f_), state(state_) {}
+                : f(f_), state(state_), value((*f)()) {}
 
             void increment() {
-                if(value)
+                value = (*f)();
-                    value = none;
-                else
-                    (*f)();
                 ++state;
             }
 
-            BOOST_DEDUCED_TYPENAME result_of<Function ()>::type const &
+            typename Function::result_type const & 
-                dereference() const {
+            dereference() const {
-                    return (value ? value : value = (*f)()).get();
+                return value;
             }
 
             bool equal(function_input_iterator const & other) const {
@@ -60,96 +42,14 @@ namespace iterators {
         private:
             Function * f;
             Input state;
-            mutable optional<BOOST_DEDUCED_TYPENAME result_of<Function ()>::type> value;
+            typename Function::result_type value;
-        };
-
-        template <class Function, class Input>
-        class function_pointer_input_iterator
-            : public iterator_facade<
-            function_pointer_input_iterator<Function, Input>,
-            typename function_types::result_type<Function>::type,
-            single_pass_traversal_tag,
-            typename function_types::result_type<Function>::type const &
-            >
-        {
-        public:
-            function_pointer_input_iterator() {}
-            function_pointer_input_iterator(Function &f_, Input state_ = Input())
-                : f(f_), state(state_) {}
-
-            void increment() {
-                if(value)
-                    value = none;
-                else
-                    (*f)();
-                ++state;
-            }
-
-            typename function_types::result_type<Function>::type const &
-                dereference() const {
-                    return (value ? value : value = (*f)()).get();
-            }
-
-            bool equal(function_pointer_input_iterator const & other) const {
-                return f == other.f && state == other.state;
-            }
-
-        private:
-            Function f;
-            Input state;
-            mutable optional<typename function_types::result_type<Function>::type> value;
-        };
-
-        template <class Function, class Input>
-        class function_reference_input_iterator
-            : public function_pointer_input_iterator<Function*,Input>
-        {
-        public:
-            function_reference_input_iterator(Function & f_, Input state_ = Input())
-                : function_pointer_input_iterator<Function*,Input>(&f_, state_)
-            {}
-        };
-
-    } // namespace impl
-
-    template <class Function, class Input>
-    class function_input_iterator
-        : public mpl::if_<
-            function_types::is_function_pointer<Function>,
-            impl::function_pointer_input_iterator<Function,Input>,
-            typename mpl::if_<
-                function_types::is_function_reference<Function>,
-                impl::function_reference_input_iterator<Function,Input>,
-                impl::function_input_iterator<Function,Input>
-            >::type
-        >::type
-    {
-        typedef typename mpl::if_<
-            function_types::is_function_pointer<Function>,
-            impl::function_pointer_input_iterator<Function,Input>,
-            typename mpl::if_<
-                function_types::is_function_reference<Function>,
-                impl::function_reference_input_iterator<Function,Input>,
-                impl::function_input_iterator<Function,Input>
-            >::type
-        >::type base_type;
-    public:
-        function_input_iterator(Function & f, Input i)
-            : base_type(f, i) {}
     };
 
     template <class Function, class Input>
     inline function_input_iterator<Function, Input>
-        make_function_input_iterator(Function & f, Input state) {
+    make_function_input_iterator(Function & f, Input state) {
-            typedef function_input_iterator<Function, Input> result_t;
+        typedef function_input_iterator<Function, Input> result_t;
-            return result_t(f, state);
+        return result_t(&f, state);
-    }
-
-    template <class Function, class Input>
-    inline function_input_iterator<Function*, Input>
-        make_function_input_iterator(Function * f, Input state) {
-            typedef function_input_iterator<Function*, Input> result_t;
-            return result_t(f, state);
     }
 
     struct infinite {
@@ -158,14 +58,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
 

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 boost
-namespace iterators {
+{
-
   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>

include/boost/iterator/interoperable.hpp

@@ -14,8 +14,8 @@
 
 # include <boost/iterator/detail/config_def.hpp> // must appear last
 
-namespace boost {
+namespace boost
-namespace iterators {
+{
 
   //
   // Meta function that determines whether two
@@ -27,7 +27,7 @@ namespace 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>

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
+// Define the trait with full mpl lambda capability and various broken
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value>
+// compiler workarounds
-{
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-public:
+    is_lvalue_iterator,T,::boost::detail::is_readable_lvalue_iterator_impl<T>::value)
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_lvalue_iterator,(T))
+    
-};
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-
+    is_non_const_lvalue_iterator,T,::boost::detail::is_non_const_lvalue_iterator_impl<T>::value)
-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;
-
 } // 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

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
+// Define the trait with full mpl lambda capability and various broken
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value>
+// compiler workarounds
-{
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-public:
+    is_readable_iterator,T,::boost::detail::is_readable_iterator_impl2<T>::value)
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_readable_iterator,(T))
+    
-};
-
-} // namespace iterators
-
-using iterators::is_readable_iterator;
-
 } // namespace boost
 
 #endif

include/boost/iterator/iterator_adaptor.hpp

@@ -24,40 +24,41 @@
 
 #ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
 # include <boost/type_traits/remove_reference.hpp>
+
+# if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
+#   include <boost/type_traits/add_reference.hpp>
+# endif
+
+#else
+# include <boost/type_traits/add_reference.hpp>
 #endif
 
-#include <boost/type_traits/add_reference.hpp>
 #include <boost/iterator/detail/config_def.hpp>
 
 #include <boost/iterator/iterator_traits.hpp>
 
-namespace boost {
+namespace boost
-namespace iterators {
+{
-
   // Used as a default template argument internally, merely to
   // indicate "use the default", this can also be passed by users
   // explicitly in order to specify that the default should be used.
   struct use_default;
-
+  
-} // namespace iterators
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
+  // the incompleteness of use_default causes massive problems for
-using iterators::use_default;
+  // is_convertible (naturally).  This workaround is fortunately not
-
+  // needed for vc6/vc7.
-// the incompleteness of use_default causes massive problems for
+  template<class To>
-// is_convertible (naturally).  This workaround is fortunately not
+  struct is_convertible<use_default,To>
-// needed for vc6/vc7.
+    : mpl::false_ {};
-template<class To>
+# endif 
-struct is_convertible<use_default,To>
+  
-  : mpl::false_ {};
-
-namespace iterators {
-
   namespace detail
   {
 
-    //
+    // 
     // Result type used in enable_if_convertible meta function.
-    // This can be an incomplete type, as only pointers to
+    // This can be an incomplete type, as only pointers to 
     // enable_if_convertible< ... >::type are used.
     // We could have used void for this, but conversion to
     // void* is just to easy.
@@ -78,7 +79,7 @@ namespace iterators {
   //   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
   // {
   // public:
-  //
+  //   
   //   ...
   //
   //   template <class OtherIterator>
@@ -97,23 +98,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.
+  // always enabled for compilers that don't support enable_if or is_convertible. 
-  // There is no need for compiler specific workarounds in user code.
+  // 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 +139,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 +186,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 +197,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 +216,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 +230,7 @@ namespace iterators {
       BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
     }
   }
-
+  
   //
   // Iterator Adaptor
   //
@@ -249,14 +265,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 +291,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 +307,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 +328,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 +346,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 +359,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>

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<
+    : mpl::aux::msvc_eti_base<
-          is_convertible<TraversalCategory, random_access_traversal_tag>
+          typename mpl::eval_if<
-        , mpl::eval_if<
+              is_convertible<TraversalCategory, random_access_traversal_tag>
-              archetypes::has_access<
+            , mpl::eval_if<
-                  AccessCategory
+                  iterator_archetypes::has_access<
-                , archetypes::writable_iterator_t
-              >
-            , mpl::identity<writable_operator_brackets<Value> >
-            , mpl::if_<
-                  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<
+  : mpl::aux::msvc_eti_base<
-        AccessCategory
+        typename iterator_access_archetype_impl<
-    >::template archetype<Value>
+            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<
+              iterator_archetypes::has_access<
-                  AccessCategory, archetypes::writable_iterator_t
+                  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

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>

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::detail::pure_traversal_tag<
-      typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category;
+          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;

include/boost/iterator/iterator_facade.hpp

@@ -7,22 +7,19 @@
 #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>
 
+#include <boost/implicit_cast.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/utility/addressof.hpp>
 
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_pointer.hpp>
-#include <boost/type_traits/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 boost
-namespace iterators {
+{
-
   // This forward declaration is required for the friend declaration
   // in iterator_core_access
   template <class I, class V, class TC, class R, class D> class iterator_facade;
@@ -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 :
+    struct enable_if_interoperable
-        public boost::iterators::enable_if<
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-            is_interoperable< Facade1, Facade2 >
+    {
-          , Return
+        typedef typename mpl::if_<
-        >
+            mpl::or_<
-    {};
+                is_convertible<Facade1, Facade2>
-
+              , is_convertible<Facade2, Facade1>
-    //
-    // enable if for use in implementation of operators specific for random access traversal.
-    //
-    template <
-        class Facade1
-      , class Facade2
-      , class Return
-    >
-    struct enable_if_interoperable_and_random_access_traversal :
-        public boost::iterators::enable_if<
-            mpl::and_<
-                is_interoperable< Facade1, Facade2 >
-              , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
-              , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
             >
           , Return
+          , int[3]
+        >::type type;
+    };        
+#else
+      : ::boost::iterators::enable_if<
+           mpl::or_<
+               is_convertible<Facade1, Facade2>
+             , is_convertible<Facade2, Facade1>
+           >
+         , Return
         >
     {};
+#endif 
 
     //
     // Generates associated types for an iterator_facade with the
@@ -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)))     \
@@ -160,7 +147,7 @@ namespace iterators {
 
         // Returning a mutable reference allows nonsense like
         // (*r++).mutate(), but it imposes fewer assumptions about the
-        // behavior of the value_type.  In particular, recall that
+        // behavior of the value_type.  In particular, recall taht
         // (*r).mutate() is legal if operator* returns by value.
         value_type&
         operator*() const
@@ -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<
+                is_convertible<Reference,Value const&>
-                    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
-                >
-
                 // No multipass iterator can have values that disappear
                 // before positions can be re-visited
               , mpl::not_<
@@ -315,36 +294,48 @@ namespace iterators {
 
     // operator->() needs special support for input iterators to strictly meet the
     // standard's requirements. If *i is not a reference type, we must still
-    // produce an lvalue to which a pointer can be formed.  We do that by
+    // produce a lvalue to which a pointer can be formed. We do that by
-    // returning a proxy object containing an instance of the reference object.
+    // returning an instantiation of this special proxy class template.
-    template <class Reference, class Pointer>
+    template <class T>
-    struct operator_arrow_dispatch // proxy references
+    struct operator_arrow_proxy
     {
-        struct proxy
+        operator_arrow_proxy(T const* px) : m_value(*px) {}
+        T* operator->() const { return &m_value; }
+        // This function is needed for MWCW and BCC, which won't call operator->
+        // again automatically per 13.3.1.2 para 8
+        operator T*() const { return &m_value; }
+        mutable T m_value;
+    };
+
+    // A metafunction that gets the result type for operator->.  Also
+    // has a static function make() which builds the result from a
+    // Reference
+    template <class ValueType, class Reference, class Pointer>
+    struct operator_arrow_result
+    {
+        // CWPro8.3 won't accept "operator_arrow_result::type", and we
+        // need that type below, so metafunction forwarding would be a
+        // losing proposition here.
+        typedef typename mpl::if_<
+            is_reference<Reference>
+          , Pointer
+          , operator_arrow_proxy<ValueType>
+        >::type type;
+
+        static type make(Reference x)
         {
-            explicit proxy(Reference const & x) : m_ref(x) {}
+            return implicit_cast<type>(&x);
-            Reference* operator->() { return boost::addressof(m_ref); }
-            // This function is needed for MWCW and BCC, which won't call
-            // operator-> again automatically per 13.3.1.2 para 8
-            operator Reference*() { return boost::addressof(m_ref); }
-            Reference m_ref;
-        };
-        typedef proxy result_type;
-        static result_type apply(Reference const & x)
-        {
-            return result_type(x);
         }
     };
 
-    template <class T, class Pointer>
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    struct operator_arrow_dispatch<T&, Pointer> // "real" references
+    // Deal with ETI
+    template<>
+    struct operator_arrow_result<int, int, int>
     {
-        typedef Pointer result_type;
+        typedef int type;
-        static result_type apply(T& x)
-        {
-            return boost::addressof(x);
-        }
     };
+# endif
 
     // A proxy return type for operator[], needed to deal with
     // iterators that may invalidate referents upon destruction.
@@ -390,7 +381,7 @@ namespace iterators {
             >
         >
     {};
-
+        
     template <class Iterator, class Value, class Reference>
     struct operator_brackets_result
     {
@@ -420,34 +411,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 +441,24 @@ namespace iterators {
     operator op(                                                            \
         iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
       , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
-# else
+# else 
-#  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 \
     >                                                                   \
-    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
+# endif 
-
-#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \
-    BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable)
-
-#  define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(prefix, op, result_type)       \
-    BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal)
 
 #  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
     template <class Derived, class V, class TC, class R, class D>   \
-    prefix typename boost::iterators::enable_if<                    \
+    prefix Derived operator+ args
-        boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >,  \
-        Derived                                                     \
-    >::type operator+ args
 
   //
   // Helper class for granting access to the iterator core interface.
@@ -495,49 +471,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_HEAD(
-      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2);
+          friend, -, boost::detail::choose_difference_type)
-
-      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<)
-      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>)
-      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=)
-      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=)
-
-#  undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
-
-      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(
-          friend, -, boost::iterators::detail::choose_difference_type)
       ;
 
       BOOST_ITERATOR_FACADE_PLUS_HEAD(
           friend inline
-        , (iterator_facade<Derived, V, TC, R, D> const&
+          , (iterator_facade<Derived, V, TC, R, D> const&
-        , typename Derived::difference_type)
+           , 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 +576,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 +592,152 @@ namespace iterators {
     , class Reference   = Value&
     , class Difference  = std::ptrdiff_t
   >
-  class iterator_facade :
+  class iterator_facade
-      public detail::iterator_facade_base<
+# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
-          Derived,
+    : public boost::detail::iterator_facade_types<
-          Value,
+         Value, CategoryOrTraversal, Reference, Difference
-          CategoryOrTraversal,
+      >::base
-          Reference,
+#  undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
-          Difference,
+# endif
-          detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value,
-          detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value
-      >
   {
-  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_result<
+        typename associated_types::value_type
+        , Reference
+        , typename associated_types::pointer
+      > pointer_;
+
+   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 pointer_::type pointer;
+
+      typedef typename associated_types::iterator_category iterator_category;
+
+      reference operator*() const
+      {
+          return iterator_core_access::dereference(this->derived());
+      }
+
+      pointer operator->() const
+      {
+          return pointer_::make(*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 +828,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 +836,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 +859,18 @@ namespace iterators {
       return tmp += n;                              \
   }
 
-  BOOST_ITERATOR_FACADE_PLUS((
+BOOST_ITERATOR_FACADE_PLUS((
-      iterator_facade<Derived, V, TC, R, D> const& i
+  iterator_facade<Derived, V, TC, R, D> const& i
-    , typename Derived::difference_type n
+  , typename Derived::difference_type n
-  ))
+))
 
-  BOOST_ITERATOR_FACADE_PLUS((
+BOOST_ITERATOR_FACADE_PLUS((
-      typename Derived::difference_type n
+    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>

include/boost/iterator/iterator_traits.hpp

@@ -8,12 +8,20 @@
 # include <boost/detail/iterator.hpp>
 # include <boost/detail/workaround.hpp>
 
-namespace boost {
+namespace boost { 
-namespace iterators {
 
-// Macro for supporting old compilers, no longer needed but kept
+// Unfortunately, g++ 2.95.x chokes when we define a class template
-// for backwards compatibility (it was documented).
+// iterator_category which has the same name as its
-#define BOOST_ITERATOR_CATEGORY iterator_category
+// 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;
+template <>
-using iterators::iterator_reference;
+struct iterator_pointer<int>
-using iterators::iterator_pointer;
+{
-using iterators::iterator_difference;
+    typedef void type;
-using iterators::iterator_category;
+};
+  
+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

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_

include/boost/iterator/permutation_iterator.hpp

@@ -13,28 +13,28 @@
 #include <boost/iterator/iterator_adaptor.hpp>
 
 
-namespace boost {
+namespace boost
-namespace iterators {
+{
 
 template< class ElementIterator
         , class IndexIterator>
 class permutation_iterator
-  : public iterator_adaptor<
+  : public iterator_adaptor< 
              permutation_iterator<ElementIterator, IndexIterator>
-           , IndexIterator, typename boost::detail::iterator_traits<ElementIterator>::value_type
+           , IndexIterator, typename detail::iterator_traits<ElementIterator>::value_type
-           , use_default, typename boost::detail::iterator_traits<ElementIterator>::reference>
+           , 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
+          , IndexIterator, typename detail::iterator_traits<ElementIterator>::value_type
-          , use_default, typename boost::detail::iterator_traits<ElementIterator>::reference> super_t;
+          , 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
 

include/boost/iterator/reverse_iterator.hpp

@@ -8,10 +8,11 @@
 #define BOOST_REVERSE_ITERATOR_23022003THW_HPP
 
 #include <boost/iterator.hpp>
+#include <boost/utility.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 
-namespace boost {
+namespace boost
-namespace iterators {
+{
 
   //
   //
@@ -27,7 +28,7 @@ namespace iterators {
    public:
       reverse_iterator() {}
 
-      explicit reverse_iterator(Iterator x)
+      explicit reverse_iterator(Iterator x) 
           : super_t(x) {}
 
       template<class OtherIterator>
@@ -39,19 +40,14 @@ namespace iterators {
       {}
 
    private:
-      typename super_t::reference dereference() const
+      typename super_t::reference dereference() const { return *boost::prior(this->base()); }
-      {
+    
-          Iterator it = this->base_reference();
-          --it;
-          return *it;
-      }
-
       void increment() { --this->base_reference(); }
       void decrement() { ++this->base_reference(); }
 
       void advance(typename super_t::difference_type n)
       {
-          this->base_reference() -= n;
+          this->base_reference() += -n;
       }
 
       template <class OtherIterator>
@@ -63,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

include/boost/iterator/transform_iterator.hpp

@@ -26,28 +26,29 @@
 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
 # include <boost/type_traits/is_base_and_derived.hpp>
 
-#endif
+#endif 
 #include <boost/iterator/detail/config_def.hpp>
 
 
-namespace boost {
+namespace boost
-namespace iterators {
+{
-
   template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
   class transform_iterator;
 
-  namespace detail
+  namespace detail 
   {
     // Compute the iterator_adaptor instantiation to be used for transform_iterator
     template <class UnaryFunc, class Iterator, class Reference, class Value>
     struct transform_iterator_base
     {
      private:
+        typedef typename std::iterator_traits<Iterator>::reference Arg1;
+
         // By default, dereferencing the iterator yields the same as
         // the function.
         typedef typename ia_dflt_help<
             Reference
-          , result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
+          , result_of<UnaryFunc(typename std::iterator_traits<Iterator>::value_type)>
         >::type reference;
 
         // To get the default for Value: remove any reference on the
@@ -73,10 +74,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 +97,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 +110,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 +128,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 +142,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 +160,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>

include/boost/iterator/zip_iterator.hpp

@@ -1,8 +1,6 @@
-// Copyright David Abrahams and Thomas Becker 2000-2006.
+// Copyright David Abrahams and Thomas Becker 2000-2006. Distributed
-// Copyright Kohei Takahashi 2012-2014.
+// under the Boost Software License, Version 1.0. (See accompanying
-//
+// file LICENSE_1_0.txt or copy at
-// 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/tuple/tuple.hpp>
-#include <boost/fusion/adapted/boost_tuple.hpp> // for backward compatibility
 
-#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_cv.hpp>
+#include <boost/mpl/and.hpp>
-
+#include <boost/mpl/apply.hpp>
-#include <boost/mpl/at.hpp>
+#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/fold.hpp>
+#include <boost/mpl/lambda.hpp>
-#include <boost/mpl/transform.hpp>
 #include <boost/mpl/placeholders.hpp>
-
+#include <boost/mpl/aux_/lambda_support.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>
 
 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>
+      template<typename Iterator>
-      struct result;
+      struct apply
-
+      { 
-      template<typename This, typename Iterator>
-      struct result<This(Iterator)>
-      {
         typedef typename
-          remove_cv<typename remove_reference<Iterator>::type>::type
+          iterator_traits<Iterator>::reference
-        iterator;
+        type;
-
-        typedef typename iterator_reference<iterator>::type type;
       };
 
       template<typename Iterator>
-        typename result<dereference_iterator(Iterator)>::type
+        typename apply<Iterator>::type operator()(Iterator const& it)
-        operator()(Iterator const& it) const
       { 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<
+      : tuple_impl_specific::tuple_meta_transform<
-            IteratorTuple,
+            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>
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-    struct minimum_traversal_category_in_iterator_tuple<std::pair<Iterator1, Iterator2> >
+      template <>
-    {
+      struct minimum_traversal_category_in_iterator_tuple<int>
-        typedef typename pure_traversal_tag<
+      {
-            typename iterator_traversal<Iterator1>::type
+          typedef int type;
-        >::type iterator1_traversal;
+      };
-        typedef typename pure_traversal_tag<
+#endif
-            typename iterator_traversal<Iterator2>::type
+      
-        >::type iterator2_traversal;
+      // We need to call tuple_meta_accumulate with mpl::and_ as the
-
+      // accumulating functor. To this end, we need to wrap it into
-        typedef typename minimum_category<
+      // a struct that has exactly two arguments (that is, template
-            iterator1_traversal
+      // parameters) and not five, like mpl::and_ does.
-          , typename minimum_category<
+      //
-                iterator2_traversal
+      template<typename Arg1, typename Arg2>
-              , random_access_traversal_tag
+      struct and_with_two_args
-            >::type
+        : mpl::and_<Arg1, Arg2>
-        >::type type;
+      {
-    };
+      };
+    
+# 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<
+        typedef typename iterator_traits<
-            typename mpl::at_c<IteratorTuple, 0>::type
+            typename tuples::element<0, IteratorTuple>::type
-        >::type difference_type;
+            >::difference_type difference_type;
-
+      
-        // Traversal catetgory is the minimum traversal category in the
+        // Traversal catetgory is the minimum traversal category in the 
         // iterator tuple.
-        typedef typename
+        typedef typename 
         detail::minimum_traversal_category_in_iterator_tuple<
             IteratorTuple
         >::type traversal_category;
      public:
-
+      
         // The iterator facade type from which the zip iterator will
         // be derived.
         typedef iterator_facade<
             zip_iterator<IteratorTuple>,
-            value_type,
+            value_type,  
             traversal_category,
             reference,
             difference_type
@@ -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 super_t as our base class. 
-   typedef typename
+   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)
+    zip_iterator(IteratorTuple iterator_tuple) 
-      : m_iterator_tuple(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;
+      return detail::tuple_impl_specific::tuple_transform( 
-        typedef detail::converter<reference> gen;
+        get_iterator_tuple(),
-        return gen::call(fusion::transform(
+        detail::dereference_iterator()
-          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(
+      return detail::tuple_impl_specific::tuple_equal(
-          get_iterator_tuple(),
+        get_iterator_tuple(),
-          other.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(
+      detail::tuple_impl_specific::tuple_for_each(
-          m_iterator_tuple,
+        m_iterator_tuple,
-          detail::increment_iterator());
+        detail::increment_iterator()
+        );
     }
-
+    
     // Decrementing a zip iterator means to decrement all iterators in
     // the iterator tuple.
     void decrement()
-    {
+    { 
-        fusion::for_each(
+      detail::tuple_impl_specific::tuple_for_each(
-          m_iterator_tuple,
+        m_iterator_tuple,
-          detail::decrement_iterator());
+        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()) -
+        return boost::tuples::get<0>(other.get_iterator_tuple()) - 
-            fusion::at_c<0>(this->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>
+  template<typename IteratorTuple> 
-  inline zip_iterator<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

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;
+  using ::int_iterator;
-namespace iterators {
+}
-using ::int_iterator;
-}}
 #endif
 
 

include/boost/pending/integer_range.hpp

@@ -0,0 +1,59 @@
+// (C) Copyright David Abrahams and Jeremy Siek 2000-2001.
+// 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)
+//
+// Revision History:
+// 04 Jan 2001  Factored counting_iterator stuff into
+//              boost/counting_iterator.hpp (David Abrahams)
+
+#ifndef BOOST_INTEGER_RANGE_HPP_
+#define BOOST_INTEGER_RANGE_HPP_
+
+#include <boost/config.hpp>
+#include <boost/iterator/counting_iterator.hpp>
+#include <algorithm>
+
+namespace boost {
+
+//=============================================================================
+// Counting Iterator and Integer Range Class
+
+template <class IntegerType>
+struct integer_range {
+    typedef counting_iterator<IntegerType> iterator;
+
+    typedef iterator const_iterator;
+    typedef IntegerType value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef IntegerType reference;
+    typedef IntegerType const_reference;
+    typedef const IntegerType* pointer;
+    typedef const IntegerType* const_pointer;
+    typedef IntegerType size_type;
+
+    integer_range(IntegerType start, IntegerType finish)
+        : m_start(start), m_finish(finish) { }
+
+    iterator begin() const { return iterator(m_start); }
+    iterator end() const { return iterator(m_finish); }
+    size_type size() const { return m_finish - m_start; }
+    bool empty() const { return m_finish == m_start; }
+    void swap(integer_range& x) {
+        std::swap(m_start, x.m_start);
+        std::swap(m_finish, x.m_finish);
+    }
+protected:
+    IntegerType m_start, m_finish;
+};
+
+template <class IntegerType>
+inline integer_range<IntegerType>
+make_integer_range(IntegerType first, IntegerType last)
+{
+  return integer_range<IntegerType>(first, last);
+}
+
+} // namespace boost
+
+#endif // BOOST_INTEGER_RANGE_HPP_

include/boost/pending/iterator_tests.hpp

@@ -25,26 +25,28 @@
 # include <boost/static_assert.hpp>
 # include <boost/concept_archetype.hpp> // for detail::dummy_constructor
 # include <boost/implicit_cast.hpp>
+# include <boost/type_traits/broken_compiler_spec.hpp>
 
 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;
 };
 
 }
 
+BOOST_TT_BROKEN_COMPILER_SPEC(boost::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 +87,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 +153,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 +218,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 +237,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 +263,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

include/boost/pointee.hpp

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

include/boost/shared_container_iterator.hpp

@@ -13,7 +13,6 @@
 #include <utility>
 
 namespace boost {
-namespace iterators {
 
 template <typename Container>
 class shared_container_iterator : public iterator_adaptor<
@@ -38,7 +37,7 @@ public:
 };
 
 template <typename Container>
-inline shared_container_iterator<Container>
+shared_container_iterator<Container>
 make_shared_container_iterator(typename Container::iterator iter,
                                boost::shared_ptr<Container> const& container) {
   typedef shared_container_iterator<Container> iterator;
@@ -48,7 +47,7 @@ make_shared_container_iterator(typename Container::iterator iter,
 
 
 template <typename Container>
-inline std::pair<
+std::pair<
   shared_container_iterator<Container>,
   shared_container_iterator<Container> >
 make_shared_container_range(boost::shared_ptr<Container> const& container) {
@@ -58,12 +57,6 @@ make_shared_container_range(boost::shared_ptr<Container> const& container) {
       make_shared_container_iterator(container->end(),container));
 }
 
-} // namespace iterators
-
-using iterators::shared_container_iterator;
-using iterators::make_shared_container_iterator;
-using iterators::make_shared_container_range;
 
 } // namespace boost
-
 #endif  // SHARED_CONTAINER_ITERATOR_RG08102002_HPP

meta/libraries.json

@@ -1,18 +0,0 @@
-{
-    "key": "iterator",
-    "name": "Iterator",
-    "authors": [
-        "Dave Abrahams",
-        "Jeremy Siek",
-        "Thomas Witt"
-    ],
-    "description": "The Boost Iterator Library contains two parts. The first is a system of concepts which extend the C++ standard iterator requirements. The second is a framework of components for building iterators based on these extended concepts and includes several useful iterator adaptors.",
-    "category": [
-        "Iterators"
-    ],
-    "maintainers": [
-        "David Abrahams <dave -at- boost-consulting.com>",
-        "Thomas Witt <witt - at - acm.org>",
-        "Jeffrey Lee Hellrung Jr. <jeffrey.hellrung -at- gmail.com>"
-    ]
-}

test/Jamfile.v2

@@ -3,34 +3,28 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 test-suite iterator
-  :
+  : 
     # These first two tests will run last, and are expected to fail
     # for many less-capable compilers.
-
+  
     [ compile-fail interoperable_fail.cpp ]
     # test uses expected success, so that we catch unrelated
     # compilation problems.
-    [ run is_convertible_fail.cpp ]
+    [ run is_convertible_fail.cpp ]  
 
     [ run zip_iterator_test.cpp
-        : : :
+        : : : 
+        
         # stlport's debug mode generates long symbols which overwhelm
         # vc6
-        #<msvc-stlport><*><runtime-build>release
+        #<msvc-stlport><*><runtime-build>release 
     ]
-    [ run zip_iterator_test2_std_tuple.cpp ]
+      
-    [ run zip_iterator_test2_fusion_vector.cpp ]
-    [ run zip_iterator_test2_fusion_list.cpp ]
-#    [ run zip_iterator_test2_fusion_deque.cpp ] // See bug report for fusion https://svn.boost.org/trac/boost/ticket/11572
-    [ run zip_iterator_test_fusion.cpp ]
-    [ run zip_iterator_test_std_tuple.cpp ]
-    [ run zip_iterator_test_std_pair.cpp ]
-
     # These tests should work for just about everything.
     [ compile is_lvalue_iterator.cpp ]
     [ compile is_readable_iterator.cpp ]
     [ compile pointee.cpp ]
-
+      
     [ run unit_tests.cpp ]
     [ run concept_tests.cpp ]
     [ run iterator_adaptor_cc.cpp ]
@@ -47,15 +41,7 @@ test-suite iterator
     [ run counting_iterator_test.cpp ]
     [ run interoperable.cpp ]
     [ run iterator_traits_test.cpp ]
-    [ run permutation_iterator_test.cpp : : : # <stlport-iostream>on
+    [ run permutation_iterator_test.cpp : : : # <stlport-iostream>on 
     ]
-    [ run function_input_iterator_test.cpp ]
+      
-
-    [ run generator_iterator_test.cpp ]
-
-    [ run minimum_category.cpp ]
-    [ compile-fail minimum_category_compile_fail.cpp ]
-
-    [ run advance_test.cpp ]
-    [ run distance_test.cpp ]
 ;

test/advance_test.cpp

@@ -1,91 +0,0 @@
-// Copyright (C) 2017 Michel Morin.
-//
-// 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)
-
-#include <vector>
-#include <list>
-#include <boost/container/slist.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/iterator/advance.hpp>
-#include <boost/iterator/transform_iterator.hpp>
-
-int twice(int x) { return x + x; }
-
-template <typename Iterator>
-void test_advance(Iterator it_from, Iterator it_to, int n)
-{
-    boost::advance(it_from,  n);
-    BOOST_TEST(it_from == it_to);
-}
-
-int main()
-{
-    int array[3] = {1, 2, 3};
-    int* ptr1 = array;
-    int* ptr2 = array + 3;
-
-    {
-        test_advance(ptr1, ptr2,  3);
-        test_advance(ptr2, ptr1, -3);
-
-        test_advance(
-            boost::make_transform_iterator(ptr1, twice)
-          , boost::make_transform_iterator(ptr2, twice)
-          , 3
-        );
-        test_advance(
-            boost::make_transform_iterator(ptr2, twice)
-          , boost::make_transform_iterator(ptr1, twice)
-          , -3
-        );
-    }
-
-    {
-        std::vector<int> ints(ptr1, ptr2);
-        test_advance(ints.begin(), ints.end(),  3);
-        test_advance(ints.end(), ints.begin(), -3);
-
-        test_advance(
-            boost::make_transform_iterator(ints.begin(), twice)
-          , boost::make_transform_iterator(ints.end(), twice)
-          , 3
-        );
-        test_advance(
-            boost::make_transform_iterator(ints.end(), twice)
-          , boost::make_transform_iterator(ints.begin(), twice)
-          , -3
-        );
-    }
-
-    {
-        std::list<int> ints(ptr1, ptr2);
-        test_advance(ints.begin(), ints.end(),  3);
-        test_advance(ints.end(), ints.begin(), -3);
-
-        test_advance(
-            boost::make_transform_iterator(ints.begin(), twice)
-          , boost::make_transform_iterator(ints.end(), twice)
-          , 3
-        );
-        test_advance(
-            boost::make_transform_iterator(ints.end(), twice)
-          , boost::make_transform_iterator(ints.begin(), twice)
-          , -3
-        );
-    }
-
-    {
-        boost::container::slist<int> ints(ptr1, ptr2);
-        test_advance(ints.begin(), ints.end(),  3);
-
-        test_advance(
-            boost::make_transform_iterator(ints.begin(), twice)
-          , boost::make_transform_iterator(ints.end(), twice)
-          , 3
-        );
-    }
-
-    return boost::report_errors();
-}

test/detail/zip_iterator_test.ipp

@@ -1,85 +0,0 @@
-// Copyright (c) 2014 Kohei Takahashi.
-//
-// 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)
-//
-//  See http://www.boost.org for most recent version including documentation.
-
-#include <boost/detail/lightweight_test.hpp>
-
-#include <boost/assign/list_of.hpp>
-#include <boost/fusion/include/at.hpp>
-#include <boost/iterator/zip_iterator.hpp>
-#include <vector>
-#include <string>
-
-
-int main()
-{
-    typedef TUPLE<
-        std::vector<int>::iterator,
-        std::vector<std::string>::iterator
-    > iterator_tuple;
-
-    std::vector<int>         vi = boost::assign::list_of(42)(72);
-    std::vector<std::string> vs = boost::assign::list_of("kokoro")("pyonpyon");
-
-    {
-        boost::zip_iterator<iterator_tuple> i1(MAKE_TUPLE(vi.begin(), vs.begin()));
-        boost::zip_iterator<iterator_tuple> i2 = i1;
-
-        BOOST_TEST( i1      ==   i2);
-        BOOST_TEST( i1++    ==   i2);
-        BOOST_TEST( i1      ==  (i2 + 1));
-        BOOST_TEST((i1 - 1) ==   i2);
-        BOOST_TEST( i1--    == ++i2);
-        BOOST_TEST( i1      == --i2);
-    }
-
-    {
-        boost::zip_iterator<iterator_tuple> i1(MAKE_TUPLE(vi.begin(), vs.begin()));
-        boost::zip_iterator<iterator_tuple> i2 = i1 + 1;
-
-        BOOST_TEST( i1      !=   i2);
-        BOOST_TEST( i1++    !=   i2);
-        BOOST_TEST( i1      !=  (i2 + 1));
-        BOOST_TEST((i1 - 1) !=   i2);
-        BOOST_TEST( i1--    != ++i2);
-        BOOST_TEST( i1      != --i2);
-    }
-
-    {
-        boost::zip_iterator<iterator_tuple> i(MAKE_TUPLE(vi.begin(), vs.begin()));
-
-        BOOST_TEST(boost::fusion::at_c<0>(* i     ) == 42);
-        BOOST_TEST(boost::fusion::at_c<1>(* i     ) == "kokoro");
-        BOOST_TEST(boost::fusion::at_c<0>(*(i + 1)) == 72);
-        BOOST_TEST(boost::fusion::at_c<1>(*(i + 1)) == "pyonpyon");
-    }
-
-    {
-        // Trac #12895
-        boost::zip_iterator<
-            TUPLE<int*, std::string*>
-        > i(MAKE_TUPLE(vi.data(), vs.data()));
-
-        BOOST_TEST(boost::fusion::at_c<0>(* i     ) == 42);
-        BOOST_TEST(boost::fusion::at_c<1>(* i     ) == "kokoro");
-        BOOST_TEST(boost::fusion::at_c<0>(*(i + 1)) == 72);
-        BOOST_TEST(boost::fusion::at_c<1>(*(i + 1)) == "pyonpyon");
-    }
-
-    {
-        boost::zip_iterator<iterator_tuple> i1(MAKE_TUPLE(vi.begin(), vs.begin()));
-        boost::zip_iterator<iterator_tuple> i2(MAKE_TUPLE(vi.end(),   vs.end()));
-
-        BOOST_TEST((i2 - i1) == 2);
-        ++i1;
-        BOOST_TEST((i2 - i1) == 1);
-        --i2;
-        BOOST_TEST((i2 - i1) == 0);
-    }
-
-    return boost::report_errors();
-}

test/detail/zip_iterator_test_original.ipp

@@ -1,857 +0,0 @@
-// (C) Copyright Dave Abrahams and Thomas Becker 2003. 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)
-//
-
-// File:
-// =====
-// zip_iterator_test_main.cpp
-
-// Author:
-// =======
-// Thomas Becker
-
-// Created:
-// ========
-// Jul 15, 2003
-
-// Purpose:
-// ========
-// Test driver for zip_iterator.hpp
-
-// Compilers Tested:
-// =================
-// Metrowerks Codewarrior Pro 7.2, 8.3
-// gcc 2.95.3
-// gcc 3.2
-// Microsoft VC 6sp5 (test fails due to some compiler bug)
-// Microsoft VC 7 (works)
-// Microsoft VC 7.1
-// Intel 5
-// Intel 6
-// Intel 7.1
-// Intel 8
-// Borland 5.5.1 (broken due to lack of support from Boost.Tuples)
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Includes
-//
-/////////////////////////////////////////////////////////////////////////////
-
-#include <boost/iterator/zip_iterator.hpp>
-#include <boost/iterator/zip_iterator.hpp> // 2nd #include tests #include guard.
-#include <iostream>
-#include <vector>
-#include <list>
-#include <set>
-#include <string>
-#include <functional>
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/iterator/is_readable_iterator.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/detail/workaround.hpp>
-#include <stddef.h>
-
-
-/// Tests for https://svn.boost.org/trac/boost/ticket/1517
-int to_value(int const &v)
-{
-    return v;
-}
-
-void category_test()
-{
-    std::list<int> rng1;
-    std::string rng2;
-
-    boost::make_zip_iterator(
-        ZI_MAKE_TUPLE(
-            boost::make_transform_iterator(rng1.begin(), &to_value), // BidirectionalInput
-            rng2.begin() // RandomAccess
-        )
-    );
-}
-///
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Das Main Funktion
-//
-/////////////////////////////////////////////////////////////////////////////
-
-int main( void )
-{
-
-  category_test();
-
-  std::cout << "\n"
-            << "***********************************************\n"
-            << "*                                             *\n"
-            << "* Test driver for boost::zip_iterator         *\n"
-            << "* Copyright Thomas Becker 2003                *\n"
-            << "*                                             *\n"
-            << "***********************************************\n\n"
-            << std::flush;
-
-  size_t num_successful_tests = 0;
-  size_t num_failed_tests = 0;
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator construction and dereferencing
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator construction and dereferencing: "
-            << std::flush;
-
-  std::vector<double> vect1(3);
-  vect1[0] = 42.;
-  vect1[1] = 43.;
-  vect1[2] = 44.;
-
-  std::set<int> intset;
-  intset.insert(52);
-  intset.insert(53);
-  intset.insert(54);
-  //
-
-  typedef
-  boost::zip_iterator<
-      ZI_TUPLE<
-          std::set<int>::iterator
-        , std::vector<double>::iterator
-      >
-  > zit_mixed;
-
-  zit_mixed zip_it_mixed = zit_mixed(
-    ZI_MAKE_TUPLE(
-        intset.begin()
-      , vect1.begin()
-    )
-  );
-
-  ZI_TUPLE<int, double> val_tuple(
-      *zip_it_mixed);
-
-  ZI_TUPLE<const int&, double&> ref_tuple(
-      *zip_it_mixed);
-
-  double dblOldVal = ZI_TUPLE_GET(1)(ref_tuple);
-  ZI_TUPLE_GET(1)(ref_tuple) -= 41.;
-
-  if( 52 == ZI_TUPLE_GET(0)(val_tuple) &&
-      42. == ZI_TUPLE_GET(1)(val_tuple) &&
-      52 == ZI_TUPLE_GET(0)(ref_tuple)  &&
-      1. == ZI_TUPLE_GET(1)(ref_tuple)  &&
-      1. == *vect1.begin()
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  // Undo change to vect1
-  ZI_TUPLE_GET(1)(ref_tuple) = dblOldVal;
-  
-#if defined(ZI_USE_BOOST_TUPLE)
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator with 12 components
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterators with 12 components:            "
-            << std::flush;
-
-  // Declare 12 containers
-  //
-  std::list<int> li1;
-  li1.push_back(1);
-  std::set<int> se1;
-  se1.insert(2);
-  std::vector<int> ve1;
-  ve1.push_back(3);
-  //
-  std::list<int> li2;
-  li2.push_back(4);
-  std::set<int> se2;
-  se2.insert(5);
-  std::vector<int> ve2;
-  ve2.push_back(6);
-  //
-  std::list<int> li3;
-  li3.push_back(7);
-  std::set<int> se3;
-  se3.insert(8);
-  std::vector<int> ve3;
-  ve3.push_back(9);
-  //
-  std::list<int> li4;
-  li4.push_back(10);
-  std::set<int> se4;
-  se4.insert(11);
-  std::vector<int> ve4;
-  ve4.push_back(12);
-
-  // typedefs for cons lists of iterators.
-  typedef boost::tuples::cons<
-    std::set<int>::iterator,
-    ZI_TUPLE<
-      std::vector<int>::iterator,
-      std::list<int>::iterator,
-      std::set<int>::iterator,
-      std::vector<int>::iterator,
-      std::list<int>::iterator,
-      std::set<int>::iterator,
-      std::vector<int>::iterator,
-      std::list<int>::iterator,
-      std::set<int>::iterator,
-      std::vector<int>::const_iterator
-      >::inherited
-    > cons_11_its_type;
-  //
-  typedef boost::tuples::cons<
-    std::list<int>::const_iterator,
-    cons_11_its_type
-    > cons_12_its_type;
-
-  // typedefs for cons lists for dereferencing the zip iterator
-  // made from the cons list above.
-  typedef boost::tuples::cons<
-    const int&,
-    ZI_TUPLE<
-      int&,
-      int&,
-      const int&,
-      int&,
-      int&,
-      const int&,
-      int&,
-      int&,
-      const int&,
-      const int&
-      >::inherited
-    > cons_11_refs_type;
-  //
-  typedef boost::tuples::cons<
-    const int&,
-    cons_11_refs_type
-    > cons_12_refs_type;
-
-  // typedef for zip iterator with 12 elements
-  typedef boost::zip_iterator<cons_12_its_type> zip_it_12_type;
-
-  // Declare a 12-element zip iterator.
-  zip_it_12_type zip_it_12(
-    cons_12_its_type(
-      li1.begin(),
-      cons_11_its_type(
-        se1.begin(),
-        ZI_MAKE_TUPLE(
-          ve1.begin(),
-          li2.begin(),
-          se2.begin(),
-          ve2.begin(),
-          li3.begin(),
-          se3.begin(),
-          ve3.begin(),
-          li4.begin(),
-          se4.begin(),
-          ve4.begin()
-          )
-        )
-      )
-    );
-
-  // Dereference, mess with the result a little.
-  cons_12_refs_type zip_it_12_dereferenced(*zip_it_12);
-  ZI_TUPLE_GET(9)(zip_it_12_dereferenced) = 42;
-
-  // Make a copy and move it a little to force some instantiations.
-  zip_it_12_type zip_it_12_copy(zip_it_12);
-  ++zip_it_12_copy;
-
-  if( ZI_TUPLE_GET(11)(zip_it_12.get_iterator_tuple()) == ve4.begin() &&
-      ZI_TUPLE_GET(11)(zip_it_12_copy.get_iterator_tuple()) == ve4.end() &&
-      1 == ZI_TUPLE_GET(0)(zip_it_12_dereferenced) &&
-      12 == ZI_TUPLE_GET(11)(zip_it_12_dereferenced) &&
-      42 == *(li4.begin())
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-  
-#endif
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator incrementing and dereferencing
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator ++ and *:                       "
-            << std::flush;
-
-  std::vector<double> vect2(3);
-  vect2[0] = 2.2;
-  vect2[1] = 3.3;
-  vect2[2] = 4.4;
-
-  boost::zip_iterator<
-    ZI_TUPLE<
-      std::vector<double>::const_iterator,
-      std::vector<double>::const_iterator
-      >
-    >
-  zip_it_begin(
-    ZI_MAKE_TUPLE(
-     vect1.begin(),
-     vect2.begin()
-     )
-  );
-
-  boost::zip_iterator<
-    ZI_TUPLE<
-      std::vector<double>::const_iterator,
-      std::vector<double>::const_iterator
-      >
-    >
-  zip_it_run(
-    ZI_MAKE_TUPLE(
-     vect1.begin(),
-     vect2.begin()
-     )
-  );
-
-  boost::zip_iterator<
-    ZI_TUPLE<
-      std::vector<double>::const_iterator,
-      std::vector<double>::const_iterator
-      >
-    >
-  zip_it_end(
-    ZI_MAKE_TUPLE(
-     vect1.end(),
-     vect2.end()
-     )
-  );
-
-  if( zip_it_run == zip_it_begin &&
-      42. == ZI_TUPLE_GET(0)(*zip_it_run) &&
-      2.2 == ZI_TUPLE_GET(1)(*zip_it_run) &&
-      43. == ZI_TUPLE_GET(0)(*(++zip_it_run)) &&
-      3.3 == ZI_TUPLE_GET(1)(*zip_it_run) &&
-      44. == ZI_TUPLE_GET(0)(*(++zip_it_run)) &&
-      4.4 == ZI_TUPLE_GET(1)(*zip_it_run) &&
-      zip_it_end == ++zip_it_run
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator decrementing and dereferencing
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator -- and *:                       "
-            << std::flush;
-
-  if( zip_it_run == zip_it_end &&
-      zip_it_end == zip_it_run-- &&
-      44. == ZI_TUPLE_GET(0)(*zip_it_run) &&
-      4.4 == ZI_TUPLE_GET(1)(*zip_it_run) &&
-      43. == ZI_TUPLE_GET(0)(*(--zip_it_run)) &&
-      3.3 == ZI_TUPLE_GET(1)(*zip_it_run) &&
-      42. == ZI_TUPLE_GET(0)(*(--zip_it_run)) &&
-      2.2 == ZI_TUPLE_GET(1)(*zip_it_run) &&
-      zip_it_begin == zip_it_run
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator copy construction and equality
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator copy construction and equality: "
-            << std::flush;
-
-  boost::zip_iterator<
-    ZI_TUPLE<
-      std::vector<double>::const_iterator,
-      std::vector<double>::const_iterator
-      >
-    > zip_it_run_copy(zip_it_run);
-
-  if(zip_it_run == zip_it_run && zip_it_run == zip_it_run_copy)
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator inequality
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator inequality:                     "
-            << std::flush;
-
-  if(!(zip_it_run != zip_it_run_copy) && zip_it_run != ++zip_it_run_copy)
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator less than
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator less than:                      "
-            << std::flush;
-
-  // Note: zip_it_run_copy == zip_it_run + 1
-  //
-  if( zip_it_run < zip_it_run_copy  &&
-      !( zip_it_run < --zip_it_run_copy) &&
-      zip_it_run == zip_it_run_copy
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator less than or equal
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "zip iterator less than or equal:             "
-            << std::flush;
-
-  // Note: zip_it_run_copy == zip_it_run
-  //
-  ++zip_it_run;
-  zip_it_run_copy += 2;
-
-  if( zip_it_run <= zip_it_run_copy &&
-      zip_it_run <= --zip_it_run_copy &&
-      !( zip_it_run <= --zip_it_run_copy) &&
-      zip_it_run <= zip_it_run
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator greater than
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator greater than:                   "
-            << std::flush;
-
-  // Note: zip_it_run_copy == zip_it_run - 1
-  //
-  if( zip_it_run > zip_it_run_copy &&
-      !( zip_it_run > ++zip_it_run_copy) &&
-      zip_it_run == zip_it_run_copy
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator greater than or equal
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator greater than or equal:          "
-            << std::flush;
-
-  ++zip_it_run;
-
-  // Note: zip_it_run == zip_it_run_copy + 1
-  //
-  if( zip_it_run >= zip_it_run_copy &&
-      --zip_it_run >= zip_it_run_copy &&
-      ! (zip_it_run >= ++zip_it_run_copy)
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator + int
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator + int:                          "
-            << std::flush;
-
-  // Note: zip_it_run == zip_it_run_copy - 1
-  //
-  zip_it_run = zip_it_run + 2;
-  ++zip_it_run_copy;
-
-  if( zip_it_run == zip_it_run_copy && zip_it_run == zip_it_begin + 3 )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator - int
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator - int:                          "
-            << std::flush;
-
-  // Note: zip_it_run == zip_it_run_copy, and both are at end position
-  //
-  zip_it_run = zip_it_run - 2;
-  --zip_it_run_copy;
-  --zip_it_run_copy;
-
-  if( zip_it_run == zip_it_run_copy && (zip_it_run - 1) == zip_it_begin )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator +=
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator +=:                             "
-            << std::flush;
-
-  // Note: zip_it_run == zip_it_run_copy, and both are at begin + 1
-  //
-  zip_it_run += 2;
-  if( zip_it_run == zip_it_begin + 3 )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator -=
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator -=:                             "
-            << std::flush;
-
-  // Note: zip_it_run is at end position, zip_it_run_copy is at
-  // begin plus one.
-  //
-  zip_it_run -= 2;
-  if( zip_it_run == zip_it_run_copy )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator getting member iterators
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator member iterators:               "
-            << std::flush;
-
-  // Note: zip_it_run and zip_it_run_copy are both at
-  // begin plus one.
-  //
-  if( ZI_TUPLE_GET(0)(zip_it_run.get_iterator_tuple()) == vect1.begin() + 1 &&
-      ZI_TUPLE_GET(1)(zip_it_run.get_iterator_tuple()) == vect2.begin() + 1
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Making zip iterators
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Making zip iterators:                        "
-            << std::flush;
-
-  std::vector<ZI_TUPLE<double, double> >
-    vect_of_tuples(3);
-
-  std::copy(
-    boost::make_zip_iterator(
-    ZI_MAKE_TUPLE(
-      vect1.begin(),
-      vect2.begin()
-      )
-    ),
-    boost::make_zip_iterator(
-    ZI_MAKE_TUPLE(
-      vect1.end(),
-      vect2.end()
-      )
-    ),
-    vect_of_tuples.begin()
-  );
-
-  if( 42. == ZI_TUPLE_GET(0)(*vect_of_tuples.begin()) &&
-      2.2 == ZI_TUPLE_GET(1)(*vect_of_tuples.begin()) &&
-      43. == ZI_TUPLE_GET(0)(*(vect_of_tuples.begin() + 1)) &&
-      3.3 == ZI_TUPLE_GET(1)(*(vect_of_tuples.begin() + 1)) &&
-      44. == ZI_TUPLE_GET(0)(*(vect_of_tuples.begin() + 2)) &&
-      4.4 == ZI_TUPLE_GET(1)(*(vect_of_tuples.begin() + 2))
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator non-const --> const conversion
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator non-const to const conversion:  "
-            << std::flush;
-
-  boost::zip_iterator<
-    ZI_TUPLE<
-      std::set<int>::const_iterator,
-      std::vector<double>::const_iterator
-      >
-    >
-  zip_it_const(
-    ZI_MAKE_TUPLE(
-      intset.begin(),
-      vect2.begin()
-    )
-  );
-  //
-  boost::zip_iterator<
-    ZI_TUPLE<
-      std::set<int>::iterator,
-      std::vector<double>::const_iterator
-      >
-    >
-  zip_it_half_const(
-    ZI_MAKE_TUPLE(
-      intset.begin(),
-      vect2.begin()
-    )
-  );
-  //
-  boost::zip_iterator<
-    ZI_TUPLE<
-      std::set<int>::iterator,
-      std::vector<double>::iterator
-      >
-    >
-  zip_it_non_const(
-    ZI_MAKE_TUPLE(
-      intset.begin(),
-      vect2.begin()
-    )
-  );
-
-  zip_it_half_const = ++zip_it_non_const;
-  zip_it_const = zip_it_half_const;
-  ++zip_it_const;
-//  zip_it_non_const = ++zip_it_const;  // Error: can't convert from const to non-const
-
-  if( 54 == ZI_TUPLE_GET(0)(*zip_it_const) &&
-      4.4 == ZI_TUPLE_GET(1)(*zip_it_const)  &&
-      53 == ZI_TUPLE_GET(0)(*zip_it_half_const)  &&
-      3.3 == ZI_TUPLE_GET(1)(*zip_it_half_const)
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-
-
-#if defined(ZI_USE_BOOST_TUPLE)
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator categories
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator categories:                     "
-            << std::flush;
-
-  // The big iterator of the previous test has vector, list, and set iterators.
-  // Therefore, it must be bidirectional, but not random access.
-  bool bBigItIsBidirectionalIterator = boost::is_convertible<
-    boost::iterator_traversal<zip_it_12_type>::type
-        , boost::bidirectional_traversal_tag
-        >::value;
-
-  bool bBigItIsRandomAccessIterator = boost::is_convertible<
-    boost::iterator_traversal<zip_it_12_type>::type
-        , boost::random_access_traversal_tag
-        >::value;
-
-  // A combining iterator with all vector iterators must have random access
-  // traversal.
-  //
-  typedef boost::zip_iterator<
-    ZI_TUPLE<
-      std::vector<double>::const_iterator,
-      std::vector<double>::const_iterator
-      >
-    > all_vects_type;
-
-  bool bAllVectsIsRandomAccessIterator = boost::is_convertible<
-    boost::iterator_traversal<all_vects_type>::type
-        , boost::random_access_traversal_tag
-    >::value;
-
-  // The big test.
-  if( bBigItIsBidirectionalIterator &&
-      ! bBigItIsRandomAccessIterator &&
-      bAllVectsIsRandomAccessIterator
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests;
-    std::cout << "not OK" << std::endl;
-  }
-  
-#endif
-
-  // Done
-  //
-  std::cout << "\nTest Result:"
-            << "\n============"
-            << "\nNumber of successful tests: " << static_cast<unsigned int>(num_successful_tests)
-            << "\nNumber of failed tests: " << static_cast<unsigned int>(num_failed_tests)
-            << std::endl;
-
-  return num_failed_tests;
-}
-

test/distance_test.cpp

@@ -1,84 +0,0 @@
-// Copyright (C) 2017 Michel Morin.
-//
-// 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)
-
-#include <vector>
-#include <list>
-#include <boost/container/slist.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/iterator/distance.hpp>
-#include <boost/iterator/transform_iterator.hpp>
-
-int twice(int x) { return x + x; }
-
-template <typename Iterator>
-void test_distance(Iterator it_from, Iterator it_to, int n)
-{
-    BOOST_TEST(boost::distance(it_from, it_to) == n);
-}
-
-int main()
-{
-    int array[3] = {1, 2, 3};
-    int* ptr1 = array;
-    int* ptr2 = array + 3;
-
-    {
-        test_distance(ptr1, ptr2,  3);
-        test_distance(ptr2, ptr1, -3);
-
-        test_distance(
-            boost::make_transform_iterator(ptr1, twice)
-          , boost::make_transform_iterator(ptr2, twice)
-          , 3
-        );
-        test_distance(
-            boost::make_transform_iterator(ptr2, twice)
-          , boost::make_transform_iterator(ptr1, twice)
-          , -3
-        );
-    }
-
-    {
-        std::vector<int> ints(ptr1, ptr2);
-        test_distance(ints.begin(), ints.end(),  3);
-        test_distance(ints.end(), ints.begin(), -3);
-
-        test_distance(
-            boost::make_transform_iterator(ints.begin(), twice)
-          , boost::make_transform_iterator(ints.end(), twice)
-          , 3
-        );
-        test_distance(
-            boost::make_transform_iterator(ints.end(), twice)
-          , boost::make_transform_iterator(ints.begin(), twice)
-          , -3
-        );
-    }
-
-    {
-        std::list<int> ints(ptr1, ptr2);
-        test_distance(ints.begin(), ints.end(),  3);
-
-        test_distance(
-            boost::make_transform_iterator(ints.begin(), twice)
-          , boost::make_transform_iterator(ints.end(), twice)
-          , 3
-        );
-    }
-
-    {
-        boost::container::slist<int> ints(ptr1, ptr2);
-        test_distance(ints.begin(), ints.end(),  3);
-
-        test_distance(
-            boost::make_transform_iterator(ints.begin(), twice)
-          , boost::make_transform_iterator(ints.end(), twice)
-          , 3
-        );
-    }
-
-    return boost::report_errors();
-}

test/function_input_iterator_test.cpp

@@ -1,119 +0,0 @@
-// Copyright 2010 (c) Dean Michael Berris
-// 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)
-
-#include <cassert>
-#include <cstddef>
-
-#include <algorithm>
-#include <iostream>
-#include <iterator>
-#include <vector>
-
-#include <boost/config.hpp>
-#include <boost/iterator/function_input_iterator.hpp>
-
-namespace {
-
-struct ones {
-    typedef int result_type;
-    result_type operator() () {
-        return 1;
-    }
-};
-
-int ones_function () {
-    return 1;
-}
-
-struct counter {
-    typedef int result_type;
-    int n;
-    explicit counter(int n_) : n(n_) { }
-    result_type operator() () {
-        return n++;
-    }
-};
-
-} // namespace
-
-using namespace std;
-
-int main(int argc, char * argv[])
-{
-    // test the iterator with function objects
-    ones ones_generator;
-    vector<int> values(10);
-    generate(values.begin(), values.end(), ones());
-    
-    vector<int> generated;
-    copy(
-        boost::make_function_input_iterator(ones_generator, 0),
-        boost::make_function_input_iterator(ones_generator, 10),
-        back_inserter(generated)
-        );
-
-    assert(values.size() == generated.size());
-    assert(equal(values.begin(), values.end(), generated.begin()));
-    cout << "function iterator test with function objects successful." << endl;
-
-    // test the iterator with normal functions
-    vector<int>().swap(generated);
-    copy(
-        boost::make_function_input_iterator(&ones_function, 0),
-        boost::make_function_input_iterator(&ones_function, 10),
-        back_inserter(generated)
-        );
-
-    assert(values.size() == generated.size());
-    assert(equal(values.begin(), values.end(), generated.begin()));
-    cout << "function iterator test with pointer to function successful." << endl;
-
-    // test the iterator with a reference to a function
-    vector<int>().swap(generated);
-    copy(
-        boost::make_function_input_iterator(ones_function, 0),
-        boost::make_function_input_iterator(ones_function, 10),
-        back_inserter(generated)
-        );
-
-    assert(values.size() == generated.size());
-    assert(equal(values.begin(), values.end(), generated.begin()));
-    cout << "function iterator test with reference to function successful." << endl;
-
-    // test the iterator with a stateful function object
-    counter counter_generator(42);
-    vector<int>().swap(generated);
-    copy(
-        boost::make_function_input_iterator(counter_generator, 0),
-        boost::make_function_input_iterator(counter_generator, 10),
-        back_inserter(generated)
-        );
-
-    assert(generated.size() == 10);
-    assert(counter_generator.n == 42 + 10);
-    for(std::size_t i = 0; i != 10; ++i)
-        assert(generated[i] == 42 + i);
-    cout << "function iterator test with stateful function object successful." << endl;
-
-#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
-    // test the iterator with lambda expressions
-    int num = 42;
-    auto lambda_generator = [&num] { return num++; };
-    vector<int>().swap(generated);
-    copy(
-        boost::make_function_input_iterator(lambda_generator, 0),
-        boost::make_function_input_iterator(lambda_generator, 10),
-        back_inserter(generated)
-        );
-
-    assert(generated.size() == 10);
-    for(std::size_t i = 0; i != 10; ++i)
-        assert(generated[i] == 42 + i);
-    cout << "function iterator test with lambda expressions successful." << endl;
-#endif // BOOST_NO_CXX11_LAMBDAS
-
-    return 0;
-}
-

test/generator_iterator_test.cpp

@@ -1,63 +0,0 @@
-//
-// Copyright 2014 Peter Dimov
-//
-// 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
-//
-
-#include <boost/generator_iterator.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <algorithm>
-
-class X
-{
-private:
-
-    int v;
-
-public:
-
-    typedef int result_type;
-
-    X(): v( 0 )
-    {
-    }
-
-    int operator()()
-    {
-        return ++v;
-    }
-};
-
-template<class InputIterator, class Size, class OutputIterator> OutputIterator copy_n( InputIterator first, Size n, OutputIterator result )
-{
-    while( n-- > 0 )
-    {
-        *result++ = *first++;
-    }
-
-    return result;
-}
-
-void copy_test()
-{
-    X x;
-    boost::generator_iterator<X> in( &x );
-
-    int const N = 4;
-    int v[ N ] = { 0 };
-
-    ::copy_n( in, 4, v );
-
-    BOOST_TEST_EQ( v[0], 1 );
-    BOOST_TEST_EQ( v[1], 2 );
-    BOOST_TEST_EQ( v[2], 3 );
-    BOOST_TEST_EQ( v[3], 4 );
-}
-
-int main()
-{
-    copy_test();
-    return boost::report_errors();
-}

test/indirect_iter_member_types.cpp

@@ -27,6 +27,8 @@ struct my_ptr {
 //  typedef boost::no_traversal_tag iterator_category;
 };
 
+BOOST_TT_BROKEN_COMPILER_SPEC(my_ptr)
+BOOST_TT_BROKEN_COMPILER_SPEC(zow)
 
 // Borland 5.6.4 and earlier drop const all over the place, so this
 // test will fail in the lines marked with (**)

test/indirect_iterator_test.cpp

@@ -27,6 +27,8 @@
 
 #include <boost/mpl/has_xxx.hpp>
 
+#include <boost/type_traits/broken_compiler_spec.hpp>
+
 #include <boost/detail/lightweight_test.hpp>
 
 #include <vector>
@@ -51,6 +53,7 @@ template <int I> struct see_val;
 struct my_iterator_tag : public std::random_access_iterator_tag { };
 
 using boost::dummyT;
+BOOST_TT_BROKEN_COMPILER_SPEC(boost::shared_ptr<dummyT>)
     
 typedef std::vector<int> storage;
 typedef std::vector<int*> pointer_ra_container;

test/is_lvalue_iterator.cpp

@@ -7,6 +7,7 @@
 #include <iostream>
 #include <boost/static_assert.hpp>
 #include <boost/noncopyable.hpp>
+#include <boost/type_traits/broken_compiler_spec.hpp>
 #include <boost/iterator/is_lvalue_iterator.hpp>
 #include <boost/iterator.hpp>
 
@@ -19,6 +20,7 @@ struct v
     ~v();
 };
 
+BOOST_TT_BROKEN_COMPILER_SPEC(v)
 
 struct value_iterator : boost::iterator<std::input_iterator_tag,v>
 {
@@ -81,6 +83,8 @@ struct constant_lvalue_iterator
     constant_lvalue_iterator operator++(int);
 };
 
+BOOST_TT_BROKEN_COMPILER_SPEC(proxy_iterator<v>::proxy)
+BOOST_TT_BROKEN_COMPILER_SPEC(proxy_iterator<int>::proxy)
 
 int main()
 {

test/is_readable_iterator.cpp

@@ -7,6 +7,7 @@
 #include <iostream>
 #include <boost/static_assert.hpp>
 #include <boost/noncopyable.hpp>
+#include <boost/type_traits/broken_compiler_spec.hpp>
 #include <boost/iterator/is_readable_iterator.hpp>
 #include <boost/iterator.hpp>
 
@@ -19,6 +20,7 @@ struct v
     ~v();
 };
 
+BOOST_TT_BROKEN_COMPILER_SPEC(v)
 
 struct value_iterator : boost::iterator<std::input_iterator_tag,v>
 {
@@ -69,6 +71,7 @@ struct proxy_iterator2 : boost::iterator<std::output_iterator_tag,v>
     proxy operator*() const;
 };
 
+BOOST_TT_BROKEN_COMPILER_SPEC(proxy_iterator::proxy)
 
 int main()
 {

test/iterator_adaptor_test.cpp

@@ -19,6 +19,8 @@
 #endif 
 #include <boost/pending/iterator_tests.hpp>
 
+# include <boost/type_traits/broken_compiler_spec.hpp>
+
 # include <boost/detail/lightweight_test.hpp>
 
 #include <stdlib.h>
@@ -33,6 +35,37 @@
 
 using boost::dummyT;
 
+struct mult_functor {
+  typedef int result_type;
+  typedef int argument_type;
+  // Functors used with transform_iterator must be
+  // DefaultConstructible, as the transform_iterator must be
+  // DefaultConstructible to satisfy the requirements for
+  // TrivialIterator.
+  mult_functor() { }
+  mult_functor(int aa) : a(aa) { }
+  int operator()(int b) const { return a * b; }
+  int a;
+};
+
+template <class Pair>
+struct select1st_ 
+  : public std::unary_function<Pair, typename Pair::first_type>
+{
+  const typename Pair::first_type& operator()(const Pair& x) const {
+    return x.first;
+  }
+  typename Pair::first_type& operator()(Pair& x) const {
+    return x.first;
+  }
+};
+
+struct one_or_four {
+  bool operator()(dummyT x) const {
+    return x.foo() == 1 || x.foo() == 4;
+  }
+};
+
 typedef std::deque<int> storage;
 typedef std::deque<int*> pointer_deque;
 typedef std::set<storage::iterator> iterator_set;

test/iterator_facade.cpp

@@ -7,11 +7,6 @@
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/new_iterator_tests.hpp>
 
-#include <boost/call_traits.hpp>
-#include <boost/polymorphic_cast.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/utility/enable_if.hpp>
-
 // This is a really, really limited test so far.  All we're doing
 // right now is checking that the postfix++ proxy for single-pass
 // iterators works properly.
@@ -50,14 +45,14 @@ class counter_iterator
 struct proxy
 {
     proxy(int& x) : state(x) {}
-
+        
     operator int const&() const
     {
         return state;
     }
 
     int& operator=(int x) { state = x; return state; }
-
+        
     int& state;
 };
 
@@ -92,136 +87,26 @@ struct input_iter
     }
 };
 
-template <class T>
-struct wrapper
-{
-    T m_x;
-    explicit wrapper(typename boost::call_traits<T>::param_type x)
-        : m_x(x)
-    { }
-    template <class U>
-    wrapper(const wrapper<U>& other,
-        typename boost::enable_if< boost::is_convertible<U,T> >::type* = 0)
-        : m_x(other.m_x)
-    { }
-};
-
-struct iterator_with_proxy_reference
-    : boost::iterator_facade<
-          iterator_with_proxy_reference
-        , wrapper<int>
-        , boost::incrementable_traversal_tag
-        , wrapper<int&>
-      >
-{
-    int& m_x;
-    explicit iterator_with_proxy_reference(int& x)
-        : m_x(x)
-    { }
-
-    void increment()
-    { }
-    wrapper<int&> dereference() const
-    { return wrapper<int&>(m_x); }
-};
-
 template <class T, class U>
 void same_type(U const&)
 { BOOST_MPL_ASSERT((boost::is_same<T,U>)); }
 
-template <class I, class A>
-struct abstract_iterator
-    : boost::iterator_facade<
-          abstract_iterator<I, A>
-        , A &
-        // In order to be value type as a reference, traversal category has
-        // to satisfy least forward traversal.
-        , boost::forward_traversal_tag
-        , A &
-      >
-{
-    abstract_iterator(I iter) : iter(iter) {}
-
-    void increment()
-    { ++iter; }
-
-    A & dereference() const
-    { return *iter; }
-
-    bool equal(abstract_iterator const& y) const
-    { return iter == y.iter; }
-
-    I iter;
-};
-
-struct base
-{
-    virtual void assign(const base &) = 0;
-    virtual bool equal(const base &) const = 0;
-};
-
-struct derived : base
-{
-    derived(int state) : state(state) { }
-    derived(const derived &d) : state(d.state) { }
-    derived(const base &b) { derived::assign(b); }
-
-    virtual void assign(const base &b)
-    {
-        state = boost::polymorphic_cast<const derived *>(&b)->state;
-    }
-
-    virtual bool equal(const base &b) const
-    {
-        return state == boost::polymorphic_cast<const derived *>(&b)->state;
-    }
-
-    int state;
-};
-
-inline bool operator==(const base &lhs, const base &rhs)
-{
-    return lhs.equal(rhs);
-}
-
 int main()
 {
-    {
+    int state = 0;
-        int state = 0;
+    boost::readable_iterator_test(counter_iterator<int const&>(&state), 0);
-        boost::readable_iterator_test(counter_iterator<int const&>(&state), 0);
+    state = 3;
-        state = 3;
+    boost::readable_iterator_test(counter_iterator<proxy>(&state), 3);
-        boost::readable_iterator_test(counter_iterator<proxy>(&state), 3);
+    boost::writable_iterator_test(counter_iterator<proxy>(&state), 9, 7);
-        boost::writable_iterator_test(counter_iterator<proxy>(&state), 9, 7);
+    BOOST_TEST(state == 8);
-        BOOST_TEST(state == 8);
-    }
 
-    {
+    // test for a fix to http://tinyurl.com/zuohe
-        // test for a fix to http://tinyurl.com/zuohe
+    // These two lines should be equivalent (and both compile)
-        // These two lines should be equivalent (and both compile)
+    input_iter p;
-        input_iter p;
+    (*p).mutator();
-        (*p).mutator();
+    p->mutator();
-        p->mutator();
-
-        same_type<input_iter::pointer>(p.operator->());
-    }
-
-    {
-        int x = 0;
-        iterator_with_proxy_reference i(x);
-        BOOST_TEST(x == 0);
-        BOOST_TEST(i.m_x == 0);
-        ++(*i).m_x;
-        BOOST_TEST(x == 1);
-        BOOST_TEST(i.m_x == 1);
-        ++i->m_x;
-        BOOST_TEST(x == 2);
-        BOOST_TEST(i.m_x == 2);
-    }
-
-    {
-        derived d(1);
-        boost::readable_iterator_test(abstract_iterator<derived *, base>(&d), derived(1));
-    }
 
+    same_type<input_iter::pointer>(p.operator->());
+    
     return boost::report_errors();
 }

test/minimum_category.cpp

@@ -1,22 +0,0 @@
-// Copyright Andrey Semashev 2014.
-//
-// Use, modification and distribution is subject to
-// the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/iterator/minimum_category.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <iterator>
-
-using boost::is_same;
-using boost::iterators::minimum_category;
-
-int main(int, char*[])
-{
-    BOOST_TEST_TRAIT_TRUE((is_same<minimum_category<std::forward_iterator_tag, std::random_access_iterator_tag>::type, std::forward_iterator_tag>));
-    BOOST_TEST_TRAIT_TRUE((is_same<minimum_category<std::random_access_iterator_tag, std::forward_iterator_tag>::type, std::forward_iterator_tag>));
-    BOOST_TEST_TRAIT_TRUE((is_same<minimum_category<std::random_access_iterator_tag, std::random_access_iterator_tag>::type, std::random_access_iterator_tag>));
-
-    return boost::report_errors();
-}

test/minimum_category_compile_fail.cpp

@@ -1,19 +0,0 @@
-// Copyright Andrey Semashev 2014.
-//
-// Use, modification and distribution is subject to
-// the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/iterator/minimum_category.hpp>
-
-using boost::iterators::minimum_category;
-
-struct A {};
-struct B {};
-
-int main(int, char*[])
-{
-    minimum_category<A, B>::type cat;
-
-    return 0;
-}

test/pointee.cpp

@@ -35,6 +35,7 @@ struct X {
     template <class T> operator T&() const;
 };
 
+BOOST_TT_BROKEN_COMPILER_SPEC(X)
     
 int main()
 {
@@ -56,24 +57,12 @@ int main()
     STATIC_ASSERT_SAME(boost::pointee<X*>::type, X);
     STATIC_ASSERT_SAME(boost::pointee<X const*>::type, X const);
 
-#if defined(BOOST_NO_CXX11_SMART_PTR)
-
     STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int> >::type, int);
     STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X> >::type, X);
     
     STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int const> >::type, int const);
     STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X const> >::type, X const);
 
-#else
-
-    STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<int> >::type, int);
-    STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<X> >::type, X);
-    
-    STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<int const> >::type, int const);
-    STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<X const> >::type, X const);
-
-#endif
-
     STATIC_ASSERT_SAME(boost::pointee<std::list<int>::iterator >::type, int);
     STATIC_ASSERT_SAME(boost::pointee<std::list<X>::iterator >::type, X);
     

test/transform_iterator_test.cpp

@@ -12,7 +12,6 @@
 //       Moved test of transform iterator into its own file. It to
 //       to be in iterator_adaptor_test.cpp.
 
-#include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <algorithm>
 #include <boost/iterator/transform_iterator.hpp>
@@ -107,17 +106,11 @@ struct polymorphic_mult_functor
 {
     //Implement result_of protocol
     template <class FArgs> struct result;
-    template <class F, class T> struct result<const F(T       )> {typedef T type;};
+    template <class F, class T> struct result<F(T)> {typedef T type;};
-    template <class F, class T> struct result<const F(T&      )> {typedef T type;};
-    template <class F, class T> struct result<const F(const T&)> {typedef T type;};
-    template <class F, class T> struct result<F(T       )> {typedef void type;};
-    template <class F, class T> struct result<F(T&      )> {typedef void type;};
-    template <class F, class T> struct result<F(const T&)> {typedef void type;};
 
     template <class T> 
-    T operator()(const T& _arg) const {return _arg*2;}
+    typename result<polymorphic_mult_functor(T)>::type
-    template <class T> 
+    operator()(const T& _arg) const {return _arg*2;}
-    void operator()(const T& _arg) { BOOST_ASSERT(0); }
 };
 
 int

test/unit_tests.cpp

@@ -7,10 +7,13 @@
 
 #include "static_assert_same.hpp"
 
-#include <boost/iterator/minimum_category.hpp>
+#include <boost/type_traits/broken_compiler_spec.hpp>
+
+#include <boost/iterator/detail/minimum_category.hpp>
 
 struct X { int a; };
 
+BOOST_TT_BROKEN_COMPILER_SPEC(X)
 
 struct Xiter : boost::iterator_adaptor<Xiter,X*>
 {
@@ -29,30 +32,30 @@ void operator_arrow_test()
 template <class T, class U, class Min>
 struct static_assert_min_cat
   : static_assert_same<
-       typename boost::iterators::minimum_category<T,U>::type, Min
+       typename boost::detail::minimum_category<T,U>::type, Min
     >
 {};
 
 void category_test()
 {
-    using namespace boost::iterators;
+    using namespace boost;
-    using namespace boost::iterators::detail;
+    using namespace boost::detail;
-
+    
     BOOST_STATIC_ASSERT((
         !boost::is_convertible<
             std::input_iterator_tag
           , input_output_iterator_tag>::value));
-
+    
     BOOST_STATIC_ASSERT((
         !boost::is_convertible<
             std::output_iterator_tag
           , input_output_iterator_tag>::value));
-
+    
     BOOST_STATIC_ASSERT((
         boost::is_convertible<
             input_output_iterator_tag
           , std::input_iterator_tag>::value));
-
+    
     BOOST_STATIC_ASSERT((
         boost::is_convertible<
             input_output_iterator_tag
@@ -64,7 +67,7 @@ void category_test()
         boost::is_convertible<
             std::forward_iterator_tag
           , input_output_iterator_tag>::value));
-#endif
+#endif 
 
     int test = static_assert_min_cat<
         std::input_iterator_tag,input_output_iterator_tag, std::input_iterator_tag
@@ -78,7 +81,7 @@ void category_test()
     test = static_assert_min_cat<
         input_output_iterator_tag,std::forward_iterator_tag, input_output_iterator_tag
     >::value;
-#endif
+#endif 
 
     test = static_assert_min_cat<
         std::input_iterator_tag,std::forward_iterator_tag, std::input_iterator_tag
@@ -93,8 +96,8 @@ void category_test()
     test = static_assert_min_cat<
         std::output_iterator_tag,std::random_access_iterator_tag, std::output_iterator_tag
     >::value;
-#endif
+#endif 
-
+    
     (void)test;
 }
 

test/zip_iterator_test.cpp

@@ -1,8 +1,857 @@
+// (C) Copyright Dave Abrahams and Thomas Becker 2003. 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)
+//
+
+// File: 
+// =====
+// zip_iterator_test_main.cpp
+
+// Author:
+// =======
+// Thomas Becker
+
+// Created:
+// ========
+// Jul 15, 2003
+
+// Purpose:
+// ========
+// Test driver for zip_iterator.hpp
+
+// Compilers Tested:
+// =================
+// Metrowerks Codewarrior Pro 7.2, 8.3
+// gcc 2.95.3
+// gcc 3.2
+// Microsoft VC 6sp5 (test fails due to some compiler bug)
+// Microsoft VC 7 (works)
+// Microsoft VC 7.1
+// Intel 5
+// Intel 6
+// Intel 7.1
+// Intel 8
+// Borland 5.5.1 (broken due to lack of support from Boost.Tuples)
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Includes
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#include <boost/iterator/zip_iterator.hpp>
+#include <boost/iterator/zip_iterator.hpp> // 2nd #include tests #include guard.
+#include <iostream>
+#include <vector>
+#include <list>
+#include <set>
+#include <string>
+#include <functional>
 #include <boost/tuple/tuple.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/iterator/is_readable_iterator.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/detail/workaround.hpp>
+#include <stddef.h>
 
-#define ZI_TUPLE      boost::tuples::tuple
+template <class It>
-#define ZI_MAKE_TUPLE boost::make_tuple
+struct pure_traversal
-#define ZI_TUPLE_GET(n) boost::tuples::get<n>
+  : boost::detail::pure_traversal_tag<
-#define ZI_USE_BOOST_TUPLE
+        typename boost::iterator_traversal<It>::type
+    >
+{};
+
+
+/// Tests for https://svn.boost.org/trac/boost/ticket/1517
+int to_value(int const &v)
+{
+    return v;
+}
+
+void category_test()
+{
+    std::list<int> rng1;
+    std::string rng2;
+
+    boost::make_zip_iterator(
+        boost::make_tuple(
+            boost::make_transform_iterator(rng1.begin(), &to_value), // BidirectionalInput
+            rng2.begin() // RandomAccess
+        )
+    );
+}
+///
+  
+/////////////////////////////////////////////////////////////////////////////
+//
+// Das Main Funktion
+//
+/////////////////////////////////////////////////////////////////////////////
+  
+int main( void )
+{
+
+  category_test();
+
+  std::cout << "\n"
+            << "***********************************************\n"
+            << "*                                             *\n"
+            << "* Test driver for boost::zip_iterator         *\n"
+            << "* Copyright Thomas Becker 2003                *\n"
+            << "*                                             *\n"
+            << "***********************************************\n\n"
+            << std::flush;
+
+  size_t num_successful_tests = 0;
+  size_t num_failed_tests = 0;
+  
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator construction and dereferencing
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator construction and dereferencing: "
+            << std::flush;
+  
+  std::vector<double> vect1(3);
+  vect1[0] = 42.;
+  vect1[1] = 43.;
+  vect1[2] = 44.;
+
+  std::set<int> intset;
+  intset.insert(52);
+  intset.insert(53);
+  intset.insert(54);
+  //
+
+  typedef
+  boost::zip_iterator<
+      boost::tuples::tuple<
+          std::set<int>::iterator
+        , std::vector<double>::iterator
+      >
+  > zit_mixed;
+
+  zit_mixed zip_it_mixed = zit_mixed(
+    boost::make_tuple(
+        intset.begin()
+      , vect1.begin()
+    )
+  );
+
+  boost::tuples::tuple<int, double> val_tuple( 
+      *zip_it_mixed);
+  
+  boost::tuples::tuple<const int&, double&> ref_tuple(
+      *zip_it_mixed);
+
+  double dblOldVal = boost::tuples::get<1>(ref_tuple);
+  boost::tuples::get<1>(ref_tuple) -= 41.;
+
+  if( 52 == boost::tuples::get<0>(val_tuple) &&
+      42. == boost::tuples::get<1>(val_tuple) &&
+      52 == boost::tuples::get<0>(ref_tuple)  &&
+      1. == boost::tuples::get<1>(ref_tuple)  &&
+      1. == *vect1.begin()
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  // Undo change to vect1
+  boost::tuples::get<1>(ref_tuple) = dblOldVal;
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator with 12 components
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterators with 12 components:            "
+            << std::flush;
+            
+  // Declare 12 containers
+  //
+  std::list<int> li1;
+  li1.push_back(1);
+  std::set<int> se1;
+  se1.insert(2);
+  std::vector<int> ve1;
+  ve1.push_back(3);
+  //
+  std::list<int> li2;
+  li2.push_back(4);
+  std::set<int> se2;
+  se2.insert(5);
+  std::vector<int> ve2;
+  ve2.push_back(6);
+  //
+  std::list<int> li3;
+  li3.push_back(7);
+  std::set<int> se3;
+  se3.insert(8);
+  std::vector<int> ve3;
+  ve3.push_back(9);
+  //
+  std::list<int> li4;
+  li4.push_back(10);
+  std::set<int> se4;
+  se4.insert(11);
+  std::vector<int> ve4;
+  ve4.push_back(12);
+
+  // typedefs for cons lists of iterators.
+  typedef boost::tuples::cons<
+    std::set<int>::iterator, 
+    boost::tuples::tuple<
+      std::vector<int>::iterator,
+      std::list<int>::iterator, 
+      std::set<int>::iterator, 
+      std::vector<int>::iterator,
+      std::list<int>::iterator, 
+      std::set<int>::iterator, 
+      std::vector<int>::iterator,
+      std::list<int>::iterator, 
+      std::set<int>::iterator, 
+      std::vector<int>::const_iterator
+      >::inherited
+    > cons_11_its_type;
+  //
+  typedef boost::tuples::cons<
+    std::list<int>::const_iterator, 
+    cons_11_its_type
+    > cons_12_its_type;
+
+  // typedefs for cons lists for dereferencing the zip iterator
+  // made from the cons list above.
+  typedef boost::tuples::cons<
+    const int&, 
+    boost::tuples::tuple<
+      int&,
+      int&,
+      const int&,
+      int&,
+      int&,
+      const int&,
+      int&,
+      int&,
+      const int&,
+      const int&
+      >::inherited
+    > cons_11_refs_type;
+  //
+  typedef boost::tuples::cons<
+    const int&, 
+    cons_11_refs_type
+    > cons_12_refs_type;
+
+  // typedef for zip iterator with 12 elements
+  typedef boost::zip_iterator<cons_12_its_type> zip_it_12_type;
+
+  // Declare a 12-element zip iterator.
+  zip_it_12_type zip_it_12(
+    cons_12_its_type(
+      li1.begin(), 
+      cons_11_its_type(
+        se1.begin(),
+        boost::make_tuple(
+          ve1.begin(),
+          li2.begin(), 
+          se2.begin(), 
+          ve2.begin(),
+          li3.begin(), 
+          se3.begin(), 
+          ve3.begin(),
+          li4.begin(), 
+          se4.begin(), 
+          ve4.begin()
+          )
+        )
+      )
+    );
+
+  // Dereference, mess with the result a little.
+  cons_12_refs_type zip_it_12_dereferenced(*zip_it_12);
+  boost::tuples::get<9>(zip_it_12_dereferenced) = 42;
+  
+  // Make a copy and move it a little to force some instantiations.
+  zip_it_12_type zip_it_12_copy(zip_it_12);
+  ++zip_it_12_copy;
+
+  if( boost::tuples::get<11>(zip_it_12.get_iterator_tuple()) == ve4.begin() &&
+      boost::tuples::get<11>(zip_it_12_copy.get_iterator_tuple()) == ve4.end() &&
+      1 == boost::tuples::get<0>(zip_it_12_dereferenced) &&
+      12 == boost::tuples::get<11>(zip_it_12_dereferenced) &&
+      42 == *(li4.begin())
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator incrementing and dereferencing
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator ++ and *:                       "
+            << std::flush;
+
+  std::vector<double> vect2(3);
+  vect2[0] = 2.2;
+  vect2[1] = 3.3;
+  vect2[2] = 4.4;
+  
+  boost::zip_iterator<
+    boost::tuples::tuple<
+      std::vector<double>::const_iterator, 
+      std::vector<double>::const_iterator
+      > 
+    >
+  zip_it_begin(
+    boost::make_tuple(
+     vect1.begin(),
+     vect2.begin()
+     )
+  );
+
+  boost::zip_iterator<
+    boost::tuples::tuple<
+      std::vector<double>::const_iterator, 
+      std::vector<double>::const_iterator
+      > 
+    >
+  zip_it_run(
+    boost::make_tuple(
+     vect1.begin(),
+     vect2.begin()
+     )
+  );
+
+  boost::zip_iterator<
+    boost::tuples::tuple<
+      std::vector<double>::const_iterator, 
+      std::vector<double>::const_iterator
+      > 
+    >
+  zip_it_end(
+    boost::make_tuple(
+     vect1.end(),
+     vect2.end()
+     )
+  );
+
+  if( zip_it_run == zip_it_begin &&
+      42. == boost::tuples::get<0>(*zip_it_run) &&
+      2.2 == boost::tuples::get<1>(*zip_it_run) &&
+      43. == boost::tuples::get<0>(*(++zip_it_run)) &&
+      3.3 == boost::tuples::get<1>(*zip_it_run) &&
+      44. == boost::tuples::get<0>(*(++zip_it_run)) &&
+      4.4 == boost::tuples::get<1>(*zip_it_run) &&
+      zip_it_end == ++zip_it_run
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator decrementing and dereferencing
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator -- and *:                       "
+            << std::flush;
+
+  if( zip_it_run == zip_it_end &&
+      zip_it_end == zip_it_run-- &&
+      44. == boost::tuples::get<0>(*zip_it_run) &&
+      4.4 == boost::tuples::get<1>(*zip_it_run) &&
+      43. == boost::tuples::get<0>(*(--zip_it_run)) &&
+      3.3 == boost::tuples::get<1>(*zip_it_run) &&
+      42. == boost::tuples::get<0>(*(--zip_it_run)) &&
+      2.2 == boost::tuples::get<1>(*zip_it_run) &&
+      zip_it_begin == zip_it_run
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator copy construction and equality
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator copy construction and equality: " 
+            << std::flush;
+
+  boost::zip_iterator<
+    boost::tuples::tuple<
+      std::vector<double>::const_iterator, 
+      std::vector<double>::const_iterator
+      >
+    > zip_it_run_copy(zip_it_run);
+
+  if(zip_it_run == zip_it_run && zip_it_run == zip_it_run_copy)
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator inequality
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator inequality:                     "
+            << std::flush;
+  
+  if(!(zip_it_run != zip_it_run_copy) && zip_it_run != ++zip_it_run_copy)
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator less than
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator less than:                      "
+            << std::flush;
+  
+  // Note: zip_it_run_copy == zip_it_run + 1
+  //
+  if( zip_it_run < zip_it_run_copy  &&
+      !( zip_it_run < --zip_it_run_copy) && 
+      zip_it_run == zip_it_run_copy
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator less than or equal
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "zip iterator less than or equal:             "
+            << std::flush;
+  
+  // Note: zip_it_run_copy == zip_it_run
+  //
+  ++zip_it_run;
+  zip_it_run_copy += 2;
+
+  if( zip_it_run <= zip_it_run_copy && 
+      zip_it_run <= --zip_it_run_copy && 
+      !( zip_it_run <= --zip_it_run_copy) && 
+      zip_it_run <= zip_it_run
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator greater than
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator greater than:                   "
+            << std::flush;
+  
+  // Note: zip_it_run_copy == zip_it_run - 1
+  //
+  if( zip_it_run > zip_it_run_copy && 
+      !( zip_it_run > ++zip_it_run_copy) && 
+      zip_it_run == zip_it_run_copy
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator greater than or equal
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator greater than or equal:          "
+            << std::flush;
+
+  ++zip_it_run;
+  
+  // Note: zip_it_run == zip_it_run_copy + 1
+  //
+  if( zip_it_run >= zip_it_run_copy && 
+      --zip_it_run >= zip_it_run_copy && 
+      ! (zip_it_run >= ++zip_it_run_copy) 
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator + int
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator + int:                          "
+            << std::flush;
+
+  // Note: zip_it_run == zip_it_run_copy - 1
+  //
+  zip_it_run = zip_it_run + 2;
+  ++zip_it_run_copy;
+
+  if( zip_it_run == zip_it_run_copy && zip_it_run == zip_it_begin + 3 )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator - int
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator - int:                          "
+            << std::flush;
+  
+  // Note: zip_it_run == zip_it_run_copy, and both are at end position
+  // 
+  zip_it_run = zip_it_run - 2;
+  --zip_it_run_copy;
+  --zip_it_run_copy;
+  
+  if( zip_it_run == zip_it_run_copy && (zip_it_run - 1) == zip_it_begin )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator +=
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator +=:                             "
+            << std::flush;
+            
+  // Note: zip_it_run == zip_it_run_copy, and both are at begin + 1
+  // 
+  zip_it_run += 2;
+  if( zip_it_run == zip_it_begin + 3 )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator -=
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator -=:                             "
+            << std::flush;
+
+  // Note: zip_it_run is at end position, zip_it_run_copy is at
+  // begin plus one.
+  // 
+  zip_it_run -= 2;
+  if( zip_it_run == zip_it_run_copy )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator getting member iterators
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator member iterators:               "
+            << std::flush;
+            
+  // Note: zip_it_run and zip_it_run_copy are both at
+  // begin plus one.
+  // 
+  if( boost::tuples::get<0>(zip_it_run.get_iterator_tuple()) == vect1.begin() + 1 &&
+      boost::tuples::get<1>(zip_it_run.get_iterator_tuple()) == vect2.begin() + 1
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Making zip iterators
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Making zip iterators:                        "
+            << std::flush;
+
+  std::vector<boost::tuples::tuple<double, double> >
+    vect_of_tuples(3);
+
+  std::copy(
+    boost::make_zip_iterator(
+    boost::make_tuple(
+      vect1.begin(), 
+      vect2.begin()
+      )
+    ),
+    boost::make_zip_iterator(
+    boost::make_tuple(
+      vect1.end(), 
+      vect2.end()
+      )
+    ),
+    vect_of_tuples.begin()
+  );
+
+  if( 42. == boost::tuples::get<0>(*vect_of_tuples.begin()) &&
+      2.2 == boost::tuples::get<1>(*vect_of_tuples.begin()) &&
+      43. == boost::tuples::get<0>(*(vect_of_tuples.begin() + 1)) &&
+      3.3 == boost::tuples::get<1>(*(vect_of_tuples.begin() + 1)) &&
+      44. == boost::tuples::get<0>(*(vect_of_tuples.begin() + 2)) &&
+      4.4 == boost::tuples::get<1>(*(vect_of_tuples.begin() + 2))
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator non-const --> const conversion
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  std::cout << "Zip iterator non-const to const conversion:  "
+            << std::flush;
+  
+  boost::zip_iterator<
+    boost::tuples::tuple<
+      std::set<int>::const_iterator,
+      std::vector<double>::const_iterator
+      >
+    > 
+  zip_it_const(
+    boost::make_tuple(
+      intset.begin(), 
+      vect2.begin()
+    )
+  );
+  //
+  boost::zip_iterator<
+    boost::tuples::tuple<
+      std::set<int>::iterator,
+      std::vector<double>::const_iterator
+      >
+    > 
+  zip_it_half_const(
+    boost::make_tuple(
+      intset.begin(), 
+      vect2.begin()
+    )
+  );
+  //
+  boost::zip_iterator<
+    boost::tuples::tuple<
+      std::set<int>::iterator,
+      std::vector<double>::iterator
+      >
+    > 
+  zip_it_non_const(
+    boost::make_tuple(
+      intset.begin(), 
+      vect2.begin()
+    )
+  );
+
+  zip_it_half_const = ++zip_it_non_const;
+  zip_it_const = zip_it_half_const;
+  ++zip_it_const;
+//  zip_it_non_const = ++zip_it_const;  // Error: can't convert from const to non-const
+  
+  if( 54 == boost::tuples::get<0>(*zip_it_const) &&
+      4.4 == boost::tuples::get<1>(*zip_it_const)  &&
+      53 == boost::tuples::get<0>(*zip_it_half_const)  &&
+      3.3 == boost::tuples::get<1>(*zip_it_half_const)
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator categories
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator categories:                     "
+            << std::flush;
+            
+  // The big iterator of the previous test has vector, list, and set iterators.
+  // Therefore, it must be bidirectional, but not random access.
+  bool bBigItIsBidirectionalIterator = boost::is_convertible<
+    boost::iterator_traversal<zip_it_12_type>::type
+        , boost::bidirectional_traversal_tag
+        >::value;
+
+  bool bBigItIsRandomAccessIterator = boost::is_convertible<
+    boost::iterator_traversal<zip_it_12_type>::type
+        , boost::random_access_traversal_tag
+        >::value;
+
+  // A combining iterator with all vector iterators must have random access
+  // traversal.
+  //
+  typedef boost::zip_iterator<
+    boost::tuples::tuple<
+      std::vector<double>::const_iterator, 
+      std::vector<double>::const_iterator
+      >
+    > all_vects_type;
+  
+  bool bAllVectsIsRandomAccessIterator = boost::is_convertible<
+    boost::iterator_traversal<all_vects_type>::type
+        , boost::random_access_traversal_tag
+    >::value;
+
+  // The big test.
+  if( bBigItIsBidirectionalIterator &&
+      ! bBigItIsRandomAccessIterator &&
+      bAllVectsIsRandomAccessIterator
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests = 0;
+    std::cout << "not OK" << std::endl;
+  }
+
+  // Done
+  //
+  std::cout << "\nTest Result:"
+            << "\n============"
+            << "\nNumber of successful tests: " << static_cast<unsigned int>(num_successful_tests)
+            << "\nNumber of failed tests: " << static_cast<unsigned int>(num_failed_tests)
+            << std::endl;
+
+  return num_failed_tests;
+}
 
-#include "detail/zip_iterator_test_original.ipp"

test/zip_iterator_test2_fusion_deque.cpp

@@ -1,9 +0,0 @@
-#include <boost/fusion/include/deque.hpp>
-#include <boost/fusion/include/make_deque.hpp>
-#include <boost/fusion/sequence/intrinsic/at_c.hpp>
-
-#define ZI_TUPLE      boost::fusion::deque
-#define ZI_MAKE_TUPLE boost::fusion::make_deque
-#define ZI_TUPLE_GET(n) boost::fusion::at_c<n>
-
-#include "detail/zip_iterator_test_original.ipp"

test/zip_iterator_test2_fusion_list.cpp

@@ -1,11 +0,0 @@
-#include <boost/config.hpp>
-
-#include <boost/fusion/include/list.hpp>
-#include <boost/fusion/include/make_list.hpp>
-#include <boost/fusion/sequence/intrinsic/at_c.hpp>
-
-#define ZI_TUPLE      boost::fusion::list
-#define ZI_MAKE_TUPLE boost::fusion::make_list
-#define ZI_TUPLE_GET(n) boost::fusion::at_c<n>
-
-#include "detail/zip_iterator_test_original.ipp"

test/zip_iterator_test2_fusion_vector.cpp

@@ -1,11 +0,0 @@
-#include <boost/config.hpp>
-
-#include <boost/fusion/include/vector.hpp>
-#include <boost/fusion/include/make_vector.hpp>
-#include <boost/fusion/sequence/intrinsic/at_c.hpp>
-
-#define ZI_TUPLE      boost::fusion::vector
-#define ZI_MAKE_TUPLE boost::fusion::make_vector
-#define ZI_TUPLE_GET(n) boost::fusion::at_c<n>
-
-#include "detail/zip_iterator_test_original.ipp"

test/zip_iterator_test2_std_tuple.cpp

@@ -1,21 +0,0 @@
-#include <boost/config.hpp>
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#include <tuple>
-#include <boost/fusion/adapted/std_tuple.hpp>
-
-#define ZI_TUPLE      std::tuple
-#define ZI_MAKE_TUPLE std::make_tuple
-#define ZI_TUPLE_GET(n) std::get<n>
-
-#include "detail/zip_iterator_test_original.ipp"
-
-#else
-
-int main()
- {
- return 0;
- }
-
-#endif

test/zip_iterator_test_fusion.cpp

@@ -1,15 +0,0 @@
-// Copyright (c) 2014 Kohei Takahashi.
-//
-// 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)
-//
-//  See http://www.boost.org for most recent version including documentation.
-
-#include <boost/fusion/include/vector.hpp>
-#include <boost/fusion/include/make_vector.hpp>
-
-#define TUPLE      boost::fusion::vector
-#define MAKE_TUPLE boost::fusion::make_vector
-
-#include "detail/zip_iterator_test.ipp"

test/zip_iterator_test_std_pair.cpp

@@ -1,16 +0,0 @@
-// Copyright (c) 2014 Kohei Takahashi.
-//
-// 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)
-//
-//  See http://www.boost.org for most recent version including documentation.
-
-#include <utility>
-#include <boost/fusion/adapted/std_pair.hpp>
-
-#define TUPLE      std::pair
-#define MAKE_TUPLE std::make_pair
-
-#include "detail/zip_iterator_test.ipp"
-

test/zip_iterator_test_std_tuple.cpp

@@ -1,29 +0,0 @@
-// Copyright (c) 2014 Kohei Takahashi.
-//
-// 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)
-//
-//  See http://www.boost.org for most recent version including documentation.
-
-#include <boost/config.hpp>
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#include <tuple>
-#include <boost/fusion/adapted/std_tuple.hpp>
-
-#define TUPLE      std::tuple
-#define MAKE_TUPLE std::make_tuple
-
-#include "detail/zip_iterator_test.ipp"
-
-#else
-
-int main()
-{
-    return 0;
-}
-
-#endif
-