Branch for development of boost.system related changes

[SVN r40931]
2025-06-26 04:21:36 +02:00 · 2007-11-08 14:20:16 +00:00
95 changed files with 85 additions and 482 deletions
--- a/doc/.cvsignore
+++ b/doc/.cvsignore
@ -0,0 +1 @@
 GNUmakefile
--- a/doc/BidirectionalTraversal.rst
+++ b/doc/BidirectionalTraversal.rst
--- a/doc/ForwardTraversal.rst
+++ b/doc/ForwardTraversal.rst
--- a/doc/GNUmakefile
+++ b/doc/GNUmakefile
--- a/doc/IncrementableIterator.rst
+++ b/doc/IncrementableIterator.rst
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -16,7 +16,5 @@ boostbook standalone
    <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
  ;
--- a/doc/LvalueIterator.rst
+++ b/doc/LvalueIterator.rst
--- a/doc/ReadableIterator.rst
+++ b/doc/ReadableIterator.rst
--- a/doc/SinglePassIterator.rst
+++ b/doc/SinglePassIterator.rst
--- a/doc/SwappableIterator.rst
+++ b/doc/SwappableIterator.rst
--- a/doc/WritableIterator.rst
+++ b/doc/WritableIterator.rst
--- a/doc/counting_iterator.pdf
+++ b/doc/counting_iterator.pdf
--- a/doc/docutils.sty
+++ b/doc/docutils.sty
--- a/doc/facade-and-adaptor.html
+++ b/doc/facade-and-adaptor.html
--- a/doc/facade-and-adaptor.pdf
+++ b/doc/facade-and-adaptor.pdf
--- a/doc/facade_iterator_category.rst
+++ b/doc/facade_iterator_category.rst
--- a/doc/filter_iterator.pdf
+++ b/doc/filter_iterator.pdf
--- a/doc/function_input_iterator.html
+++ b/doc/function_input_iterator.html
@ -1,142 +0,0 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <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.6: http://docutils.sourceforge.net/" />
 <title></title>
 <meta name="author" content="Dean Michael Berris" />
 <link rel="stylesheet" href="../../../rst.css" type="text/css" />
 </head>
 <body>
 <div class="document">
 <table class="docinfo" frame="void" rules="none">
 <col class="docinfo-name" />
 <col class="docinfo-content" />
 <tbody valign="top">
 <tr><th class="docinfo-name">Author:</th>
 <td><a class="first reference external" href="mailto:mikhailberis&#64;gmail.com">Dean Michael Berris</a></td></tr>
 <tr class="field"><th class="docinfo-name">License:</th><td class="field-body">Distributed under the Boost Software License, Version 1.0
 (See accompanying file LICENSE_1_0.txt or copy at <a class="reference external" href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</td>
 </tr>
 </tbody>
 </table>
 <div class="section" id="function-input-iterator">
 <h1>Function Input Iterator</h1>
 <p>The Function Input Iterator allows for creating iterators that encapsulate
 a nullary function object and a state object which tracks the number of times
 the iterator has been incremented. A Function Input Iterator models the
 <a class="reference external" href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a> concept and is useful for creating bounded input iterators.</p>
 <p>Like the Generator Iterator, the Function Input Iterator takes a function
 that models the <a class="reference external" href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> concept (which is basically a nullary or 0-arity
 function object). Each increment of the function Function Input Iterator
 invokes the generator function and stores the value in the iterator. When
 the iterator is dereferenced the stored value is returned.</p>
 <p>The Function Input Iterator encapsulates a state object which models the
 <a class="reference internal" href="#incrementable-concept">Incrementable Concept</a> and the <a class="reference external" href="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a> Concept. These concepts are
 described below as:</p>
 <div class="section" id="incrementable-concept">
 <h2>Incrementable Concept</h2>
 <p>A type models the Incrementable Concept when it supports the pre- and post-
 increment operators. For a given object <tt class="docutils literal"><span class="pre">i</span></tt> with type <tt class="docutils literal"><span class="pre">I</span></tt>, the following
 constructs should be valid:</p>
 <table border="1" class="docutils">
 <colgroup>
 <col width="24%" />
 <col width="46%" />
 <col width="30%" />
 </colgroup>
 <tbody valign="top">
 <tr><td colspan="3">Construct  Description        Return Type</td>
 </tr>
 <tr><td>i++</td>
 <td>Post-increment i.</td>
 <td>I</td>
 </tr>
 <tr><td>++i</td>
 <td>Pre-increment i.</td>
 <td>I&amp;</td>
 </tr>
 </tbody>
 </table>
 <p>NOTE: An Incrementable type should also be <a class="reference external" href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>.</p>
 </div>
 <div class="section" id="synopsis">
 <h2>Synopsis</h2>
 <pre class="literal-block">
 namespace {
    template &lt;class Function, class State&gt;
    class function_input_iterator;
    template &lt;class Function, class State&gt;
    typename function_input_iterator&lt;Function, State&gt;
    make_function_input_iterator(Function &amp; f);
    struct infinite;
 }
 </pre>
 </div>
 <div class="section" id="function-input-iterator-class">
 <h2>Function Input Iterator Class</h2>
 <p>The class Function Input Iterator class takes two template parameters
 <tt class="docutils literal"><span class="pre">Function</span></tt> and <tt class="docutils literal"><span class="pre">State</span></tt>. These two template parameters tell the
 Function Input Iterator the type of the function to encapsulate and
 the type of the internal state value to hold.</p>
 <p>The <tt class="docutils literal"><span class="pre">State</span></tt> parameter is important in cases where you want to
 control the type of the counter which determines whether two iterators
 are at the same state. This allows for creating a pair of iterators which
 bound the range of the invocations of the encapsulated functions.</p>
 </div>
 <div class="section" id="examples">
 <h2>Examples</h2>
 <p>The following example shows how we use the function input iterator class
 in cases where we want to create bounded (lazy) generated ranges.</p>
 <pre class="literal-block">
 struct generator {
    typedef int result_type;
    generator() { srand(time(0)); }
    result_type operator() () const {
        return rand();
    }
 };
 int main(int argc, char * argv[]) {
    generator f;
    copy(
            make_function_input_iterator(f, 0),
            make_function_input_iterator(f, 10),
            ostream_iterator&lt;int&gt;(cout, &quot; &quot;)
        );
    return 0;
 }
 </pre>
 <p>Here we can see that we've bounded the number of invocations using an <tt class="docutils literal"><span class="pre">int</span></tt>
 that counts from <tt class="docutils literal"><span class="pre">0</span></tt> to <tt class="docutils literal"><span class="pre">10</span></tt>. Say we want to create an endless stream
 of random numbers and encapsulate that in a pair of integers, we can do
 it with the <tt class="docutils literal"><span class="pre">boost::infinite</span></tt> helper class.</p>
 <pre class="literal-block">
 copy(
        make_function_input_iterator(f,infinite()),
        make_function_input_iterator(f,infinite()),
        ostream_iterator&lt;int&gt;(count, &quot; &quot;)
    );
 </pre>
 <p>Above, instead of creating a huge vector we rely on the STL copy algorithm
 to traverse the function input iterator and call the function object f
 as it increments the iterator. The special property of <tt class="docutils literal"><span class="pre">boost::infinite</span></tt>
 is that equating two instances always yield false -- and that incrementing
 an instance of <tt class="docutils literal"><span class="pre">boost::infinite</span></tt> doesn't do anything. This is an efficient
 way of stating that the iterator range provided by two iterators with an
 encapsulated infinite state will definitely be infinite.</p>
 </div>
 </div>
 </div>
 <div class="footer">
 <hr class="footer" />
 <a class="reference external" href="function_input_iterator.rst">View document source</a>.
 Generated by <a class="reference external" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference external" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
 </div>
 </body>
 </html>
--- a/doc/function_input_iterator.rst
+++ b/doc/function_input_iterator.rst
@ -1,126 +0,0 @@
 :Author:
    `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)
 Function Input Iterator
 =======================
 The Function Input Iterator allows for creating iterators that encapsulate
 a nullary function object and a state object which tracks the number of times
 the iterator has been incremented. A Function Input Iterator models the
 `InputIterator`_ concept and is useful for creating bounded input iterators.
 .. _InputIterator: http://www.sgi.com/tech/stl/InputIterator.html
 Like the Generator Iterator, the Function Input Iterator takes a function
 that models the Generator_ concept (which is basically a nullary or 0-arity
 function object). Each increment of the function Function Input Iterator
 invokes the generator function and stores the value in the iterator. When
 the iterator is dereferenced the stored value is returned.
 .. _Generator: http://www.sgi.com/tech/stl/Generator.html
 The Function Input Iterator encapsulates a state object which models the
 `Incrementable Concept`_ and the EqualityComparable_ Concept. These concepts are
 described below as:
 .. _EqualityComparable: http://www.sgi.com/tech/stl/EqualityComparable.html
 Incrementable Concept
 ---------------------
 A type models the Incrementable Concept when it supports the pre- and post-
 increment operators. For a given object ``i`` with type ``I``, the following 
 constructs should be valid:
 =========  =================  ===========
 Construct  Description        Return Type
 -----------------------------------------
 i++        Post-increment i.  I
 ++i        Pre-increment i.   I&
 =========  =================  ===========
 NOTE: An Incrementable type should also be DefaultConstructible_.
 .. _DefaultConstructible: http://www.sgi.com/tech/stl/DefaultConstructible.html
 Synopsis
 --------
 ::
    namespace {
        template <class Function, class State>
        class function_input_iterator;
        template <class Function, class State>
        typename function_input_iterator<Function, State>
        make_function_input_iterator(Function & f);
        struct infinite;
    }
 Function Input Iterator Class
 -----------------------------
 The class Function Input Iterator class takes two template parameters
 ``Function`` and ``State``. These two template parameters tell the
 Function Input Iterator the type of the function to encapsulate and
 the type of the internal state value to hold.
 The ``State`` parameter is important in cases where you want to
 control the type of the counter which determines whether two iterators 
 are at the same state. This allows for creating a pair of iterators which 
 bound the range of the invocations of the encapsulated functions.
 Examples
 --------
 The following example shows how we use the function input iterator class
 in cases where we want to create bounded (lazy) generated ranges.
 ::
    struct generator {
        typedef int result_type;
        generator() { srand(time(0)); }
        result_type operator() () const {
            return rand();
        }
    };
    int main(int argc, char * argv[]) {
        generator f;
        copy(
                make_function_input_iterator(f, 0),
                make_function_input_iterator(f, 10),
                ostream_iterator<int>(cout, " ")
            );
        return 0;
    }
 Here we can see that we've bounded the number of invocations using an ``int``
 that counts from ``0`` to ``10``. Say we want to create an endless stream
 of random numbers and encapsulate that in a pair of integers, we can do
 it with the ``boost::infinite`` helper class.
 ::
    copy(
            make_function_input_iterator(f,infinite()),
            make_function_input_iterator(f,infinite()),
            ostream_iterator<int>(count, " ")
        );
 Above, instead of creating a huge vector we rely on the STL copy algorithm
 to traverse the function input iterator and call the function object f
 as it increments the iterator. The special property of ``boost::infinite``
 is that equating two instances always yield false -- and that incrementing
 an instance of ``boost::infinite`` doesn't do anything. This is an efficient
 way of stating that the iterator range provided by two iterators with an
 encapsulated infinite state will definitely be infinite.
--- a/doc/function_output_iterator.pdf
+++ b/doc/function_output_iterator.pdf
--- a/doc/index.html
+++ b/doc/index.html
@ -3,7 +3,7 @@
 <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.6: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.5: http://docutils.sourceforge.net/" />
 <title>The Boost.Iterator Library Boost</title>
 <link rel="stylesheet" href="../../../rst.css" type="text/css" />
 </head>
@ -11,6 +11,9 @@
 <div class="document" id="the-boost-iterator-library-logo">
 <h1 class="title">The Boost.Iterator Library <a class="reference external" href="../../../index.htm"><img alt="Boost" src="../../../boost.png" /></a></h1>
 <!-- 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) -->
 <!-- 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) -->
@ -37,7 +40,7 @@ Lab</a>, <a class="reference external" href="http://www.styleadvisor.com">Zephyr
 <col class="field-body" />
 <tbody valign="top">
 <tr class="field"><th class="field-name">Abstract:</th><td class="field-body">The Boost Iterator Library contains two parts. The first
-is a system of <a class="reference external" href="http://www.boost.org/more/generic_programming.html#concept">concepts</a> which extend the C++ standard
+is a system of <a class="reference external" href="../../../more/generic_programming.html#concept">concepts</a> 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
@ -57,21 +60,21 @@ older Boost Iterator Adaptor Library.</td>
 <div class="contents topic" id="table-of-contents">
 <p class="topic-title first"><strong>Table of Contents</strong></p>
 <ul class="simple">
-<li><a class="reference internal" href="#new-style-iterators" id="id23">New-Style Iterators</a></li>
+<li><a class="reference internal" href="#new-style-iterators" id="id22">New-Style Iterators</a></li>
-<li><a class="reference internal" href="#iterator-facade-and-adaptor" id="id24">Iterator Facade and Adaptor</a></li>
+<li><a class="reference internal" href="#iterator-facade-and-adaptor" id="id23">Iterator Facade and Adaptor</a></li>
-<li><a class="reference internal" href="#specialized-adaptors" id="id25">Specialized Adaptors</a></li>
+<li><a class="reference internal" href="#specialized-adaptors" id="id24">Specialized Adaptors</a></li>
-<li><a class="reference internal" href="#iterator-utilities" id="id26">Iterator Utilities</a><ul>
+<li><a class="reference internal" href="#iterator-utilities" id="id25">Iterator Utilities</a><ul>
-<li><a class="reference internal" href="#traits" id="id27">Traits</a></li>
+<li><a class="reference internal" href="#traits" id="id26">Traits</a></li>
-<li><a class="reference internal" href="#testing-and-concept-checking" id="id28">Testing and Concept Checking</a></li>
+<li><a class="reference internal" href="#testing-and-concept-checking" id="id27">Testing and Concept Checking</a></li>
 </ul>
 </li>
-<li><a class="reference internal" href="#upgrading-from-the-old-boost-iterator-adaptor-library" id="id29">Upgrading from the old Boost Iterator Adaptor Library</a></li>
+<li><a class="reference internal" href="#upgrading-from-the-old-boost-iterator-adaptor-library" id="id28">Upgrading from the old Boost Iterator Adaptor Library</a></li>
-<li><a class="reference internal" href="#history" id="id30">History</a></li>
+<li><a class="reference internal" href="#history" id="id29">History</a></li>
 </ul>
 </div>
 <hr class="docutils" />
 <div class="section" id="new-style-iterators">
-<h1><a class="toc-backref" href="#id23">New-Style Iterators</a></h1>
+<h1><a class="toc-backref" href="#id22">New-Style Iterators</a></h1>
 <p>The iterator categories defined in C++98 are extremely limiting
 because they bind together two orthogonal concepts: traversal and
 element access.  For example, because a random access iterator is
@ -90,7 +93,7 @@ concepts, see our</p>
 <a class="reference external" href="new-iter-concepts.html">Standard Proposal For New-Style Iterators</a> (<a class="reference external" href="new-iter-concepts.pdf">PDF</a>)</blockquote>
 </div>
 <div class="section" id="iterator-facade-and-adaptor">
-<h1><a class="toc-backref" href="#id24">Iterator Facade and Adaptor</a></h1>
+<h1><a class="toc-backref" href="#id23">Iterator Facade and Adaptor</a></h1>
 <p>Writing standard-conforming iterators is tricky, but the need comes
 up often.  In order to ease the implementation of new iterators,
 the Boost.Iterator library provides the <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> class template,
@ -117,7 +120,7 @@ and accepted into the first C++ technical report; see our</p>
 <p>for more details.</p>
 </div>
 <div class="section" id="specialized-adaptors">
-<h1><a class="toc-backref" href="#id25">Specialized Adaptors</a></h1>
+<h1><a class="toc-backref" href="#id24">Specialized Adaptors</a></h1>
 <p>The iterator library supplies a useful suite of standard-conforming
 iterator templates based on the Boost <a class="reference internal" href="#iterator-facade-and-adaptor">iterator facade and adaptor</a>.</p>
 <ul class="simple">
@ -125,9 +128,6 @@ iterator templates based on the Boost <a class="reference internal" href="#itera
 Implements a &quot;lazy sequence&quot;</li>
 <li><a class="reference external" href="filter_iterator.html"><tt class="docutils literal"><span class="pre">filter_iterator</span></tt></a> (<a class="reference external" href="filter_iterator.pdf">PDF</a>): an iterator over the subset of elements of some
 sequence which satisfy a given predicate</li>
 <li><a class="reference external" href="function_input_iterator.html"><tt class="docutils literal"><span class="pre">function_input_iterator</span></tt></a> (<a class="reference external" href="function_input_iterator.pdf">PDF</a>): an input iterator wrapping a generator (nullary
 function object); each time the iterator is dereferenced, the function object
 is called to get the value to return.</li>
 <li><a class="reference external" href="function_output_iterator.html"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt></a> (<a class="reference external" href="function_output_iterator.pdf">PDF</a>): an output iterator wrapping a unary function
 object; each time an element is written into the dereferenced
 iterator, it is passed as a parameter to the function object.</li>
@ -149,9 +149,9 @@ positions of heterogeneous underlying iterators.</li>
 </ul>
 </div>
 <div class="section" id="iterator-utilities">
-<h1><a class="toc-backref" href="#id26">Iterator Utilities</a></h1>
+<h1><a class="toc-backref" href="#id25">Iterator Utilities</a></h1>
 <div class="section" id="traits">
-<h2><a class="toc-backref" href="#id27">Traits</a></h2>
+<h2><a class="toc-backref" href="#id26">Traits</a></h2>
 <ul class="simple">
 <li><a class="reference external" href="pointee.html"><tt class="docutils literal"><span class="pre">pointee.hpp</span></tt></a> (<a class="reference external" href="pointee.pdf">PDF</a>): Provides the capability to deduce the referent types
 of pointers, smart pointers and iterators in generic code.  Used
@ -165,7 +165,7 @@ testing iterator interoperability -->
 <!-- comment! __ interoperable.pdf -->
 </div>
 <div class="section" id="testing-and-concept-checking">
-<h2><a class="toc-backref" href="#id28">Testing and Concept Checking</a></h2>
+<h2><a class="toc-backref" href="#id27">Testing and Concept Checking</a></h2>
 <ul class="simple">
 <li><a class="reference external" href="iterator_concepts.html"><tt class="docutils literal"><span class="pre">iterator_concepts.hpp</span></tt></a> (<a class="reference external" href="iterator_concepts.pdf">PDF</a>): Concept checking classes for the new iterator concepts.</li>
 <li><a class="reference external" href="iterator_archetypes.html"><tt class="docutils literal"><span class="pre">iterator_archetypes.hpp</span></tt></a> (<a class="reference external" href="iterator_archetypes.pdf">PDF</a>): Concept archetype classes for the new iterators concepts.</li>
@ -173,17 +173,17 @@ testing iterator interoperability -->
 </div>
 </div>
 <div class="section" id="upgrading-from-the-old-boost-iterator-adaptor-library">
-<h1><a class="toc-backref" href="#id29">Upgrading from the old Boost Iterator Adaptor Library</a></h1>
+<h1><a class="toc-backref" href="#id28">Upgrading from the old Boost Iterator Adaptor Library</a></h1>
 <p id="upgrading">If you have been using the old Boost Iterator Adaptor library to
 implement iterators, you probably wrote a <tt class="docutils literal"><span class="pre">Policies</span></tt> class which
 captures the core operations of your iterator.  In the new library
 design, you'll move those same core operations into the body of the
 iterator class itself.  If you were writing a family of iterators,
-you probably wrote a <a class="reference external" href="http://www.boost.org/more/generic_programming.html#type_generator">type generator</a> to build the
+you probably wrote a <a class="reference external" href="../../../more/generic_programming.html#type_generator">type generator</a> to build the
 <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> specialization you needed; in the new library
 design you don't need a type generator (though may want to keep it
 around as a compatibility aid for older code) because, due to the
-use of the Curiously Recurring Template Pattern (CRTP) <a class="citation-reference" href="#cop95" id="id22">[Cop95]</a>,
+use of the Curiously Recurring Template Pattern (CRTP) <a class="citation-reference" href="#cop95" id="id21">[Cop95]</a>,
 you can now define the iterator class yourself and acquire
 functionality through inheritance from <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> or
 <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>.  As a result, you also get much finer control
@ -198,7 +198,7 @@ type, <tt class="docutils literal"><span class="pre">transform_iterator</span></
 <tt class="docutils literal"><span class="pre">projection_iterator</span></tt> used to.</p>
 </div>
 <div class="section" id="history">
-<h1><a class="toc-backref" href="#id30">History</a></h1>
+<h1><a class="toc-backref" href="#id29">History</a></h1>
 <p>In 2000 Dave Abrahams was writing an iterator for a container of
 pointers, which would access the pointed-to elements when
 dereferenced.  Naturally, being a library writer, he decided to
@ -226,7 +226,7 @@ library you see today.</p>
 <table class="docutils citation" frame="void" id="cop95" rules="none">
 <colgroup><col class="label" /><col /></colgroup>
 <tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id22">[Cop95]</a></td><td>[Coplien, 1995] Coplien, J., Curiously Recurring Template
+<tr><td class="label"><a class="fn-backref" href="#id21">[Cop95]</a></td><td>[Coplien, 1995] Coplien, J., Curiously Recurring Template
 Patterns, C++ Report, February 1995, pp. 24-27.</td></tr>
 </tbody>
 </table>
--- a/doc/index.rst
+++ b/doc/index.rst
@ -43,7 +43,7 @@ __ ../../../index.htm
           The components of the Boost Iterator Library replace the
           older Boost Iterator Adaptor Library.
-.. _concepts: http://www.boost.org/more/generic_programming.html#concept
+.. _concepts: ../../../more/generic_programming.html#concept
 .. contents:: **Table of Contents**
@ -138,11 +138,7 @@ iterator templates based on the Boost `iterator facade and adaptor`_.
 * |filter|_ (PDF__): an iterator over the subset of elements of some
  sequence which satisfy a given predicate
-* |function_input|_ (PDF__): an input iterator wrapping a generator (nullary
+* |function|_ (PDF__): an output iterator wrapping a unary function
  function object); each time the iterator is dereferenced, the function object
  is called to get the value to return.
 * |function_output|_ (PDF__): an output iterator wrapping a unary function
  object; each time an element is written into the dereferenced
  iterator, it is passed as a parameter to the function object.
@ -175,12 +171,8 @@ __ counting_iterator.pdf
 .. _filter: filter_iterator.html
 __ filter_iterator.pdf
-.. |function_input| replace:: ``function_input_iterator``
+.. |function| replace:: ``function_output_iterator``
-.. _function_input: function_input_iterator.html
+.. _function: function_output_iterator.html
 __ function_input_iterator.pdf
 .. |function_output| replace:: ``function_output_iterator``
 .. _function_output: function_output_iterator.html
 __ function_output_iterator.pdf
 .. |indirect| replace:: ``indirect_iterator``
@ -279,7 +271,7 @@ over how your iterator works: you can add additional constructors,
 or even override the iterator functionality provided by the
 library.
-.. _`type generator`: http://www.boost.org/more/generic_programming.html#type_generator
+.. _`type generator`: ../../../more/generic_programming.html#type_generator
 If you're looking for the old ``projection_iterator`` component,
 its functionality has been merged into ``transform_iterator``: as
--- a/doc/indirect_iterator.pdf
+++ b/doc/indirect_iterator.pdf
--- a/doc/indirect_reference_ref.rst
+++ b/doc/indirect_reference_ref.rst
--- a/doc/interoperability-revisited.rst
+++ b/doc/interoperability-revisited.rst
--- a/doc/issues.rst
+++ b/doc/issues.rst
--- a/doc/iterator_adaptor.pdf
+++ b/doc/iterator_adaptor.pdf
--- a/doc/iterator_adaptor_tutorial.rst
+++ b/doc/iterator_adaptor_tutorial.rst
--- a/doc/iterator_archetypes.html
+++ b/doc/iterator_archetypes.html
--- a/doc/iterator_archetypes.pdf
+++ b/doc/iterator_archetypes.pdf
--- a/doc/iterator_archetypes.rst
+++ b/doc/iterator_archetypes.rst
--- a/doc/iterator_concepts.pdf
+++ b/doc/iterator_concepts.pdf
--- a/doc/iterator_concepts.rst
+++ b/doc/iterator_concepts.rst
--- a/doc/iterator_facade.html
+++ b/doc/iterator_facade.html
@ -866,7 +866,7 @@ operator -(iterator_facade&lt;Dr1,V1,TC1,R1,D1&gt; const&amp; lhs,
 <p>In this section we'll walk through the implementation of a few
 iterators using <tt class="docutils literal"><span class="pre">iterator_facade</span></tt>, based around the simple
 example of a linked list of polymorphic objects.  This example was
-inspired by a <a class="reference external" href="http://thread.gmane.org/gmane.comp.lib.boost.user/5100">posting</a> by Keith Macdonald on the <a class="reference external" href="http://www.boost.org/more/mailing_lists.htm#users">Boost-Users</a>
+inspired by a <a class="reference external" href="http://thread.gmane.org/gmane.comp.lib.boost.user/5100">posting</a> by Keith Macdonald on the <a class="reference external" href="../../../more/mailing_lists.htm#users">Boost-Users</a>
 mailing list.</p>
 <div class="section" id="the-problem">
 <h2><a class="toc-backref" href="#id32">The Problem</a></h2>
--- a/doc/iterator_facade.pdf
+++ b/doc/iterator_facade.pdf
--- a/doc/iterator_facade_tutorial.rst
+++ b/doc/iterator_facade_tutorial.rst
@ -8,7 +8,7 @@ example of a linked list of polymorphic objects.  This example was
 inspired by a `posting`__ by Keith Macdonald on the `Boost-Users`_
 mailing list.
-.. _`Boost-Users`: http://www.boost.org/more/mailing_lists.htm#users
+.. _`Boost-Users`: ../../../more/mailing_lists.htm#users
 __ http://thread.gmane.org/gmane.comp.lib.boost.user/5100
--- a/doc/iterator_traits.html
+++ b/doc/iterator_traits.html
--- a/doc/iterator_traits.pdf
+++ b/doc/iterator_traits.pdf
--- a/doc/iterator_traits.rst
+++ b/doc/iterator_traits.rst
--- a/doc/make_counting_iterator.rst
+++ b/doc/make_counting_iterator.rst
--- a/doc/make_filter_iterator.rst
+++ b/doc/make_filter_iterator.rst
--- a/doc/make_transform_iterator.rst
+++ b/doc/make_transform_iterator.rst
--- a/doc/make_zip_iterator.rst
+++ b/doc/make_zip_iterator.rst
--- a/doc/new-iter-concepts.html
+++ b/doc/new-iter-concepts.html
--- a/doc/new-iter-concepts.pdf
+++ b/doc/new-iter-concepts.pdf
--- a/doc/permutation_iterator.pdf
+++ b/doc/permutation_iterator.pdf
--- a/doc/pointee.html
+++ b/doc/pointee.html
--- a/doc/pointee.pdf
+++ b/doc/pointee.pdf
--- a/doc/pointee.rst
+++ b/doc/pointee.rst
--- a/doc/pointee_ref.rst
+++ b/doc/pointee_ref.rst
--- a/doc/quickbook/facade_tutorial.qbk
+++ b/doc/quickbook/facade_tutorial.qbk
@ -7,7 +7,7 @@ example of a linked list of polymorphic objects.  This example was
 inspired by a 
 [@http://thread.gmane.org/gmane.comp.lib.boost.user/5100 `posting`]
 by Keith Macdonald on the 
-[@http://www.boost.org/more/mailing_lists.htm#users `Boost-Users`]
+[@../../../more/mailing_lists.htm#users `Boost-Users`]
 mailing list.
--- a/doc/quickbook/iterator.qbk
+++ b/doc/quickbook/iterator.qbk
@ -32,7 +32,7 @@
 [section:intro Introduction]
-[def _concepts_ [@http://www.boost.org/more/generic_programming.html#concept concepts]]
+[def _concepts_ [@../../more/generic_programming.html#concept concepts]]
 The Boost Iterator Library contains two parts. The first
 is a system of _concepts_ which extend the C++ standard
@ -203,7 +203,7 @@ templates.
 [section:upgrading Upgrading from the old Boost Iterator Adaptor Library]
-[def _type_generator_ [@http://www.boost.org/more/generic_programming.html#type_generator type generator]]
+[def _type_generator_ [@../../more/generic_programming.html#type_generator type generator]]
 If you have been using the old Boost Iterator Adaptor library to
 implement iterators, you probably wrote a `Policies` class which
--- a/doc/reverse_iterator.pdf
+++ b/doc/reverse_iterator.pdf
--- a/doc/sources.py
+++ b/doc/sources.py
@ -6,7 +6,6 @@ sources = [
 'counting_iterator.rst',
 'facade-and-adaptor.rst',
 'filter_iterator.rst',
 'function_input_iterator.rst',
 'function_output_iterator.rst',
 'index.rst',
 'indirect_iterator.rst',
--- a/doc/transform_iterator.pdf
+++ b/doc/transform_iterator.pdf
--- a/doc/transform_iterator_eg.rst
+++ b/doc/transform_iterator_eg.rst
--- a/doc/zip_iterator.html
+++ b/doc/zip_iterator.html
--- a/doc/zip_iterator.pdf
+++ b/doc/zip_iterator.pdf
--- a/doc/zip_iterator.rst
+++ b/doc/zip_iterator.rst
--- a/doc/zip_iterator_abstract.rst
+++ b/doc/zip_iterator_abstract.rst
--- a/doc/zip_iterator_eg.rst
+++ b/doc/zip_iterator_eg.rst
--- a/doc/zip_iterator_ref.rst
+++ b/doc/zip_iterator_ref.rst
--- a/example/node.hpp
+++ b/example/node.hpp
--- a/example/node_iterator1.cpp
+++ b/example/node_iterator1.cpp
--- a/example/node_iterator1.hpp
+++ b/example/node_iterator1.hpp
--- a/example/node_iterator2.cpp
+++ b/example/node_iterator2.cpp
--- a/example/node_iterator2.hpp
+++ b/example/node_iterator2.hpp
--- a/example/node_iterator3.cpp
+++ b/example/node_iterator3.cpp
--- a/example/node_iterator3.hpp
+++ b/example/node_iterator3.hpp
--- a/include/boost/iterator.hpp
+++ b/include/boost/iterator.hpp
@ -1,4 +1,4 @@
-//  iterator.hpp workarounds for non-conforming standard libraries  ---------//
+//  interator.hpp workarounds for non-conforming standard libraries  ---------//
 //  (C) Copyright Beman Dawes 2000. Distributed under the Boost
 //  Software License, Version 1.0. (See accompanying file
--- a/include/boost/iterator/detail/any_conversion_eater.hpp
+++ b/include/boost/iterator/detail/any_conversion_eater.hpp
--- a/include/boost/iterator/detail/config_def.hpp
+++ b/include/boost/iterator/detail/config_def.hpp
@ -47,11 +47,9 @@
 #endif
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                       \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                   \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))                   \
    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
-    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
+    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
 # define BOOST_NO_LVALUE_RETURN_DETECTION
 # if 0 // test code
--- a/include/boost/iterator/detail/facade_iterator_category.hpp
+++ b/include/boost/iterator/detail/facade_iterator_category.hpp
--- a/include/boost/iterator/detail/minimum_category.hpp
+++ b/include/boost/iterator/detail/minimum_category.hpp
--- a/include/boost/iterator/function_input_iterator.hpp
+++ b/include/boost/iterator/function_input_iterator.hpp
@ -1,64 +0,0 @@
 // Copyright 2009 (C) Dean Michael Berris <me@deanberris.com>
 // 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_FUNCTION_INPUT_ITERATOR
 #define BOOST_FUNCTION_INPUT_ITERATOR
 #include <boost/iterator/iterator_facade.hpp>
 namespace boost {
    template <class Function, class Input>
        class function_input_iterator
        : public iterator_facade<
            function_input_iterator<Function, Input>,
            typename Function::result_type,
            single_pass_traversal_tag,
            typename Function::result_type const &
            >
    {
        public:
            function_input_iterator() {}
            function_input_iterator(Function * f_, Input state_ = Input()) 
                : f(f_), state(state_), value((*f)()) {}
            void increment() {
                value = (*f)();
                ++state;
            }
            typename Function::result_type const & 
            dereference() const {
                return value;
            }
            bool equal(function_input_iterator const & other) const {
                return f == other.f && state == other.state;
            }
        private:
            Function * f;
            Input state;
            typename Function::result_type value;
    };
    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 {
        infinite & operator++() { return *this; }
        infinite & operator++(int) { return *this; }
        bool operator==(infinite &) const { return false; };
        bool operator==(infinite const &) const { return false; };
    };
 }
 #endif
--- a/include/boost/iterator/indirect_iterator.hpp
+++ b/include/boost/iterator/indirect_iterator.hpp
@ -110,7 +110,7 @@ namespace boost
  private:    
      typename super_t::reference dereference() const
      {
-# if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
          return const_cast<super_t::reference>(**this->base());
 # else
          return **this->base();
--- a/include/boost/iterator/is_lvalue_iterator.hpp
+++ b/include/boost/iterator/is_lvalue_iterator.hpp
--- a/include/boost/iterator/is_readable_iterator.hpp
+++ b/include/boost/iterator/is_readable_iterator.hpp
--- a/include/boost/iterator/iterator_adaptor.hpp
+++ b/include/boost/iterator/iterator_adaptor.hpp
@ -24,14 +24,9 @@
 #ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
 # include <boost/type_traits/remove_reference.hpp>
-
+#else 
 # 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
+#endif 
 #include <boost/iterator/detail/config_def.hpp>
--- a/include/boost/iterator/iterator_facade.hpp
+++ b/include/boost/iterator/iterator_facade.hpp
@ -105,7 +105,6 @@ namespace boost
        typedef typename remove_const<ValueParam>::type value_type;
        // Not the real associated pointer type
        typedef typename mpl::eval_if<
            boost::detail::iterator_writability_disabled<ValueParam,Reference>
          , add_pointer<const value_type>
@ -434,26 +433,26 @@ namespace boost
 # ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \
    template <                                                              \
-        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
+        class Derived1, class V1, class TC1, class R1, class D1             \
-      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
+      , class Derived2, class V2, class TC2, class R2, class D2             \
    >                                                                       \
    prefix typename mpl::apply2<result_type,Derived1,Derived2>::type \
    operator op(                                                            \
-        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
+        iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs               \
-      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
+      , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)
 # else 
 #  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)   \
    template <                                                          \
-        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
+        class Derived1, class V1, class TC1, class R1, class D1         \
-      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
+      , class Derived2, class V2, class TC2, class R2, class D2         \
    >                                                                   \
    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<Derived1, V1, TC1, R1, D1> const& lhs           \
-      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
+      , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)
 # endif 
 #  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
@ -471,7 +470,8 @@ namespace boost
  //
  class iterator_core_access
  {
-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \
    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
      // Tasteless as this may seem, making all members public allows member templates
      // to work in the absence of member template friends.
   public:
@ -618,12 +618,6 @@ namespace boost
         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_;
@ -633,9 +627,7 @@ namespace boost
      typedef typename associated_types::value_type value_type;
      typedef Reference reference;
      typedef Difference difference_type;
-
+      typedef typename associated_types::pointer pointer;
      typedef typename pointer_::type pointer;
      typedef typename associated_types::iterator_category iterator_category;
      reference operator*() const
@ -643,9 +635,18 @@ namespace boost
          return iterator_core_access::dereference(this->derived());
      }
-      pointer operator->() const
+      typename boost::detail::operator_arrow_result<
          value_type
        , reference
        , pointer
      >::type
      operator->() const
      {
-          return pointer_::make(*this->derived());
+          return boost::detail::operator_arrow_result<
              value_type
            , reference
            , pointer
          >::make(*this->derived());
      }
      typename boost::detail::operator_brackets_result<Derived,Value,reference>::type
--- a/include/boost/iterator/transform_iterator.hpp
+++ b/include/boost/iterator/transform_iterator.hpp
@ -7,6 +7,7 @@
 #ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
 #define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
 #include <boost/function.hpp>
 #include <boost/iterator.hpp>
 #include <boost/iterator/detail/enable_if.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
@ -20,8 +21,6 @@
 #include <boost/type_traits/is_reference.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/utility/result_of.hpp>
 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
 # include <boost/type_traits/is_base_and_derived.hpp>
@ -37,18 +36,33 @@ namespace boost
  namespace detail 
  {
    template <class UnaryFunc>
    struct function_object_result
    {
      typedef typename UnaryFunc::result_type type;
    };
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    template <class Return, class Argument>
    struct function_object_result<Return(*)(Argument)>
    {
      typedef Return type;
    };
 #endif
    // 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.
+        // the function.  Do we need to adjust the way
        // function_object_result is computed for the standard
        // proposal (e.g. using Doug's result_of)?
        typedef typename ia_dflt_help<
            Reference
-          , result_of<UnaryFunc(typename std::iterator_traits<Iterator>::value_type)>
+          , function_object_result<UnaryFunc>
        >::type reference;
        // To get the default for Value: remove any reference on the
@ -100,7 +114,7 @@ namespace boost
 #endif 
    }
-    template <
+    template<
        class OtherUnaryFunction
      , class OtherIterator
      , class OtherReference
--- a/include/boost/iterator/zip_iterator.hpp
+++ b/include/boost/iterator/zip_iterator.hpp
@ -357,7 +357,7 @@ namespace boost {
    {
      typedef typename tuple_impl_specific::tuple_meta_transform<
          IteratorTuple
-        , pure_traversal_tag<iterator_traversal<> >
+        , iterator_traversal<>
      >::type tuple_of_traversal_tags;
      typedef typename tuple_impl_specific::tuple_meta_accumulate<
--- a/include/boost/iterator_adaptors.hpp
+++ b/include/boost/iterator_adaptors.hpp
@ -1,9 +1,6 @@
 // Copyright David Abrahams 2004. 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 www.boost.org/libs/iterator for documentation.
 #ifndef ITERATOR_ADAPTORS_DWA2004725_HPP
 # define ITERATOR_ADAPTORS_DWA2004725_HPP
--- a/include/boost/pointee.hpp
+++ b/include/boost/pointee.hpp
--- a/index.html
+++ b/index.html
--- a/test/constant_iter_arrow.cpp
+++ b/test/constant_iter_arrow.cpp
--- a/test/constant_iter_arrow_fail.cpp
+++ b/test/constant_iter_arrow_fail.cpp
--- a/test/interoperable.cpp
+++ b/test/interoperable.cpp
--- a/test/is_lvalue_iterator.cpp
+++ b/test/is_lvalue_iterator.cpp
--- a/test/is_readable_iterator.cpp
+++ b/test/is_readable_iterator.cpp
--- a/test/iter_archetype_default_ctor.cpp
+++ b/test/iter_archetype_default_ctor.cpp
--- a/test/iterator_facade.cpp
+++ b/test/iterator_facade.cpp
@ -87,10 +87,6 @@ struct input_iter
    }
 };
 template <class T, class U>
 void same_type(U const&)
 { BOOST_MPL_ASSERT((boost::is_same<T,U>)); }
 int main()
 {
    int state = 0;
@ -105,8 +101,6 @@ int main()
    input_iter p;
    (*p).mutator();
    p->mutator();
    same_type<input_iter::pointer>(p.operator->());
    return boost::report_errors();
 }
--- a/test/pointee.cpp
+++ b/test/pointee.cpp
--- a/test/transform_iterator_test.cpp
+++ b/test/transform_iterator_test.cpp
@ -102,16 +102,6 @@ int mult_2(int arg)
  return arg*2;
 }
 struct polymorphic_mult_functor
 {
    //Implement result_of protocol
    template <class FArgs> struct result;
    template <class F, class T> struct result<F(T)> {typedef T type;};
    template <class T> 
    typename result<polymorphic_mult_functor(T)>::type
    operator()(const T& _arg) const {return _arg*2;}
 };
 int
 main()
@ -254,25 +244,5 @@ main()
    );
  }
  // Test transform_iterator with polymorphic object function
  {
    int x[N], y[N];
    for (int k = 0; k < N; ++k)
      x[k] = k;
    std::copy(x, x + N, y);
    for (int k2 = 0; k2 < N; ++k2)
      x[k2] = x[k2] * 2;
    boost::input_iterator_test(
        boost::make_transform_iterator(y, polymorphic_mult_functor()), x[0], x[1]);
    boost::input_iterator_test(
        boost::make_transform_iterator(&y[0], polymorphic_mult_functor()), x[0], x[1]);
    boost::random_access_readable_iterator_test(
        boost::make_transform_iterator(y, polymorphic_mult_functor()), N, x);
  }
  return boost::report_errors();
 }
--- a/test/zip_iterator_test.cpp
+++ b/test/zip_iterator_test.cpp
@ -46,7 +46,6 @@
 #include <vector>
 #include <list>
 #include <set>
 #include <string>
 #include <functional>
 #include <boost/tuple/tuple.hpp>
 #include <boost/iterator/transform_iterator.hpp>
@ -61,27 +60,6 @@ struct pure_traversal
        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
        )
    );
 }
 ///
 /////////////////////////////////////////////////////////////////////////////
 //
@ -92,8 +70,6 @@ void category_test()
 int main( void )
 {
  category_test();
  std::cout << "\n"
            << "***********************************************\n"
            << "*                                             *\n"