mirror of
https://github.com/boostorg/iterator.git
synced 2025-06-27 21:11:02 +02:00
Compare commits
31 Commits
svn-branch
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| ff57de07ec | |||
| 2ece3ac5c2 | |||
| 9b681a7980 | |||
| 1ab5f06d06 | |||
| 78effefadb | |||
| 37c46f7da5 | |||
| 6d0f901b2e | |||
| db0e0b7b91 | |||
| 23d53055f9 | |||
| ff73538b5b | |||
| 0e0d5b4326 | |||
| 30685528c7 | |||
| c849f35965 | |||
| aa483f4961 | |||
| 93c010eb51 | |||
| 0dc017b1a8 | |||
| 92c92bbbf8 | |||
| f51591cb04 | |||
| 624131ce46 | |||
| 47da2546f9 | |||
| 8a53abc1e8 | |||
| b258a435cc | |||
| 43e4f1a766 | |||
| 02d22c12ae | |||
| 70ef2f0e81 | |||
| b7283c93c6 | |||
| 5184d64b80 | |||
| f482354ffd | |||
| 7a2b9d66a9 | |||
| d79112ee5a | |||
| 4a5e8f175a |
1
doc/.cvsignore
Executable file
1
doc/.cvsignore
Executable file
@ -0,0 +1 @@
|
||||
GNUmakefile
|
||||
@ -13,11 +13,8 @@ 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
|
||||
;
|
||||
|
||||
|
||||
|
||||
@ -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@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&</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 <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;
|
||||
}
|
||||
</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<int>(cout, " ")
|
||||
);
|
||||
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<int>(count, " ")
|
||||
);
|
||||
</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>
|
||||
@ -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.
|
||||
|
||||
|
||||
@ -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) -->
|
||||
@ -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="#iterator-facade-and-adaptor" id="id24">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="#iterator-utilities" id="id26">Iterator Utilities</a><ul>
|
||||
<li><a class="reference internal" href="#traits" id="id27">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="#new-style-iterators" id="id22">New-Style Iterators</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="id24">Specialized Adaptors</a></li>
|
||||
<li><a class="reference internal" href="#iterator-utilities" id="id25">Iterator Utilities</a><ul>
|
||||
<li><a class="reference internal" href="#traits" id="id26">Traits</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="#history" id="id30">History</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="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 "lazy sequence"</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,7 +173,7 @@ 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
|
||||
@ -183,7 +183,7 @@ you probably wrote a <a class="reference external" href="http://www.boost.org/mo
|
||||
<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>
|
||||
|
||||
@ -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 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
|
||||
* |function|_ (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_input: function_input_iterator.html
|
||||
__ function_input_iterator.pdf
|
||||
|
||||
.. |function_output| replace:: ``function_output_iterator``
|
||||
.. _function_output: function_output_iterator.html
|
||||
.. |function| replace:: ``function_output_iterator``
|
||||
.. _function: function_output_iterator.html
|
||||
__ function_output_iterator.pdf
|
||||
|
||||
.. |indirect| replace:: ``indirect_iterator``
|
||||
|
||||
451
doc/issues.html
Executable file
451
doc/issues.html
Executable file
@ -0,0 +1,451 @@
|
||||
<?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.4: http://docutils.sourceforge.net/" />
|
||||
<title>Problem with is_writable and is_swappable in N1550</title>
|
||||
<meta name="author" content="David Abrahams and Jeremy Siek" />
|
||||
<meta name="organization" content="Boost Consulting, Indiana University Bloomington" />
|
||||
<meta name="date" content="2003-11-19" />
|
||||
<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek 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)" />
|
||||
<style type="text/css">
|
||||
|
||||
/*
|
||||
:Author: David Goodger
|
||||
:Contact: goodger@users.sourceforge.net
|
||||
:Date: $Date$
|
||||
:Revision: $Revision$
|
||||
:Copyright: This stylesheet has been placed in the public domain.
|
||||
|
||||
Default cascading style sheet for the HTML output of Docutils.
|
||||
|
||||
See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
|
||||
customize this style sheet.
|
||||
*/
|
||||
|
||||
/* used to remove borders from tables and images */
|
||||
.borderless, table.borderless td, table.borderless th {
|
||||
border: 0 }
|
||||
|
||||
table.borderless td, table.borderless th {
|
||||
/* Override padding for "table.docutils td" with "! important".
|
||||
The right padding separates the table cells. */
|
||||
padding: 0 0.5em 0 0 ! important }
|
||||
|
||||
.first {
|
||||
/* Override more specific margin styles with "! important". */
|
||||
margin-top: 0 ! important }
|
||||
|
||||
.last, .with-subtitle {
|
||||
margin-bottom: 0 ! important }
|
||||
|
||||
.hidden {
|
||||
display: none }
|
||||
|
||||
a.toc-backref {
|
||||
text-decoration: none ;
|
||||
color: black }
|
||||
|
||||
blockquote.epigraph {
|
||||
margin: 2em 5em ; }
|
||||
|
||||
dl.docutils dd {
|
||||
margin-bottom: 0.5em }
|
||||
|
||||
/* Uncomment (and remove this text!) to get bold-faced definition list terms
|
||||
dl.docutils dt {
|
||||
font-weight: bold }
|
||||
*/
|
||||
|
||||
div.abstract {
|
||||
margin: 2em 5em }
|
||||
|
||||
div.abstract p.topic-title {
|
||||
font-weight: bold ;
|
||||
text-align: center }
|
||||
|
||||
div.admonition, div.attention, div.caution, div.danger, div.error,
|
||||
div.hint, div.important, div.note, div.tip, div.warning {
|
||||
margin: 2em ;
|
||||
border: medium outset ;
|
||||
padding: 1em }
|
||||
|
||||
div.admonition p.admonition-title, div.hint p.admonition-title,
|
||||
div.important p.admonition-title, div.note p.admonition-title,
|
||||
div.tip p.admonition-title {
|
||||
font-weight: bold ;
|
||||
font-family: sans-serif }
|
||||
|
||||
div.attention p.admonition-title, div.caution p.admonition-title,
|
||||
div.danger p.admonition-title, div.error p.admonition-title,
|
||||
div.warning p.admonition-title {
|
||||
color: red ;
|
||||
font-weight: bold ;
|
||||
font-family: sans-serif }
|
||||
|
||||
/* Uncomment (and remove this text!) to get reduced vertical space in
|
||||
compound paragraphs.
|
||||
div.compound .compound-first, div.compound .compound-middle {
|
||||
margin-bottom: 0.5em }
|
||||
|
||||
div.compound .compound-last, div.compound .compound-middle {
|
||||
margin-top: 0.5em }
|
||||
*/
|
||||
|
||||
div.dedication {
|
||||
margin: 2em 5em ;
|
||||
text-align: center ;
|
||||
font-style: italic }
|
||||
|
||||
div.dedication p.topic-title {
|
||||
font-weight: bold ;
|
||||
font-style: normal }
|
||||
|
||||
div.figure {
|
||||
margin-left: 2em ;
|
||||
margin-right: 2em }
|
||||
|
||||
div.footer, div.header {
|
||||
clear: both;
|
||||
font-size: smaller }
|
||||
|
||||
div.line-block {
|
||||
display: block ;
|
||||
margin-top: 1em ;
|
||||
margin-bottom: 1em }
|
||||
|
||||
div.line-block div.line-block {
|
||||
margin-top: 0 ;
|
||||
margin-bottom: 0 ;
|
||||
margin-left: 1.5em }
|
||||
|
||||
div.sidebar {
|
||||
margin-left: 1em ;
|
||||
border: medium outset ;
|
||||
padding: 1em ;
|
||||
background-color: #ffffee ;
|
||||
width: 40% ;
|
||||
float: right ;
|
||||
clear: right }
|
||||
|
||||
div.sidebar p.rubric {
|
||||
font-family: sans-serif ;
|
||||
font-size: medium }
|
||||
|
||||
div.system-messages {
|
||||
margin: 5em }
|
||||
|
||||
div.system-messages h1 {
|
||||
color: red }
|
||||
|
||||
div.system-message {
|
||||
border: medium outset ;
|
||||
padding: 1em }
|
||||
|
||||
div.system-message p.system-message-title {
|
||||
color: red ;
|
||||
font-weight: bold }
|
||||
|
||||
div.topic {
|
||||
margin: 2em }
|
||||
|
||||
h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
|
||||
h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
|
||||
margin-top: 0.4em }
|
||||
|
||||
h1.title {
|
||||
text-align: center }
|
||||
|
||||
h2.subtitle {
|
||||
text-align: center }
|
||||
|
||||
hr.docutils {
|
||||
width: 75% }
|
||||
|
||||
img.align-left {
|
||||
clear: left }
|
||||
|
||||
img.align-right {
|
||||
clear: right }
|
||||
|
||||
ol.simple, ul.simple {
|
||||
margin-bottom: 1em }
|
||||
|
||||
ol.arabic {
|
||||
list-style: decimal }
|
||||
|
||||
ol.loweralpha {
|
||||
list-style: lower-alpha }
|
||||
|
||||
ol.upperalpha {
|
||||
list-style: upper-alpha }
|
||||
|
||||
ol.lowerroman {
|
||||
list-style: lower-roman }
|
||||
|
||||
ol.upperroman {
|
||||
list-style: upper-roman }
|
||||
|
||||
p.attribution {
|
||||
text-align: right ;
|
||||
margin-left: 50% }
|
||||
|
||||
p.caption {
|
||||
font-style: italic }
|
||||
|
||||
p.credits {
|
||||
font-style: italic ;
|
||||
font-size: smaller }
|
||||
|
||||
p.label {
|
||||
white-space: nowrap }
|
||||
|
||||
p.rubric {
|
||||
font-weight: bold ;
|
||||
font-size: larger ;
|
||||
color: maroon ;
|
||||
text-align: center }
|
||||
|
||||
p.sidebar-title {
|
||||
font-family: sans-serif ;
|
||||
font-weight: bold ;
|
||||
font-size: larger }
|
||||
|
||||
p.sidebar-subtitle {
|
||||
font-family: sans-serif ;
|
||||
font-weight: bold }
|
||||
|
||||
p.topic-title {
|
||||
font-weight: bold }
|
||||
|
||||
pre.address {
|
||||
margin-bottom: 0 ;
|
||||
margin-top: 0 ;
|
||||
font-family: serif ;
|
||||
font-size: 100% }
|
||||
|
||||
pre.literal-block, pre.doctest-block {
|
||||
margin-left: 2em ;
|
||||
margin-right: 2em ;
|
||||
background-color: #eeeeee }
|
||||
|
||||
span.classifier {
|
||||
font-family: sans-serif ;
|
||||
font-style: oblique }
|
||||
|
||||
span.classifier-delimiter {
|
||||
font-family: sans-serif ;
|
||||
font-weight: bold }
|
||||
|
||||
span.interpreted {
|
||||
font-family: sans-serif }
|
||||
|
||||
span.option {
|
||||
white-space: nowrap }
|
||||
|
||||
span.pre {
|
||||
white-space: pre }
|
||||
|
||||
span.problematic {
|
||||
color: red }
|
||||
|
||||
span.section-subtitle {
|
||||
/* font-size relative to parent (h1..h6 element) */
|
||||
font-size: 80% }
|
||||
|
||||
table.citation {
|
||||
border-left: solid 1px gray;
|
||||
margin-left: 1px }
|
||||
|
||||
table.docinfo {
|
||||
margin: 2em 4em }
|
||||
|
||||
table.docutils {
|
||||
margin-top: 0.5em ;
|
||||
margin-bottom: 0.5em }
|
||||
|
||||
table.footnote {
|
||||
border-left: solid 1px black;
|
||||
margin-left: 1px }
|
||||
|
||||
table.docutils td, table.docutils th,
|
||||
table.docinfo td, table.docinfo th {
|
||||
padding-left: 0.5em ;
|
||||
padding-right: 0.5em ;
|
||||
vertical-align: top }
|
||||
|
||||
table.docutils th.field-name, table.docinfo th.docinfo-name {
|
||||
font-weight: bold ;
|
||||
text-align: left ;
|
||||
white-space: nowrap ;
|
||||
padding-left: 0 }
|
||||
|
||||
h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
|
||||
h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
|
||||
font-size: 100% }
|
||||
|
||||
tt.docutils {
|
||||
background-color: #eeeeee }
|
||||
|
||||
ul.auto-toc {
|
||||
list-style-type: none }
|
||||
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="document" id="problem-with-is-writable-and-is-swappable-in-n1550">
|
||||
<h1 class="title">Problem with <tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils literal"><span class="pre">is_swappable</span></tt> in <a class="reference" href="http://www.boost-consulting.com/writing/n1550.html">N1550</a></h1>
|
||||
<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>David Abrahams and Jeremy Siek</td></tr>
|
||||
<tr><th class="docinfo-name">Contact:</th>
|
||||
<td><a class="first reference" href="mailto:dave@boost-consulting.com">dave@boost-consulting.com</a>, <a class="last reference" href="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</a></td></tr>
|
||||
<tr><th class="docinfo-name">Organization:</th>
|
||||
<td><a class="first reference" href="http://www.boost-consulting.com">Boost Consulting</a>, Indiana University Bloomington</td></tr>
|
||||
<tr><th class="docinfo-name">Date:</th>
|
||||
<td>2003-11-19</td></tr>
|
||||
<tr><th class="docinfo-name">Copyright:</th>
|
||||
<td>Copyright David Abrahams, Jeremy Siek 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 <a class="reference" href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</td></tr>
|
||||
</tbody>
|
||||
</table>
|
||||
<div class="contents topic">
|
||||
<p class="topic-title first"><a id="table-of-contents" name="table-of-contents">Table of Contents</a></p>
|
||||
<ul class="simple">
|
||||
<li><a class="reference" href="#introduction" id="id1" name="id1">Introduction</a></li>
|
||||
<li><a class="reference" href="#proposed-resolution" id="id2" name="id2">Proposed Resolution</a></li>
|
||||
<li><a class="reference" href="#rationale" id="id3" name="id3">Rationale</a></li>
|
||||
</ul>
|
||||
</div>
|
||||
<div class="section">
|
||||
<h1><a class="toc-backref" href="#id1" id="introduction" name="introduction">Introduction</a></h1>
|
||||
<p>The <tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils literal"><span class="pre">is_swappable</span></tt> traits classes in <a class="reference" href="http://www.boost-consulting.com/writing/n1550.html">N1550</a>
|
||||
provide a mechanism for determining at compile time if an iterator
|
||||
type is a model of the new Writable Iterator and Swappable Iterator
|
||||
concepts, analogous to <tt class="docutils literal"><span class="pre">iterator_traits<X>::iterator_category</span></tt>
|
||||
for the old iterator concepts. For backward compatibility,
|
||||
<tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils literal"><span class="pre">is_swappable</span></tt> not only work with new
|
||||
iterators, but they also are intended to work for old
|
||||
iterators (iterators that meet the requirements for one of the
|
||||
iterator concepts in the current standard). In the case of old
|
||||
iterators, the writability and swapability is deduced based on the
|
||||
<tt class="docutils literal"><span class="pre">iterator_category</span></tt> and also the <tt class="docutils literal"><span class="pre">reference</span></tt> type. The
|
||||
specification for this deduction gives false positives for forward
|
||||
iterators that have non-assignable value types.</p>
|
||||
<p>To review, the part of the <tt class="docutils literal"><span class="pre">is_writable</span></tt> trait definition which
|
||||
applies to old iterators is:</p>
|
||||
<pre class="literal-block">
|
||||
if (cat is convertible to output_iterator_tag)
|
||||
return true;
|
||||
else if (cat is convertible to forward_iterator_tag
|
||||
and iterator_traits<Iterator>::reference is a
|
||||
mutable reference)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
</pre>
|
||||
<p>Suppose the <tt class="docutils literal"><span class="pre">value_type</span></tt> of the iterator <tt class="docutils literal"><span class="pre">It</span></tt> has a private
|
||||
assignment operator:</p>
|
||||
<pre class="literal-block">
|
||||
class B {
|
||||
public:
|
||||
...
|
||||
private:
|
||||
B& operator=(const B&);
|
||||
};
|
||||
</pre>
|
||||
<p>and suppose the <tt class="docutils literal"><span class="pre">reference</span></tt> type of the iterator is <tt class="docutils literal"><span class="pre">B&</span></tt>. In
|
||||
that case, <tt class="docutils literal"><span class="pre">is_writable<It>::value</span></tt> will be true when in fact
|
||||
attempting to write into <tt class="docutils literal"><span class="pre">B</span></tt> will cause an error.</p>
|
||||
<p>The same problem applies to <tt class="docutils literal"><span class="pre">is_swappable</span></tt>.</p>
|
||||
</div>
|
||||
<div class="section">
|
||||
<h1><a class="toc-backref" href="#id2" id="proposed-resolution" name="proposed-resolution">Proposed Resolution</a></h1>
|
||||
<ol class="arabic">
|
||||
<li><p class="first">Remove the <tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils literal"><span class="pre">is_swappable</span></tt> traits, and remove the
|
||||
requirements in the Writable Iterator and Swappable Iterator concepts
|
||||
that require their models to support these traits.</p>
|
||||
</li>
|
||||
<li><p class="first">Change the <tt class="docutils literal"><span class="pre">is_readable</span></tt> specification to be:
|
||||
<tt class="docutils literal"><span class="pre">is_readable<X>::type</span></tt> is <tt class="docutils literal"><span class="pre">true_type</span></tt> if the
|
||||
result type of <tt class="docutils literal"><span class="pre">X::operator*</span></tt> is convertible to
|
||||
<tt class="docutils literal"><span class="pre">iterator_traits<X>::value_type</span></tt> and is <tt class="docutils literal"><span class="pre">false_type</span></tt>
|
||||
otherwise. Also, <tt class="docutils literal"><span class="pre">is_readable</span></tt> is required to satisfy
|
||||
the requirements for the UnaryTypeTrait concept
|
||||
(defined in the type traits proposal).</p>
|
||||
<p>Remove the requirement for support of the <tt class="docutils literal"><span class="pre">is_readable</span></tt> trait from
|
||||
the Readable Iterator concept.</p>
|
||||
</li>
|
||||
<li><p class="first">Remove the <tt class="docutils literal"><span class="pre">iterator_tag</span></tt> class.</p>
|
||||
</li>
|
||||
<li><p class="first">Change the specification of <tt class="docutils literal"><span class="pre">traversal_category</span></tt> to:</p>
|
||||
<pre class="literal-block">
|
||||
traversal-category(Iterator) =
|
||||
let cat = iterator_traits<Iterator>::iterator_category
|
||||
if (cat is convertible to incrementable_iterator_tag)
|
||||
return cat; // Iterator is a new iterator
|
||||
else if (cat is convertible to random_access_iterator_tag)
|
||||
return random_access_traversal_tag;
|
||||
else if (cat is convertible to bidirectional_iterator_tag)
|
||||
return bidirectional_traversal_tag;
|
||||
else if (cat is convertible to forward_iterator_tag)
|
||||
return forward_traversal_tag;
|
||||
else if (cat is convertible to input_iterator_tag)
|
||||
return single_pass_iterator_tag;
|
||||
else if (cat is convertible to output_iterator_tag)
|
||||
return incrementable_iterator_tag;
|
||||
else
|
||||
return null_category_tag;
|
||||
</pre>
|
||||
</li>
|
||||
</ol>
|
||||
</div>
|
||||
<div class="section">
|
||||
<h1><a class="toc-backref" href="#id3" id="rationale" name="rationale">Rationale</a></h1>
|
||||
<ol class="arabic simple">
|
||||
<li>There are two reasons for removing <tt class="docutils literal"><span class="pre">is_writable</span></tt>
|
||||
and <tt class="docutils literal"><span class="pre">is_swappable</span></tt>. The first is that we do not know of
|
||||
a way to fix the specification so that it gives the correct
|
||||
answer for all iterators. Second, there was only a weak
|
||||
motivation for having <tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils literal"><span class="pre">is_swappable</span></tt>
|
||||
there in the first place. The main motivation was simply
|
||||
uniformity: we have tags for the old iterator categories
|
||||
so we should have tags for the new iterator categories.
|
||||
While having tags and the capability to dispatch based
|
||||
on the traversal categories is often used, we see
|
||||
less of a need for dispatching based on writability
|
||||
and swappability, since typically algorithms
|
||||
that need these capabilities have no alternative if
|
||||
they are not provided.</li>
|
||||
<li>We discovered that the <tt class="docutils literal"><span class="pre">is_readable</span></tt> trait can be implemented
|
||||
using only the iterator type itself and its <tt class="docutils literal"><span class="pre">value_type</span></tt>.
|
||||
Therefore we remove the requirement for <tt class="docutils literal"><span class="pre">is_readable</span></tt> from the
|
||||
Readable Iterator concept, and change the definition of
|
||||
<tt class="docutils literal"><span class="pre">is_readable</span></tt> so that it works for any iterator type.</li>
|
||||
<li>The purpose of the <tt class="docutils literal"><span class="pre">iterator_tag</span></tt> class was to
|
||||
bundle the traversal and access category tags
|
||||
into the <tt class="docutils literal"><span class="pre">iterator_category</span></tt> typedef.
|
||||
With <tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils literal"><span class="pre">is_swappable</span></tt> gone, and
|
||||
<tt class="docutils literal"><span class="pre">is_readable</span></tt> no longer in need of special hints,
|
||||
there is no reason for iterators to provide
|
||||
information about the access capabilities of an iterator.
|
||||
Thus there is no need for the <tt class="docutils literal"><span class="pre">iterator_tag</span></tt>. The
|
||||
traversal tag can be directly used for the
|
||||
<tt class="docutils literal"><span class="pre">iterator_category</span></tt>. If a new iterator is intended to be backward
|
||||
compatible with old iterator concepts, a tag type
|
||||
that is convertible to both one of the new traversal tags
|
||||
and also to an old iterator tag can be created and use
|
||||
for the <tt class="docutils literal"><span class="pre">iterator_category</span></tt>.</li>
|
||||
<li>The changes to the specification of <tt class="docutils literal"><span class="pre">traversal_category</span></tt> are a
|
||||
direct result of the removal of <tt class="docutils literal"><span class="pre">iterator_tag</span></tt>.</li>
|
||||
</ol>
|
||||
</div>
|
||||
</div>
|
||||
</body>
|
||||
</html>
|
||||
0
doc/rst2html
Executable file → Normal file
0
doc/rst2html
Executable file → Normal file
@ -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',
|
||||
|
||||
17
example/Jamfile
Normal file
17
example/Jamfile
Normal file
@ -0,0 +1,17 @@
|
||||
# Copyright David Abrahams 2006. Distributed under the Boost
|
||||
# Software License, Version 1.0. (See accompanying
|
||||
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
test-suite iterator_examples
|
||||
: [ run reverse_iterator.cpp ]
|
||||
[ run node_iterator1.cpp ]
|
||||
[ run node_iterator2.cpp ]
|
||||
[ run node_iterator3.cpp ]
|
||||
[ run counting_iterator_example.cpp ]
|
||||
[ run filter_iterator_example.cpp ]
|
||||
[ run func_output_iter_example.cpp ]
|
||||
[ run indirect_iterator_example.cpp ]
|
||||
[ run permutation_iter_example.cpp ]
|
||||
[ run reverse_iterator_example.cpp ]
|
||||
[ run transform_iterator_example.cpp ]
|
||||
;
|
||||
@ -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
|
||||
|
||||
@ -1,150 +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/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>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace impl {
|
||||
|
||||
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>
|
||||
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_), value((*f)())
|
||||
{}
|
||||
|
||||
void increment() {
|
||||
value = (*f)();
|
||||
++state;
|
||||
}
|
||||
|
||||
typename function_types::result_type<Function>::type const &
|
||||
dereference() const {
|
||||
return value;
|
||||
}
|
||||
|
||||
bool equal(function_pointer_input_iterator const & other) const {
|
||||
return f == other.f && state == other.state;
|
||||
}
|
||||
|
||||
private:
|
||||
Function f;
|
||||
Input state;
|
||||
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) {
|
||||
typedef function_input_iterator<Function, Input> result_t;
|
||||
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 {
|
||||
infinite & operator++() { return *this; }
|
||||
infinite & operator++(int) { return *this; }
|
||||
bool operator==(infinite &) const { return false; };
|
||||
bool operator==(infinite const &) const { return false; };
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -24,9 +24,15 @@
|
||||
|
||||
#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>
|
||||
|
||||
@ -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>
|
||||
@ -324,7 +323,7 @@ namespace boost
|
||||
|
||||
static type make(Reference x)
|
||||
{
|
||||
return boost::implicit_cast<type>(&x);
|
||||
return implicit_cast<type>(&x);
|
||||
}
|
||||
};
|
||||
|
||||
@ -618,12 +617,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 +626,7 @@ namespace boost
|
||||
typedef typename associated_types::value_type value_type;
|
||||
typedef Reference reference;
|
||||
typedef Difference difference_type;
|
||||
|
||||
typedef typename pointer_::type pointer;
|
||||
|
||||
typedef typename associated_types::pointer pointer;
|
||||
typedef typename associated_types::iterator_category iterator_category;
|
||||
|
||||
reference operator*() const
|
||||
@ -643,9 +634,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
|
||||
|
||||
@ -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,16 +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:
|
||||
// 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>::reference)>
|
||||
, function_object_result<UnaryFunc>
|
||||
>::type reference;
|
||||
|
||||
// To get the default for Value: remove any reference on the
|
||||
@ -98,7 +114,7 @@ namespace boost
|
||||
#endif
|
||||
}
|
||||
|
||||
template <
|
||||
template<
|
||||
class OtherUnaryFunction
|
||||
, class OtherIterator
|
||||
, class OtherReference
|
||||
|
||||
@ -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<
|
||||
|
||||
59
include/boost/pending/integer_range.hpp
Normal file
59
include/boost/pending/integer_range.hpp
Normal file
@ -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_
|
||||
@ -43,6 +43,5 @@ test-suite iterator
|
||||
[ run iterator_traits_test.cpp ]
|
||||
[ run permutation_iterator_test.cpp : : : # <stlport-iostream>on
|
||||
]
|
||||
[ run function_input_iterator_test.cpp ]
|
||||
|
||||
;
|
||||
|
||||
@ -1,70 +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 <boost/iterator/function_input_iterator.hpp>
|
||||
#include <vector>
|
||||
#include <iterator>
|
||||
#include <cassert>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
|
||||
struct ones {
|
||||
typedef int result_type;
|
||||
result_type operator() () {
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
int ones_function () {
|
||||
return 1;
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -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();
|
||||
}
|
||||
|
||||
@ -102,17 +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 F, class T> struct result<F(T& )> {typedef T type;};
|
||||
template <class F, class T> struct result<F(const T&)> {typedef T type;};
|
||||
|
||||
template <class T>
|
||||
T operator()(const T& _arg) const {return _arg*2;}
|
||||
};
|
||||
|
||||
int
|
||||
main()
|
||||
@ -255,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();
|
||||
}
|
||||
|
||||
@ -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"
|
||||
|
||||
Reference in New Issue
Block a user