forked from boostorg/iterator
Compare commits
7 Commits
boost-1.65
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| 5b9f37973b | |||
| e9df461e61 | |||
| 8f93bbdf54 | |||
| 4f2ba1aefe | |||
| acaeec5640 | |||
| b6317294cc | |||
| ec9b0b667d |
40
.travis.yml
40
.travis.yml
@ -1,40 +0,0 @@
|
||||
# Copyright 2016 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
|
||||
language: cpp
|
||||
|
||||
sudo: false
|
||||
|
||||
python: "2.7"
|
||||
|
||||
os:
|
||||
- linux
|
||||
- osx
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
|
||||
install:
|
||||
- cd ..
|
||||
- git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
- cd boost-root
|
||||
- git submodule update --init --depth 1 tools/build
|
||||
- git submodule update --init --depth 1 libs/config
|
||||
- git submodule update --init --depth 1 tools/boostdep
|
||||
- cp -r $TRAVIS_BUILD_DIR/* libs/iterator
|
||||
- python tools/boostdep/depinst/depinst.py iterator
|
||||
- ./bootstrap.sh
|
||||
- ./b2 headers
|
||||
|
||||
script:
|
||||
- TOOLSET=gcc,clang
|
||||
- if [ $TRAVIS_OS_NAME == osx ]; then TOOLSET=clang; fi
|
||||
- ./b2 --verbose-test libs/config/test//config_info toolset=$TOOLSET || true
|
||||
- ./b2 libs/iterator/test toolset=$TOOLSET
|
||||
|
||||
notifications:
|
||||
email:
|
||||
on_success: always
|
||||
0
doc/BidirectionalTraversal.rst
Normal file → Executable file
0
doc/BidirectionalTraversal.rst
Normal file → Executable file
0
doc/ForwardTraversal.rst
Normal file → Executable file
0
doc/ForwardTraversal.rst
Normal file → Executable file
0
doc/GNUmakefile
Normal file → Executable file
0
doc/GNUmakefile
Normal file → Executable file
0
doc/IncrementableIterator.rst
Normal file → Executable file
0
doc/IncrementableIterator.rst
Normal file → Executable file
@ -13,15 +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
|
||||
;
|
||||
|
||||
###############################################################################
|
||||
alias boostdoc ;
|
||||
explicit boostdoc ;
|
||||
alias boostrelease : standalone ;
|
||||
explicit boostrelease ;
|
||||
|
||||
0
doc/LvalueIterator.rst
Normal file → Executable file
0
doc/LvalueIterator.rst
Normal file → Executable file
0
doc/ReadableIterator.rst
Normal file → Executable file
0
doc/ReadableIterator.rst
Normal file → Executable file
0
doc/SinglePassIterator.rst
Normal file → Executable file
0
doc/SinglePassIterator.rst
Normal file → Executable file
0
doc/SwappableIterator.rst
Normal file → Executable file
0
doc/SwappableIterator.rst
Normal file → Executable file
0
doc/WritableIterator.rst
Normal file → Executable file
0
doc/WritableIterator.rst
Normal file → Executable file
0
doc/counting_iterator.pdf
Normal file → Executable file
0
doc/counting_iterator.pdf
Normal file → Executable file
0
doc/docutils.sty
Normal file → Executable file
0
doc/docutils.sty
Normal file → Executable file
18
doc/facade-and-adaptor.html
Normal file → Executable file
18
doc/facade-and-adaptor.html
Normal file → Executable file
@ -26,7 +26,7 @@
|
||||
Lab</a>, <a class="last reference external" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></td></tr>
|
||||
<tr><th class="docinfo-name">Date:</th>
|
||||
<td>2006-09-11</td></tr>
|
||||
<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html">N1530</a>=03-0113, which was
|
||||
<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html">N1530</a>=03-0113, which was
|
||||
accepted for Technical Report 1 by the C++ standard
|
||||
committee's library working group.</td>
|
||||
</tr>
|
||||
@ -239,29 +239,29 @@ Iterator Concepts.</p>
|
||||
<div class="section" id="iterator-concepts">
|
||||
<h2><a class="toc-backref" href="#id18">Iterator Concepts</a></h2>
|
||||
<p>This proposal is formulated in terms of the new <tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">concepts</span></tt>
|
||||
as proposed in <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>, since user-defined and especially adapted
|
||||
as proposed in <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>, since user-defined and especially adapted
|
||||
iterators suffer from the well known categorization problems that are
|
||||
inherent to the current iterator categories.</p>
|
||||
<p>This proposal does not strictly depend on proposal <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>, as there
|
||||
<p>This proposal does not strictly depend on proposal <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>, as there
|
||||
is a direct mapping between new and old categories. This proposal
|
||||
could be reformulated using this mapping if <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a> was not accepted.</p>
|
||||
could be reformulated using this mapping if <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a> was not accepted.</p>
|
||||
</div>
|
||||
<div class="section" id="interoperability">
|
||||
<h2><a class="toc-backref" href="#id19">Interoperability</a></h2>
|
||||
<p>The question of iterator interoperability is poorly addressed in the
|
||||
current standard. There are currently two defect reports that are
|
||||
concerned with interoperability issues.</p>
|
||||
<p>Issue <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a> concerns the fact that mutable container iterator types
|
||||
<p>Issue <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a> concerns the fact that mutable container iterator types
|
||||
are only required to be convertible to the corresponding constant
|
||||
iterator types, but objects of these types are not required to
|
||||
interoperate in comparison or subtraction expressions. This situation
|
||||
is tedious in practice and out of line with the way built in types
|
||||
work. This proposal implements the proposed resolution to issue
|
||||
<a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>, as most standard library implementations do nowadays. In other
|
||||
<a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>, as most standard library implementations do nowadays. In other
|
||||
words, if an iterator type A has an implicit or user defined
|
||||
conversion to an iterator type B, the iterator types are interoperable
|
||||
and the usual set of operators are available.</p>
|
||||
<p>Issue <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#280">280</a> concerns the current lack of interoperability between
|
||||
<p>Issue <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280">280</a> concerns the current lack of interoperability between
|
||||
reverse iterator types. The proposed new reverse_iterator template
|
||||
fixes the issues raised in 280. It provides the desired
|
||||
interoperability without introducing unwanted overloads.</p>
|
||||
@ -422,8 +422,8 @@ member (e.g. <a class="reference internal" href="#counting"><tt class="docutils
|
||||
into the temporary iterator <tt class="docutils literal"><span class="pre">p+n</span></tt>, which is destroyed when
|
||||
<tt class="docutils literal"><span class="pre">operator[]</span></tt> returns.</p>
|
||||
<p>Writable iterators built with <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> implement the
|
||||
semantics required by the preferred resolution to <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
|
||||
adopted by proposal <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
|
||||
semantics required by the preferred resolution to <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
|
||||
adopted by proposal <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
|
||||
convertible to the iterator's <tt class="docutils literal"><span class="pre">value_type</span></tt>, and <tt class="docutils literal"><span class="pre">p[n]</span> <span class="pre">=</span> <span class="pre">x</span></tt> is
|
||||
equivalent to <tt class="docutils literal"><span class="pre">*(p</span> <span class="pre">+</span> <span class="pre">n)</span> <span class="pre">=</span> <span class="pre">x</span></tt> (Note: This result object may be
|
||||
implemented as a proxy containing a copy of <tt class="docutils literal"><span class="pre">p+n</span></tt>). This approach
|
||||
|
||||
0
doc/facade-and-adaptor.pdf
Normal file → Executable file
0
doc/facade-and-adaptor.pdf
Normal file → Executable file
@ -19,7 +19,7 @@
|
||||
.. Version 1.9 of this ReStructuredText document corresponds to
|
||||
n1530_, the paper accepted by the LWG.
|
||||
|
||||
.. _n1530: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html
|
||||
.. _n1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
|
||||
|
||||
:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.
|
||||
|
||||
@ -140,7 +140,7 @@ as proposed in n1550_, since user-defined and especially adapted
|
||||
iterators suffer from the well known categorization problems that are
|
||||
inherent to the current iterator categories.
|
||||
|
||||
.. _n1550: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm
|
||||
.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
|
||||
|
||||
This proposal does not strictly depend on proposal n1550_, as there
|
||||
is a direct mapping between new and old categories. This proposal
|
||||
@ -169,8 +169,8 @@ reverse iterator types. The proposed new reverse_iterator template
|
||||
fixes the issues raised in 280. It provides the desired
|
||||
interoperability without introducing unwanted overloads.
|
||||
|
||||
.. _179: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179
|
||||
.. _280: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#280
|
||||
.. _179: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179
|
||||
.. _280: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280
|
||||
|
||||
|
||||
Iterator Facade
|
||||
|
||||
0
doc/facade_iterator_category.rst
Normal file → Executable file
0
doc/facade_iterator_category.rst
Normal file → Executable file
0
doc/filter_iterator.pdf
Normal file → Executable file
0
doc/filter_iterator.pdf
Normal file → Executable file
@ -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,132 +0,0 @@
|
||||
:Author:
|
||||
`Dean Michael Berris <mailto:me@deanberris.com>`_
|
||||
|
||||
:License:
|
||||
Distributed under the Boost Software License, Version 1.0
|
||||
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
:Copyright:
|
||||
Copyright 2012 Google, Inc.
|
||||
|
||||
Function Input Iterator
|
||||
=======================
|
||||
|
||||
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
|
||||
|
||||
The Function Input Iterator takes a function that models the Generator_ concept
|
||||
(which is basically a nullary or 0-arity function object). The first dereference
|
||||
of the iterator at a given position invokes the generator function and stores
|
||||
and returns the result; subsequent dereferences at the same position simply
|
||||
return the same stored result. Incrementing the iterator places it at a new
|
||||
position, hence a subsequent dereference will generate a new value via another
|
||||
invokation of the generator function. This ensures the generator function is
|
||||
invoked precisely when the iterator is requested to return a (new) value.
|
||||
|
||||
.. _Generator: http://www.sgi.com/tech/stl/Generator.html
|
||||
|
||||
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, State s);
|
||||
|
||||
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>(cout, " ")
|
||||
);
|
||||
|
||||
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.
|
||||
|
||||
|
||||
0
doc/function_output_iterator.pdf
Normal file → Executable file
0
doc/function_output_iterator.pdf
Normal file → Executable file
@ -1,163 +0,0 @@
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
||||
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="Content-Language" content="en-us">
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
|
||||
|
||||
<title>Generator Iterator Adaptor Documentation</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
<img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle"
|
||||
width="277" height="86">
|
||||
|
||||
<h1>Generator Iterator Adaptor</h1>
|
||||
|
||||
<p>Defined in header <a href=
|
||||
"../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>
|
||||
|
||||
<p>The generator iterator adaptor makes it easier to create custom input
|
||||
iterators from 0-ary functions and function objects. The adaptor takes a
|
||||
<a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> and
|
||||
creates a model of <a href=
|
||||
"http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>. Each
|
||||
increment retrieves an item from the generator and makes it available to be
|
||||
retrieved by dereferencing. The motivation for this iterator is that some
|
||||
concepts can be more naturally expressed as a generator, while most STL
|
||||
algorithms expect an iterator. An example is the <a href=
|
||||
"../random/index.html">Random Number</a> library.</p>
|
||||
|
||||
<h2>Synopsis</h2>
|
||||
|
||||
<blockquote>
|
||||
<pre>
|
||||
namespace boost {
|
||||
template <class Generator>
|
||||
class generator_iterator_policies;
|
||||
|
||||
template <class Generator>
|
||||
class generator_iterator_generator;
|
||||
|
||||
template <class Generator>
|
||||
typename generator_iterator_generator<Generator>::type
|
||||
make_generator_iterator(Generator & gen);
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
<hr>
|
||||
|
||||
<h2>The Generator Iterator Generator Class</h2>
|
||||
|
||||
<p>The class generator_iterator_generator is a helper class whose purpose
|
||||
is to construct a generator iterator type. The template parameter for this
|
||||
class is the Generator function object type that is being wrapped. The
|
||||
generator iterator adaptor only holds a reference (or pointer) to the
|
||||
function object, therefore the function object must outlive the generator
|
||||
iterator adaptor constructed from it.</p>
|
||||
<pre>
|
||||
template <class Generator>
|
||||
class generator_iterator_generator
|
||||
{
|
||||
public:
|
||||
typedef <i>unspecified</i> type; // the resulting generator iterator type
|
||||
}
|
||||
</pre>
|
||||
|
||||
<h3>Template Parameters</h3>
|
||||
|
||||
<table border summary="">
|
||||
<tr>
|
||||
<th>Parameter</th>
|
||||
|
||||
<th>Description</th>
|
||||
</tr>
|
||||
|
||||
<tr>
|
||||
<td><tt><a href=
|
||||
"http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>
|
||||
|
||||
<td>The generator (0-ary function object) type being wrapped. The
|
||||
return type of the function must be defined as
|
||||
<tt>Generator::result_type</tt>. The function object must be a model of
|
||||
<a href=
|
||||
"http://www.sgi.com/tech/stl/Generator.html">Generator</a>.</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h3>Concept Model</h3>
|
||||
|
||||
<p>The generator iterator class is a model of <a href=
|
||||
"http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.</p>
|
||||
|
||||
<h3>Members</h3>
|
||||
|
||||
<p>The generator iterator implements the member functions and operators
|
||||
required of the <a href=
|
||||
"http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
|
||||
concept.<br></p>
|
||||
<hr>
|
||||
|
||||
<h2><a name="make_generator_iterator" id="make_generator_iterator">The
|
||||
Generator Iterator Object Generator</a></h2>
|
||||
|
||||
<p>The <tt>make_generator_iterator()</tt> function provides a convenient
|
||||
way to create generator iterator objects. The function saves the user the
|
||||
trouble of explicitly writing out the iterator types.</p>
|
||||
|
||||
<blockquote>
|
||||
<pre>
|
||||
template <class Generator>
|
||||
typename generator_iterator_generator<Generator>::type
|
||||
make_generator_iterator(Generator & gen);
|
||||
</pre>
|
||||
</blockquote>
|
||||
<hr>
|
||||
|
||||
<h3>Example</h3>
|
||||
|
||||
<p>The following program shows how <code>generator_iterator</code>
|
||||
transforms a generator into an input iterator.</p>
|
||||
|
||||
<blockquote>
|
||||
<pre>
|
||||
#include <iostream>
|
||||
#include <boost/generator_iterator.hpp>
|
||||
|
||||
class my_generator
|
||||
{
|
||||
public:
|
||||
typedef int result_type;
|
||||
my_generator() : state(0) { }
|
||||
int operator()() { return ++state; }
|
||||
private:
|
||||
int state;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
my_generator gen;
|
||||
boost::generator_iterator_generator<my_generator>::type it = boost::make_generator_iterator(gen);
|
||||
for(int i = 0; i < 10; ++i, ++it)
|
||||
std::cout << *it << std::endl;
|
||||
}
|
||||
</pre>
|
||||
</blockquote>
|
||||
<hr>
|
||||
|
||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
||||
height="31" width="88"></a></p>
|
||||
|
||||
<p>Revised
|
||||
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
|
||||
|
||||
<p><i>Copyright © 2001 <a href=
|
||||
"http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a></i></p>
|
||||
|
||||
<p><i>Distributed under the Boost Software License, Version 1.0. (See
|
||||
accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
|
||||
copy at <a href=
|
||||
"http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
|
||||
</body>
|
||||
</html>
|
||||
44
doc/index.html
Normal file → Executable file
44
doc/index.html
Normal file → Executable file
@ -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>
|
||||
|
||||
18
doc/index.rst
Normal file → Executable file
18
doc/index.rst
Normal file → Executable file
@ -115,8 +115,8 @@ __ iterator_facade.pdf
|
||||
__ iterator_adaptor.pdf
|
||||
|
||||
Both |facade| and |adaptor| as well as many of the `specialized
|
||||
adaptors`_ mentioned below have been proposed for standardization;
|
||||
see our
|
||||
adaptors`_ mentioned below have been proposed for standardization,
|
||||
and accepted into the first C++ technical report; see our
|
||||
|
||||
`Standard Proposal For Iterator Facade and Adaptor`__ (PDF__)
|
||||
|
||||
@ -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``
|
||||
|
||||
0
doc/indirect_iterator.pdf
Normal file → Executable file
0
doc/indirect_iterator.pdf
Normal file → Executable file
0
doc/indirect_reference_ref.rst
Normal file → Executable file
0
doc/indirect_reference_ref.rst
Normal file → Executable file
0
doc/interoperability-revisited.rst
Normal file → Executable file
0
doc/interoperability-revisited.rst
Normal file → Executable file
2
doc/issues.rst
Normal file → Executable file
2
doc/issues.rst
Normal file → Executable file
@ -3,7 +3,7 @@
|
||||
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
.. _N1550: http://www.boost-consulting.com/writing/n1550.html
|
||||
.. _N1530: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html
|
||||
.. _N1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
|
||||
|
||||
:Author: David Abrahams and Jeremy Siek
|
||||
:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu
|
||||
|
||||
0
doc/iterator_adaptor.pdf
Normal file → Executable file
0
doc/iterator_adaptor.pdf
Normal file → Executable file
0
doc/iterator_adaptor_tutorial.rst
Normal file → Executable file
0
doc/iterator_adaptor_tutorial.rst
Normal file → Executable file
0
doc/iterator_archetypes.html
Normal file → Executable file
0
doc/iterator_archetypes.html
Normal file → Executable file
0
doc/iterator_archetypes.pdf
Normal file → Executable file
0
doc/iterator_archetypes.pdf
Normal file → Executable file
0
doc/iterator_archetypes.rst
Normal file → Executable file
0
doc/iterator_archetypes.rst
Normal file → Executable file
0
doc/iterator_concepts.pdf
Normal file → Executable file
0
doc/iterator_concepts.pdf
Normal file → Executable file
0
doc/iterator_concepts.rst
Normal file → Executable file
0
doc/iterator_concepts.rst
Normal file → Executable file
@ -242,8 +242,8 @@ member (e.g. <a class="reference external" href="counting_iterator.html"><tt cla
|
||||
into the temporary iterator <tt class="docutils literal"><span class="pre">p+n</span></tt>, which is destroyed when
|
||||
<tt class="docutils literal"><span class="pre">operator[]</span></tt> returns.</p>
|
||||
<p>Writable iterators built with <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> implement the
|
||||
semantics required by the preferred resolution to <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
|
||||
adopted by proposal <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
|
||||
semantics required by the preferred resolution to <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
|
||||
adopted by proposal <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
|
||||
convertible to the iterator's <tt class="docutils literal"><span class="pre">value_type</span></tt>, and <tt class="docutils literal"><span class="pre">p[n]</span> <span class="pre">=</span> <span class="pre">x</span></tt> is
|
||||
equivalent to <tt class="docutils literal"><span class="pre">*(p</span> <span class="pre">+</span> <span class="pre">n)</span> <span class="pre">=</span> <span class="pre">x</span></tt> (Note: This result object may be
|
||||
implemented as a proxy containing a copy of <tt class="docutils literal"><span class="pre">p+n</span></tt>). This approach
|
||||
|
||||
0
doc/iterator_facade.pdf
Normal file → Executable file
0
doc/iterator_facade.pdf
Normal file → Executable file
@ -167,9 +167,9 @@ the implementation of her iterator is free to implement an
|
||||
class; it will hide the one supplied by ``iterator_facade`` from
|
||||
clients of her iterator.
|
||||
|
||||
.. _n1550: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm
|
||||
.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
|
||||
|
||||
.. _`issue 299`: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299
|
||||
.. _`issue 299`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299
|
||||
|
||||
.. _`operator arrow`:
|
||||
|
||||
|
||||
@ -106,7 +106,7 @@ The ``iterator_category`` member of ``iterator_facade`` is
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
*iterator-category*\ (CategoryOrTraversal, reference, value_type)
|
||||
*iterator-category*\ (CategoryOrTraversal, value_type, reference)
|
||||
|
||||
where *iterator-category* is defined as follows:
|
||||
|
||||
|
||||
0
doc/iterator_facade_tutorial.rst
Normal file → Executable file
0
doc/iterator_facade_tutorial.rst
Normal file → Executable file
31
doc/iterator_traits.html
Normal file → Executable file
31
doc/iterator_traits.html
Normal file → Executable file
@ -3,11 +3,11 @@
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
||||
<meta name="generator" content="Docutils 0.11: http://docutils.sourceforge.net/" />
|
||||
<meta name="generator" content="Docutils 0.5: http://docutils.sourceforge.net/" />
|
||||
<title>Iterator Traits</title>
|
||||
<meta name="author" content="David Abrahams" />
|
||||
<meta name="organization" content="Boost Consulting" />
|
||||
<meta name="date" content="$Date$" />
|
||||
<meta name="date" content="2006-09-11" />
|
||||
<meta name="copyright" content="Copyright David Abrahams 2004." />
|
||||
<link rel="stylesheet" href="../../../rst.css" type="text/css" />
|
||||
</head>
|
||||
@ -25,7 +25,7 @@
|
||||
<tr><th class="docinfo-name">Organization:</th>
|
||||
<td><a class="first last reference external" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
|
||||
<tr><th class="docinfo-name">Date:</th>
|
||||
<td>$Date$</td></tr>
|
||||
<td>2006-09-11</td></tr>
|
||||
<tr><th class="docinfo-name">Copyright:</th>
|
||||
<td>Copyright David Abrahams 2004.</td></tr>
|
||||
</tbody>
|
||||
@ -37,7 +37,7 @@
|
||||
<col class="field-name" />
|
||||
<col class="field-body" />
|
||||
<tbody valign="top">
|
||||
<tr class="field"><th class="field-name">abstract:</th><td class="field-body">Header <tt class="docutils literal"><boost/iterator/iterator_traits.hpp></tt> provides
|
||||
<tr class="field"><th class="field-name">abstract:</th><td class="field-body">Header <tt class="docutils literal"><span class="pre"><boost/iterator/iterator_traits.hpp></span></tt> provides
|
||||
the ability to access an iterator's associated types using
|
||||
MPL-compatible <a class="reference external" href="../../mpl/doc/index.html#metafunctions">metafunctions</a>.</td>
|
||||
</tr>
|
||||
@ -46,15 +46,15 @@ MPL-compatible <a class="reference external" href="../../mpl/doc/index.html#meta
|
||||
<div class="section" id="overview">
|
||||
<h1>Overview</h1>
|
||||
<p><tt class="docutils literal"><span class="pre">std::iterator_traits</span></tt> provides access to five associated types
|
||||
of any iterator: its <tt class="docutils literal">value_type</tt>, <tt class="docutils literal">reference</tt>, <tt class="docutils literal">pointer</tt>,
|
||||
<tt class="docutils literal">iterator_category</tt>, and <tt class="docutils literal">difference_type</tt>. Unfortunately,
|
||||
of any iterator: its <tt class="docutils literal"><span class="pre">value_type</span></tt>, <tt class="docutils literal"><span class="pre">reference</span></tt>, <tt class="docutils literal"><span class="pre">pointer</span></tt>,
|
||||
<tt class="docutils literal"><span class="pre">iterator_category</span></tt>, and <tt class="docutils literal"><span class="pre">difference_type</span></tt>. Unfortunately,
|
||||
such a "multi-valued" traits template can be difficult to use in a
|
||||
metaprogramming context. <tt class="docutils literal"><boost/iterator/iterator_traits.hpp></tt>
|
||||
metaprogramming context. <tt class="docutils literal"><span class="pre"><boost/iterator/iterator_traits.hpp></span></tt>
|
||||
provides access to these types using a standard <a class="reference external" href="../../mpl/doc/index.html#metafunctions">metafunctions</a>.</p>
|
||||
</div>
|
||||
<div class="section" id="summary">
|
||||
<h1>Summary</h1>
|
||||
<p>Header <tt class="docutils literal"><boost/iterator/iterator_traits.hpp></tt>:</p>
|
||||
<p>Header <tt class="docutils literal"><span class="pre"><boost/iterator/iterator_traits.hpp></span></tt>:</p>
|
||||
<pre class="literal-block">
|
||||
template <class Iterator>
|
||||
struct iterator_value
|
||||
@ -98,6 +98,21 @@ struct iterator_category
|
||||
};
|
||||
</pre>
|
||||
</div>
|
||||
<div class="section" id="broken-compiler-notes">
|
||||
<h1>Broken Compiler Notes</h1>
|
||||
<p>Because of workarounds in Boost, you may find that these
|
||||
<a class="reference external" href="../../mpl/doc/index.html#metafunctions">metafunctions</a> actually work better than the facilities provided by
|
||||
your compiler's standard library.</p>
|
||||
<p>On compilers that don't support partial specialization, such as
|
||||
Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
|
||||
<a class="reference external" href="../../type_traits/index.html#transformations">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</a> on the
|
||||
<tt class="docutils literal"><span class="pre">value_type</span></tt> of pointers that are passed to these metafunctions.</p>
|
||||
<p>Because of bugs in the implementation of GCC-2.9x, the name of
|
||||
<tt class="docutils literal"><span class="pre">iterator_category</span></tt> is changed to <tt class="docutils literal"><span class="pre">iterator_category_</span></tt> on that
|
||||
compiler. A macro, <tt class="docutils literal"><span class="pre">BOOST_ITERATOR_CATEGORY</span></tt>, that expands to
|
||||
either <tt class="docutils literal"><span class="pre">iterator_category</span></tt> or <tt class="docutils literal"><span class="pre">iterator_category_</span></tt>, as
|
||||
appropriate to the platform, is provided for portability.</p>
|
||||
</div>
|
||||
</div>
|
||||
<div class="footer">
|
||||
<hr class="footer" />
|
||||
|
||||
0
doc/iterator_traits.pdf
Normal file → Executable file
0
doc/iterator_traits.pdf
Normal file → Executable file
21
doc/iterator_traits.rst
Normal file → Executable file
21
doc/iterator_traits.rst
Normal file → Executable file
@ -75,3 +75,24 @@ Header ``<boost/iterator/iterator_traits.hpp>``::
|
||||
detail::iterator_traits<Iterator>::iterator_category
|
||||
type;
|
||||
};
|
||||
|
||||
Broken Compiler Notes
|
||||
=====================
|
||||
|
||||
Because of workarounds in Boost, you may find that these
|
||||
metafunctions_ actually work better than the facilities provided by
|
||||
your compiler's standard library.
|
||||
|
||||
On compilers that don't support partial specialization, such as
|
||||
Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION_ on the
|
||||
``value_type`` of pointers that are passed to these metafunctions.
|
||||
|
||||
Because of bugs in the implementation of GCC-2.9x, the name of
|
||||
``iterator_category`` is changed to ``iterator_category_`` on that
|
||||
compiler. A macro, ``BOOST_ITERATOR_CATEGORY``, that expands to
|
||||
either ``iterator_category`` or ``iterator_category_``, as
|
||||
appropriate to the platform, is provided for portability.
|
||||
|
||||
.. _BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION: ../../type_traits/index.html#transformations
|
||||
|
||||
|
||||
0
doc/make_counting_iterator.rst
Normal file → Executable file
0
doc/make_counting_iterator.rst
Normal file → Executable file
0
doc/make_filter_iterator.rst
Normal file → Executable file
0
doc/make_filter_iterator.rst
Normal file → Executable file
0
doc/make_transform_iterator.rst
Normal file → Executable file
0
doc/make_transform_iterator.rst
Normal file → Executable file
0
doc/make_zip_iterator.rst
Normal file → Executable file
0
doc/make_zip_iterator.rst
Normal file → Executable file
16
doc/new-iter-concepts.html
Normal file → Executable file
16
doc/new-iter-concepts.html
Normal file → Executable file
@ -27,10 +27,10 @@
|
||||
Lab</a>, <a class="last reference external" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></td></tr>
|
||||
<tr><th class="docinfo-name">Date:</th>
|
||||
<td>2006-09-11</td></tr>
|
||||
<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1550.htm">n1550</a>=03-0133, which was
|
||||
<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1550.html">n1550</a>=03-0133, which was
|
||||
accepted for Technical Report 1 by the C++ standard
|
||||
committee's library working group. This proposal is a
|
||||
revision of paper <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2001/n1297.html">n1297</a>, <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1477.html">n1477</a>, and <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1531.html">n1531</a>.</td>
|
||||
revision of paper <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2001/n1297.html">n1297</a>, <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1477.html">n1477</a>, and <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1531.html">n1531</a>.</td>
|
||||
</tr>
|
||||
<tr><th class="docinfo-name">Copyright:</th>
|
||||
<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt
|
||||
@ -127,12 +127,12 @@ requirements in the iterator categories.</p>
|
||||
<td><tt class="docutils literal"><span class="pre">*i</span></tt> is convertible to <tt class="docutils literal"><span class="pre">T</span></tt></td>
|
||||
</tr>
|
||||
<tr><td>Forward Iterator</td>
|
||||
<td><tt class="docutils literal"><span class="pre">*i</span></tt> is <tt class="docutils literal"><span class="pre">T&</span></tt> (or <tt class="docutils literal"><span class="pre">const</span> <span class="pre">T&</span></tt> once <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 200</a>
|
||||
<td><tt class="docutils literal"><span class="pre">*i</span></tt> is <tt class="docutils literal"><span class="pre">T&</span></tt> (or <tt class="docutils literal"><span class="pre">const</span> <span class="pre">T&</span></tt> once <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 200</a>
|
||||
is resolved)</td>
|
||||
</tr>
|
||||
<tr><td>Random Access Iterator</td>
|
||||
<td><tt class="docutils literal"><span class="pre">i[n]</span></tt> is convertible to <tt class="docutils literal"><span class="pre">T</span></tt> (also <tt class="docutils literal"><span class="pre">i[n]</span> <span class="pre">=</span> <span class="pre">t</span></tt>
|
||||
is required for mutable iterators once <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>
|
||||
is required for mutable iterators once <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>
|
||||
is resolved)</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
@ -141,7 +141,7 @@ is resolved)</td>
|
||||
single hierarchy, many useful iterators can not be appropriately
|
||||
categorized. For example, <tt class="docutils literal"><span class="pre">vector<bool>::iterator</span></tt> is almost a
|
||||
random access iterator, but the return type is not <tt class="docutils literal"><span class="pre">bool&</span></tt> (see
|
||||
<a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 96</a> and Herb Sutter's paper J16/99-0008 = WG21
|
||||
<a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 96</a> and Herb Sutter's paper J16/99-0008 = WG21
|
||||
N1185). Therefore, the iterators of <tt class="docutils literal"><span class="pre">vector<bool></span></tt> only meet the
|
||||
requirements of input iterator and output iterator. This is so
|
||||
nonintuitive that the C++ standard contradicts itself on this point.
|
||||
@ -344,7 +344,7 @@ approach for specifying <tt class="docutils literal"><span class="pre">operator[
|
||||
direction would mean that an iterator satisfying the old Random Access
|
||||
Iterator requirements would not necessarily be a model of Readable or
|
||||
Writable Lvalue Iterator. Instead we have chosen a design that
|
||||
matches the preferred resolution of <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>: <tt class="docutils literal"><span class="pre">operator[]</span></tt> is
|
||||
matches the preferred resolution of <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>: <tt class="docutils literal"><span class="pre">operator[]</span></tt> is
|
||||
only required to return something convertible to the <tt class="docutils literal"><span class="pre">value_type</span></tt>
|
||||
(for a Readable Iterator), and is required to support assignment
|
||||
<tt class="docutils literal"><span class="pre">i[n]</span> <span class="pre">=</span> <span class="pre">t</span></tt> (for a Writable Iterator).</p>
|
||||
@ -976,7 +976,7 @@ struct random_access_traversal_tag : bidirectional_traversal_tag { };
|
||||
<div class="section" id="addition-to-lib-iterator-traits">
|
||||
<h2><a class="toc-backref" href="#id23">Addition to [lib.iterator.traits]</a></h2>
|
||||
<p>The <tt class="docutils literal"><span class="pre">is_readable_iterator</span></tt> class
|
||||
template satisfies the <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">UnaryTypeTrait</a> requirements.</p>
|
||||
template satisfies the <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">UnaryTypeTrait</a> requirements.</p>
|
||||
<p>Given an iterator type <tt class="docutils literal"><span class="pre">X</span></tt>, <tt class="docutils literal"><span class="pre">is_readable_iterator<X>::value</span></tt>
|
||||
yields <tt class="docutils literal"><span class="pre">true</span></tt> if, for an object <tt class="docutils literal"><span class="pre">a</span></tt> of type <tt class="docutils literal"><span class="pre">X</span></tt>, <tt class="docutils literal"><span class="pre">*a</span></tt> is
|
||||
convertible to <tt class="docutils literal"><span class="pre">iterator_traits<X>::value_type</span></tt>, and <tt class="docutils literal"><span class="pre">false</span></tt>
|
||||
@ -1007,7 +1007,7 @@ otherwise.</p>
|
||||
</div>
|
||||
<div class="section" id="footnotes">
|
||||
<h1><a class="toc-backref" href="#id24">Footnotes</a></h1>
|
||||
<p>The UnaryTypeTrait concept is defined in <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">n1519</a>; the LWG is
|
||||
<p>The UnaryTypeTrait concept is defined in <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">n1519</a>; the LWG is
|
||||
considering adding the requirement that specializations are derived
|
||||
from their nested <tt class="docutils literal"><span class="pre">::type</span></tt>.</p>
|
||||
<!-- LocalWords: Abrahams Siek Witt const bool Sutter's WG int UL LI href Lvalue
|
||||
|
||||
0
doc/new-iter-concepts.pdf
Normal file → Executable file
0
doc/new-iter-concepts.pdf
Normal file → Executable file
@ -38,10 +38,10 @@
|
||||
|
||||
.. contents:: Table of Contents
|
||||
|
||||
.. _n1297: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2001/n1297.html
|
||||
.. _n1477: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1477.html
|
||||
.. _n1531: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1531.html
|
||||
.. _n1550: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1550.htm
|
||||
.. _n1297: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2001/n1297.html
|
||||
.. _n1477: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1477.html
|
||||
.. _n1531: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1531.html
|
||||
.. _n1550: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1550.html
|
||||
|
||||
============
|
||||
Motivation
|
||||
@ -76,8 +76,8 @@ requirements in the iterator categories.
|
||||
| |is resolved) |
|
||||
+------------------------+-----------------------------------------------------+
|
||||
|
||||
.. _issue 200: http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#200
|
||||
.. _issue 299: http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#299
|
||||
.. _issue 200: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#200
|
||||
.. _issue 299: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299
|
||||
|
||||
|
||||
Because iterator traversal and value access are mixed together in a
|
||||
@ -91,7 +91,7 @@ nonintuitive that the C++ standard contradicts itself on this point.
|
||||
In paragraph 23.2.4/1 it says that a ``vector`` is a sequence that
|
||||
supports random access iterators.
|
||||
|
||||
.. _issue 96: http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#96
|
||||
.. _issue 96: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96
|
||||
|
||||
Another difficult-to-categorize iterator is the transform iterator, an
|
||||
adaptor which applies a unary function object to the dereferenced
|
||||
@ -791,7 +791,7 @@ The UnaryTypeTrait concept is defined in n1519_; the LWG is
|
||||
considering adding the requirement that specializations are derived
|
||||
from their nested ``::type``.
|
||||
|
||||
.. _n1519: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1519.htm
|
||||
.. _n1519: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm
|
||||
|
||||
..
|
||||
LocalWords: Abrahams Siek Witt const bool Sutter's WG int UL LI href Lvalue
|
||||
|
||||
0
doc/permutation_iterator.pdf
Normal file → Executable file
0
doc/permutation_iterator.pdf
Normal file → Executable file
0
doc/pointee.html
Normal file → Executable file
0
doc/pointee.html
Normal file → Executable file
0
doc/pointee.pdf
Normal file → Executable file
0
doc/pointee.pdf
Normal file → Executable file
0
doc/pointee.rst
Normal file → Executable file
0
doc/pointee.rst
Normal file → Executable file
0
doc/pointee_ref.rst
Normal file → Executable file
0
doc/pointee_ref.rst
Normal file → Executable file
@ -132,7 +132,7 @@ above are defined as follows:
|
||||
|
||||
iterator_adaptor();
|
||||
|
||||
[*Requires:] The `Base` type must be Default Constructible.[br]
|
||||
[*Requires:] The `Base` type must be Default Constructible.\n
|
||||
[*Returns:] An instance of `iterator_adaptor` with
|
||||
`m_iterator` default constructed.
|
||||
|
||||
@ -206,7 +206,7 @@ we're going to pick up right where it left off.
|
||||
.. |fac_tut| replace:: `iterator_facade` tutorial
|
||||
.. _fac_tut: iterator_facade.html#tutorial-example
|
||||
|
||||
[blurb [*`node_base*` really *is* an iterator][br][br]
|
||||
[blurb [*`node_base*` really *is* an iterator]\n\n
|
||||
It's not really a very interesting iterator, since `node_base`
|
||||
is an abstract class: a pointer to a `node_base` just points
|
||||
at some base subobject of an instance of some other class, and
|
||||
|
||||
@ -156,7 +156,7 @@ semantics.
|
||||
[
|
||||
[`++r`]
|
||||
[`X&`]
|
||||
[pre:[br]`r` is dereferenceable;[br]post:[br]`r` is dereferenceable or[br]`r` is past-the-end]
|
||||
[pre:\n`r` is dereferenceable;\npost:\n`r` is dereferenceable or\n`r` is past-the-end]
|
||||
]
|
||||
[
|
||||
[`a == b`]
|
||||
@ -227,7 +227,7 @@ the stated semantics.
|
||||
[
|
||||
[`--r`]
|
||||
[`X&`]
|
||||
[pre: there exists `s` such that `r == ++s`.[br] post: `s` is dereferenceable. `--(++r) == r`. `--r == --s` implies `r == s`. `&r == &--r`.]
|
||||
[pre: there exists `s` such that `r == ++s`.\n post: `s` is dereferenceable. `--(++r) == r`. `--r == --s` implies `r == s`. `&r == &--r`.]
|
||||
]
|
||||
[
|
||||
[`r--`]
|
||||
|
||||
@ -152,7 +152,7 @@ operations.
|
||||
|
||||
counting_iterator();
|
||||
|
||||
[*Requires: ] `Incrementable` is Default Constructible.[br]
|
||||
[*Requires: ] `Incrementable` is Default Constructible.\n
|
||||
[*Effects: ] Default construct the member `m_inc`.
|
||||
|
||||
|
||||
@ -174,13 +174,13 @@ operations.
|
||||
|
||||
counting_iterator& operator++();
|
||||
|
||||
[*Effects: ] `++m_inc`[br]
|
||||
[*Effects: ] `++m_inc`\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
|
||||
counting_iterator& operator--();
|
||||
|
||||
[*Effects: ] `--m_inc`[br]
|
||||
[*Effects: ] `--m_inc`\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
|
||||
|
||||
@ -68,7 +68,6 @@ requirements.
|
||||
[
|
||||
[`i.dereference()`]
|
||||
[Access the value referred to]
|
||||
]
|
||||
[
|
||||
[`i.equal(j)`]
|
||||
[Compare for equality with `j`]
|
||||
@ -84,7 +83,6 @@ requirements.
|
||||
[
|
||||
[`i.advance(n)`]
|
||||
[Advance by `n` positions]
|
||||
]
|
||||
[
|
||||
[`i.distance_to(j)`]
|
||||
[Measure the distance to `j`]
|
||||
@ -167,9 +165,9 @@ the implementation of her iterator is free to implement an
|
||||
class; it will hide the one supplied by `iterator_facade` from
|
||||
clients of her iterator.
|
||||
|
||||
.. _n1550: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm
|
||||
.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
|
||||
|
||||
.. _`issue 299`: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299
|
||||
.. _`issue 299`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299
|
||||
|
||||
.. _`operator arrow`:
|
||||
|
||||
@ -489,8 +487,7 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
|
||||
|
||||
[*Returns:]
|
||||
|
||||
[pre
|
||||
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
@ -498,7 +495,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).equal((Dr1 const&)lhs)`.
|
||||
]
|
||||
|
||||
|
||||
template <class Dr1, class V1, class TC1, class R1, class D1,
|
||||
@ -509,7 +505,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
[*Returns:]
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
@ -517,7 +512,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
Otherwise,
|
||||
`!((Dr2 const&)rhs).equal((Dr1 const&)lhs)`.
|
||||
]
|
||||
|
||||
|
||||
template <class Dr1, class V1, class TC1, class R1, class D1,
|
||||
@ -528,7 +522,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
[*Returns:]
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
@ -536,7 +529,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) > 0`.
|
||||
]
|
||||
|
||||
|
||||
template <class Dr1, class V1, class TC1, class R1, class D1,
|
||||
@ -547,7 +539,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
[*Returns:]
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
@ -555,7 +546,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) >= 0`.
|
||||
]
|
||||
|
||||
|
||||
template <class Dr1, class V1, class TC1, class R1, class D1,
|
||||
@ -566,7 +556,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
[*Returns:]
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
@ -574,7 +563,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) < 0`.
|
||||
]
|
||||
|
||||
|
||||
template <class Dr1, class V1, class TC1, class R1, class D1,
|
||||
@ -585,7 +573,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
[*Returns:]
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
@ -593,7 +580,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) <= 0`.
|
||||
]
|
||||
|
||||
.. _minus:
|
||||
|
||||
@ -606,7 +592,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
[*Return Type:]
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
@ -615,11 +600,9 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
Otherwise
|
||||
`difference` shall be `iterator_traits<Dr2>::difference_type`
|
||||
]
|
||||
|
||||
[*Returns:]
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
@ -627,7 +610,6 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs)`.
|
||||
]
|
||||
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -261,17 +261,17 @@ __ ../example/node_iterator1.cpp
|
||||
|
||||
[h2 A constant `node_iterator`]
|
||||
|
||||
[blurb *Constant and Mutable iterators*[br][br]
|
||||
[blurb *Constant and Mutable iterators*\n\n
|
||||
The term **mutable iterator** means an iterator through which
|
||||
the object it references (its "referent") can be modified. A
|
||||
**constant iterator** is one which doesn't allow modification of
|
||||
its referent.[br][br]
|
||||
its referent.\n\n
|
||||
The words *constant* and *mutable* don't refer to the ability to
|
||||
modify the iterator itself. For example, an `int const*` is a
|
||||
non-\ `const` *constant iterator*, which can be incremented
|
||||
but doesn't allow modification of its referent, and `int*
|
||||
const` is a `const` *mutable iterator*, which cannot be
|
||||
modified but which allows modification of its referent.[br][br]
|
||||
modified but which allows modification of its referent.\n\n
|
||||
Confusing? We agree, but those are the standard terms. It
|
||||
probably doesn't help much that a container's constant iterator
|
||||
is called `const_iterator`.
|
||||
@ -312,7 +312,7 @@ changes:
|
||||
node_base **const**\ * m_node;
|
||||
};
|
||||
|
||||
[blurb `const` and an iterator's `value_type`[br][br]
|
||||
[blurb `const` and an iterator's `value_type`\n\n
|
||||
The C++ standard requires an iterator's `value_type` *not* be
|
||||
`const`\ -qualified, so `iterator_facade` strips the
|
||||
`const` from its `Value` parameter in order to produce the
|
||||
|
||||
@ -178,7 +178,7 @@ operations.
|
||||
|
||||
filter_iterator();
|
||||
|
||||
[*Requires: ]`Predicate` and `Iterator` must be Default Constructible.[br]
|
||||
[*Requires: ]`Predicate` and `Iterator` must be Default Constructible.\n
|
||||
[*Effects: ] Constructs a `filter_iterator` whose`m_pred`, `m_iter`, and `m_end`
|
||||
members are a default constructed.
|
||||
|
||||
@ -195,7 +195,7 @@ operations.
|
||||
filter_iterator(Iterator x, Iterator end = Iterator());
|
||||
|
||||
[*Requires: ] `Predicate` must be Default Constructible and
|
||||
`Predicate` is a class type (not a function pointer).[br]
|
||||
`Predicate` is a class type (not a function pointer).\n
|
||||
[*Effects: ] Constructs a `filter_iterator` where `m_iter` is either
|
||||
the first position in the range `[x,end)` such that `m_pred(*m_iter) == true`
|
||||
or else`m_iter == end`. The member `m_pred` is default constructed.
|
||||
@ -205,9 +205,9 @@ operations.
|
||||
filter_iterator(
|
||||
filter_iterator<Predicate, OtherIterator> const& t
|
||||
, typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
|
||||
);
|
||||
);`
|
||||
|
||||
[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.[br]
|
||||
[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.\n
|
||||
[*Effects: ] Constructs a filter iterator whose members are copied from `t`.
|
||||
|
||||
|
||||
@ -235,7 +235,7 @@ operations.
|
||||
|
||||
[*Effects: ] Increments `m_iter` and then continues to
|
||||
increment `m_iter` until either `m_iter == m_end`
|
||||
or `m_pred(*m_iter) == true`.[br]
|
||||
or `m_pred(*m_iter) == true`.\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
|
||||
|
||||
@ -203,7 +203,7 @@ following operations:
|
||||
|
||||
indirect_iterator();
|
||||
|
||||
[*Requires: ] `Iterator` must be Default Constructible.[br]
|
||||
[*Requires: ] `Iterator` must be Default Constructible.\n
|
||||
[*Effects: ] Constructs an instance of `indirect_iterator` with
|
||||
a default-constructed `m_iterator`.
|
||||
|
||||
@ -225,7 +225,7 @@ following operations:
|
||||
, typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
|
||||
);
|
||||
|
||||
[*Requires: ] `Iterator2` is implicitly convertible to `Iterator`.[br]
|
||||
[*Requires: ] `Iterator2` is implicitly convertible to `Iterator`.\n
|
||||
[*Effects: ] Constructs an instance of `indirect_iterator` whose
|
||||
`m_iterator` subobject is constructed from `y.base()`.
|
||||
|
||||
@ -242,13 +242,13 @@ following operations:
|
||||
|
||||
indirect_iterator& operator++();
|
||||
|
||||
[*Effects: ] `++m_iterator`[br]
|
||||
[*Effects: ] `++m_iterator`\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
|
||||
indirect_iterator& operator--();
|
||||
|
||||
[*Effects: ] `--m_iterator`[br]
|
||||
[*Effects: ] `--m_iterator`\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
[endsect]
|
||||
@ -1,7 +1,6 @@
|
||||
|
||||
[library Boost.Iterator
|
||||
[/ version 1.0.1]
|
||||
[quickbook 1.6]
|
||||
[authors [Abrahams, David], [Siek, Jeremy], [Witt, Thomas]]
|
||||
[copyright 2003 2005 David Abrahams Jeremy Siek Thomas Witt]
|
||||
[category iterator]
|
||||
@ -100,7 +99,7 @@ adaptors`_ mentioned below have been proposed for standardization
|
||||
|
||||
The iterator library supplies a useful suite of standard-conforming
|
||||
iterator templates based on the Boost [link
|
||||
iterator.intro.iterator_facade_and_adaptor iterator facade and adaptor]
|
||||
intro.iterator_facade_and_adaptor iterator facade and adaptor]
|
||||
templates.
|
||||
|
||||
[def _counting_ [@./counting_iterator.html `counting_iterator`]]
|
||||
|
||||
@ -189,7 +189,7 @@ following operations.
|
||||
|
||||
permutation_iterator& operator++();
|
||||
|
||||
[*Effects: ] `++m_order`[br]
|
||||
[*Effects: ] `++m_order`\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
|
||||
|
||||
@ -115,7 +115,7 @@ operations.
|
||||
|
||||
reverse_iterator();
|
||||
|
||||
[*Requires: ] `Iterator` must be Default Constructible.[br]
|
||||
[*Requires: ] `Iterator` must be Default Constructible.\n
|
||||
[*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator`
|
||||
default constructed.
|
||||
|
||||
@ -131,7 +131,7 @@ operations.
|
||||
, typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
|
||||
);
|
||||
|
||||
[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.[br]
|
||||
[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.\n
|
||||
[*Effects: ] Constructs instance of `reverse_iterator` whose
|
||||
`m_iterator` subobject is constructed from `y.base()`.
|
||||
|
||||
@ -149,12 +149,12 @@ operations.
|
||||
|
||||
reverse_iterator& operator++();
|
||||
|
||||
[*Effects: ] `--m_iterator`[br]
|
||||
[*Effects: ] `--m_iterator`\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
reverse_iterator& operator--();
|
||||
|
||||
[*Effects: ] `++m_iterator`[br]
|
||||
[*Effects: ] `++m_iterator`\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
[endsect]
|
||||
@ -52,4 +52,21 @@ Header `<boost/iterator/iterator_traits.hpp>`:
|
||||
type;
|
||||
};
|
||||
|
||||
[endsect]
|
||||
[h2 Broken Compiler Notes]
|
||||
|
||||
Because of workarounds in Boost, you may find that these
|
||||
[@../../mpl/doc/index.html#metafunctions metafunctions] actually work better than the facilities provided by
|
||||
your compiler's standard library.
|
||||
|
||||
On compilers that don't support partial specialization, such as
|
||||
Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
|
||||
[@../../type_traits/index.html#transformations BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION] on the
|
||||
`value_type` of pointers that are passed to these metafunctions.
|
||||
|
||||
Because of bugs in the implementation of GCC-2.9x, the name of
|
||||
`iterator_category` is changed to `iterator_category_` on that
|
||||
compiler. A macro, `BOOST_ITERATOR_CATEGORY`, that expands to
|
||||
either `iterator_category` or `iterator_category_`, as
|
||||
appropriate to the platform, is provided for portability.
|
||||
|
||||
[endsect]
|
||||
@ -85,7 +85,7 @@ The source code for this example can be found
|
||||
|
||||
|
||||
If `Reference` is `use_default` then the `reference` member of
|
||||
`transform_iterator` is[br]
|
||||
`transform_iterator` is\n
|
||||
`result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
|
||||
Otherwise, `reference` is `Reference`.
|
||||
|
||||
@ -160,7 +160,7 @@ interoperable with `Y`.
|
||||
|
||||
[h3 Operations]
|
||||
|
||||
In addition to the operations required by the [link iterator.specialized.transform.concepts concepts] modeled by
|
||||
In addition to the operations required by the [link transform.concepts concepts] modeled by
|
||||
`transform_iterator`, `transform_iterator` provides the following
|
||||
operations:
|
||||
|
||||
@ -183,7 +183,7 @@ operations:
|
||||
|
||||
[*Returns: ] An instance of `transform_iterator` with `m_f`
|
||||
initialized to `t.functor()` and `m_iterator` initialized to
|
||||
`t.base()`.[br]
|
||||
`t.base()`.\n
|
||||
[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.
|
||||
|
||||
|
||||
@ -204,13 +204,13 @@ operations:
|
||||
|
||||
transform_iterator& operator++();
|
||||
|
||||
[*Effects: ] `++m_iterator`[br]
|
||||
[*Effects: ] `++m_iterator`\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
|
||||
transform_iterator& operator--();
|
||||
|
||||
[*Effects: ] `--m_iterator`[br]
|
||||
[*Effects: ] `--m_iterator`\n
|
||||
[*Returns: ] `*this`
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -49,40 +49,11 @@ proxy references or return the pointee by value. When that
|
||||
information is needed, call on `indirect_reference`.
|
||||
|
||||
Both of these templates are essential to the correct functioning of
|
||||
[link iterator.specialized.indirect `indirect_iterator`].
|
||||
|
||||
[h2 `minimum_category`]
|
||||
|
||||
`minimum_category` takes two iterator categories or two iterator traversal tags
|
||||
and returns the one that is the weakest (i.e. least advanced). For example:
|
||||
|
||||
static_assert(
|
||||
is_same<
|
||||
minimum_category<
|
||||
std::forward_iterator_tag,
|
||||
std::random_access_iterator_tag
|
||||
>::type,
|
||||
std::forward_iterator_tag
|
||||
>::value,
|
||||
"Unexpected minimum_category result"
|
||||
);
|
||||
|
||||
[h2 Iterator category and traversal tags manipulation]
|
||||
|
||||
The library provides several utilities to simplify conversions between iterator categories
|
||||
and traversal tags:
|
||||
|
||||
* `iterator_category_to_traversal<C>::type` - the metafunction takes an iterator category `C` and returns
|
||||
the corresponding traversal tag.
|
||||
* `iterator_traversal<T>::type` - a shorthand for `iterator_category_to_traversal<iterator_category<T>::type>::type`.
|
||||
* `pure_traversal_tag<T>::type` - the metafunction takes a tag `T` which derives from one of the iterator traversal tags
|
||||
and returns that traversal tag. `T` may also derive from other tags describing the iterator (e.g. whether this is a `const`-iterator
|
||||
or not), these additional tags are not considered.
|
||||
* `pure_iterator_traversal<T>::type` - a shorthand for `pure_traversal_tag<iterator_traversal<T>::type>::type`.
|
||||
[link indirecct `indirect_iterator`].
|
||||
|
||||
[h2 Reference]
|
||||
|
||||
[h3 `pointee`]
|
||||
[h3 `pointeee`]
|
||||
|
||||
template <class Dereferenceable>
|
||||
struct pointee
|
||||
@ -103,9 +74,9 @@ or not), these additional tags are not considered.
|
||||
|
||||
if ( ++x is ill-formed )
|
||||
{
|
||||
return Dereferenceable::element_type
|
||||
return `Dereferenceable::element_type`
|
||||
}
|
||||
else if (*x is a mutable reference to
|
||||
else if (`*x` is a mutable reference to
|
||||
std::iterator_traits<Dereferenceable>::value_type)
|
||||
{
|
||||
return iterator_traits<Dereferenceable>::value_type
|
||||
@ -135,81 +106,10 @@ or not), these additional tags are not considered.
|
||||
`x` is an object of type `Dereferenceable`:
|
||||
|
||||
if ( ++x is ill-formed )
|
||||
return pointee<Dereferenceable>::type&
|
||||
return `pointee<Dereferenceable>::type&`
|
||||
else
|
||||
std::iterator_traits<Dereferenceable>::reference
|
||||
|
||||
[h3 `minimum_category`]
|
||||
|
||||
template <typename C1, typename C2>
|
||||
struct minimum_category
|
||||
{
|
||||
typedef /* see below */ type;
|
||||
};
|
||||
|
||||
[*Requires:] Both `C1` and `C2` shall be standard iterator categories or
|
||||
iterator traversal tags.
|
||||
|
||||
`type` is determined according to the following algorithm, where `c1` is an
|
||||
object of type `C1` and `c2` is an object of type `C2`:
|
||||
|
||||
if (c1 is convertible to c2)
|
||||
return C2;
|
||||
else
|
||||
return C1;
|
||||
|
||||
[note The above definition relies on the fact that the more restricting categories
|
||||
and traversal tags are convertible to the less restricting ones.]
|
||||
|
||||
[h3 `iterator_category_to_traversal`]
|
||||
|
||||
template <typename C>
|
||||
struct iterator_category_to_traversal
|
||||
{
|
||||
typedef /* see below */ type;
|
||||
};
|
||||
|
||||
[*Requires:] `C` shall be a standard iterator category or an
|
||||
iterator traversal tag.
|
||||
|
||||
If `C` is an iterator traversal tag or convertible to one, `type` equivalent to `C`.
|
||||
Otherwise, `type` is defined to the closest iterator traversal tag matching `C`.
|
||||
|
||||
[h3 `iterator_traversal`]
|
||||
|
||||
template <typename Iterator>
|
||||
struct iterator_traversal
|
||||
{
|
||||
typedef typename iterator_category_to_traversal<
|
||||
typename iterator_category<Iterator>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
[*Requires:] `Iterator` shall be an iterator.
|
||||
|
||||
[h3 `pure_traversal_tag`]
|
||||
|
||||
template <typename T>
|
||||
struct pure_traversal_tag
|
||||
{
|
||||
typedef /* see below */ type;
|
||||
};
|
||||
|
||||
[*Requires:] `T` shall be convertible to an iterator traversal tag.
|
||||
|
||||
`type` is defined to be the most advanced traversal tag `Tag` so that `T` is convertible to `Tag`.
|
||||
|
||||
[h3 `pure_iterator_traversal`]
|
||||
|
||||
template <typename Iterator>
|
||||
struct pure_iterator_traversal
|
||||
{
|
||||
typedef typename pure_traversal_tag<
|
||||
typename iterator_traversal<Iterator>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
[*Requires:] `Iterator` shall be an iterator.
|
||||
|
||||
[endsect]
|
||||
|
||||
@ -321,4 +221,4 @@ Iterator Traversal Concepts
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
@ -8,16 +8,6 @@ the zip iterator moves all the iterators in parallel.
|
||||
Dereferencing the zip iterator returns a tuple that contains
|
||||
the results of dereferencing the individual iterators.
|
||||
|
||||
The tuple of iterators is now implemented in terms of a Boost fusion sequence.
|
||||
Because of this the 'tuple' may be any Boost fusion sequence and, for backwards
|
||||
compatibility through a Boost fusion sequence adapter, a Boost tuple. Because the
|
||||
'tuple' may be any boost::fusion sequence the 'tuple' may also be any type for which a
|
||||
Boost fusion adapter exists. This includes, among others, a std::tuple and a std::pair.
|
||||
Just remember to include the appropriate Boost fusion adapter header files for these
|
||||
other Boost fusion adapters. The zip_iterator header file already includes the
|
||||
Boost fusion adapter header file for Boost tuple, so you need not include it yourself
|
||||
to use a Boost tuple as your 'tuple'.
|
||||
|
||||
[section:zip_example Example]
|
||||
|
||||
There are two main types of applications of the `zip_iterator`. The first
|
||||
@ -228,7 +218,7 @@ operations.
|
||||
, IteratorTuple>::type* = 0 // exposition only
|
||||
);
|
||||
|
||||
[*Returns:] An instance of `zip_iterator` that is a copy of `other`.[br]
|
||||
[*Returns:] An instance of `zip_iterator` that is a copy of `other`.\n
|
||||
[*Requires:] `OtherIteratorTuple` is implicitly convertible to `IteratorTuple`.
|
||||
|
||||
|
||||
@ -245,13 +235,13 @@ operations.
|
||||
|
||||
zip_iterator& operator++();
|
||||
|
||||
[*Effects:] Increments each iterator in `m_iterator_tuple`.[br]
|
||||
[*Effects:] Increments each iterator in `m_iterator_tuple`.\n
|
||||
[*Returns:] `*this`
|
||||
|
||||
|
||||
zip_iterator& operator--();
|
||||
|
||||
[*Effects:] Decrements each iterator in `m_iterator_tuple`.[br]
|
||||
[*Effects:] Decrements each iterator in `m_iterator_tuple`.\n
|
||||
[*Returns:] `*this`
|
||||
|
||||
template<typename IteratorTuple>
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
.. _N1550: http://www.boost-consulting.com/writing/n1550.html
|
||||
.. _N1530: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html
|
||||
.. _N1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
|
||||
|
||||
:Author: David Abrahams and Jeremy Siek
|
||||
:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu
|
||||
|
||||
0
doc/reverse_iterator.pdf
Normal file → Executable file
0
doc/reverse_iterator.pdf
Normal file → Executable 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',
|
||||
|
||||
@ -99,7 +99,7 @@ private:
|
||||
</pre>
|
||||
<p>If <tt class="docutils literal"><span class="pre">Reference</span></tt> is <tt class="docutils literal"><span class="pre">use_default</span></tt> then the <tt class="docutils literal"><span class="pre">reference</span></tt> member of
|
||||
<tt class="docutils literal"><span class="pre">transform_iterator</span></tt> is
|
||||
<tt class="docutils literal"><span class="pre">result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type</span></tt>.
|
||||
<tt class="docutils literal"><span class="pre">result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type</span></tt>.
|
||||
Otherwise, <tt class="docutils literal"><span class="pre">reference</span></tt> is <tt class="docutils literal"><span class="pre">Reference</span></tt>.</p>
|
||||
<p>If <tt class="docutils literal"><span class="pre">Value</span></tt> is <tt class="docutils literal"><span class="pre">use_default</span></tt> then the <tt class="docutils literal"><span class="pre">value_type</span></tt> member is
|
||||
<tt class="docutils literal"><span class="pre">remove_cv<remove_reference<reference></span> <span class="pre">>::type</span></tt>. Otherwise,
|
||||
@ -117,10 +117,10 @@ convertible to <tt class="docutils literal"><span class="pre">input_iterator_tag
|
||||
<div class="section" id="transform-iterator-requirements">
|
||||
<h1><a class="toc-backref" href="#id3"><tt class="docutils literal"><span class="pre">transform_iterator</span></tt> requirements</a></h1>
|
||||
<p>The type <tt class="docutils literal"><span class="pre">UnaryFunction</span></tt> must be Assignable, Copy Constructible, and
|
||||
the expression <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be valid where <tt class="docutils literal"><span class="pre">f</span></tt> is a const object of
|
||||
the expression <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be valid where <tt class="docutils literal"><span class="pre">f</span></tt> is an object of
|
||||
type <tt class="docutils literal"><span class="pre">UnaryFunction</span></tt>, <tt class="docutils literal"><span class="pre">i</span></tt> is an object of type <tt class="docutils literal"><span class="pre">Iterator</span></tt>, and
|
||||
where the type of <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be
|
||||
<tt class="docutils literal"><span class="pre">result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type</span></tt>.</p>
|
||||
<tt class="docutils literal"><span class="pre">result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type</span></tt>.</p>
|
||||
<p>The argument <tt class="docutils literal"><span class="pre">Iterator</span></tt> shall model Readable Iterator.</p>
|
||||
</div>
|
||||
<div class="section" id="transform-iterator-models">
|
||||
|
||||
0
doc/transform_iterator.pdf
Normal file → Executable file
0
doc/transform_iterator.pdf
Normal file → Executable file
0
doc/transform_iterator_eg.rst
Normal file → Executable file
0
doc/transform_iterator_eg.rst
Normal file → Executable file
@ -41,7 +41,7 @@
|
||||
|
||||
If ``Reference`` is ``use_default`` then the ``reference`` member of
|
||||
``transform_iterator`` is
|
||||
``result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
|
||||
``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
|
||||
Otherwise, ``reference`` is ``Reference``.
|
||||
|
||||
If ``Value`` is ``use_default`` then the ``value_type`` member is
|
||||
@ -64,10 +64,10 @@ convertible to ``input_iterator_tag``.
|
||||
...................................
|
||||
|
||||
The type ``UnaryFunction`` must be Assignable, Copy Constructible, and
|
||||
the expression ``f(*i)`` must be valid where ``f`` is a const object of
|
||||
the expression ``f(*i)`` must be valid where ``f`` is an object of
|
||||
type ``UnaryFunction``, ``i`` is an object of type ``Iterator``, and
|
||||
where the type of ``f(*i)`` must be
|
||||
``result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
|
||||
``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
|
||||
|
||||
The argument ``Iterator`` shall model Readable Iterator.
|
||||
|
||||
|
||||
0
doc/zip_iterator.html
Normal file → Executable file
0
doc/zip_iterator.html
Normal file → Executable file
0
doc/zip_iterator.pdf
Normal file → Executable file
0
doc/zip_iterator.pdf
Normal file → Executable file
0
doc/zip_iterator.rst
Normal file → Executable file
0
doc/zip_iterator.rst
Normal file → Executable file
10
doc/zip_iterator_abstract.rst
Normal file → Executable file
10
doc/zip_iterator_abstract.rst
Normal file → Executable file
@ -8,13 +8,3 @@ iterator is constructed from a tuple of iterators. Moving
|
||||
the zip iterator moves all the iterators in parallel.
|
||||
Dereferencing the zip iterator returns a tuple that contains
|
||||
the results of dereferencing the individual iterators.
|
||||
|
||||
The tuple of iterators is now implemented in terms of a Boost fusion sequence.
|
||||
Because of this the 'tuple' may be any Boost fusion sequence and, for backwards
|
||||
compatibility through a Boost fusion sequence adapter, a Boost tuple. Because the
|
||||
'tuple' may be any boost::fusion sequence the 'tuple' may also be any type for which a
|
||||
Boost fusion adapter exists. This includes, among others, a std::tuple and a std::pair.
|
||||
Just remember to include the appropriate Boost fusion adapter header files for these
|
||||
other Boost fusion adapters. The zip_iterator header file already includes the
|
||||
Boost fusion adapter header file for Boost tuple, so you need not include it yourself
|
||||
to use a Boost tuple as your 'tuple'.
|
||||
|
||||
0
doc/zip_iterator_eg.rst
Normal file → Executable file
0
doc/zip_iterator_eg.rst
Normal file → Executable file
0
doc/zip_iterator_ref.rst
Normal file → Executable file
0
doc/zip_iterator_ref.rst
Normal file → Executable file
0
example/node.hpp
Normal file → Executable file
0
example/node.hpp
Normal file → Executable file
0
example/node_iterator1.cpp
Normal file → Executable file
0
example/node_iterator1.cpp
Normal file → Executable file
0
example/node_iterator1.hpp
Normal file → Executable file
0
example/node_iterator1.hpp
Normal file → Executable file
0
example/node_iterator2.cpp
Normal file → Executable file
0
example/node_iterator2.cpp
Normal file → Executable file
0
example/node_iterator2.hpp
Normal file → Executable file
0
example/node_iterator2.hpp
Normal file → Executable file
0
example/node_iterator3.cpp
Normal file → Executable file
0
example/node_iterator3.cpp
Normal file → Executable file
0
example/node_iterator3.hpp
Normal file → Executable file
0
example/node_iterator3.hpp
Normal file → Executable file
@ -14,7 +14,6 @@
|
||||
#include <iterator>
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
|
||||
template <class UnaryFunction>
|
||||
class function_output_iterator {
|
||||
@ -34,13 +33,13 @@ namespace iterators {
|
||||
struct output_proxy {
|
||||
output_proxy(UnaryFunction& f) : m_f(f) { }
|
||||
template <class T> output_proxy& operator=(const T& value) {
|
||||
m_f(value);
|
||||
return *this;
|
||||
m_f(value);
|
||||
return *this;
|
||||
}
|
||||
UnaryFunction& m_f;
|
||||
};
|
||||
output_proxy operator*() { return output_proxy(m_f); }
|
||||
self& operator++() { return *this; }
|
||||
self& operator++() { return *this; }
|
||||
self& operator++(int) { return *this; }
|
||||
private:
|
||||
UnaryFunction m_f;
|
||||
@ -52,11 +51,6 @@ namespace iterators {
|
||||
return function_output_iterator<UnaryFunction>(f);
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
using iterators::function_output_iterator;
|
||||
using iterators::make_function_output_iterator;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
|
||||
|
||||
@ -1,85 +0,0 @@
|
||||
// (C) Copyright Jens Maurer 2001.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// Revision History:
|
||||
|
||||
// 15 Nov 2001 Jens Maurer
|
||||
// created.
|
||||
|
||||
// See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation.
|
||||
|
||||
#ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
|
||||
#define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
|
||||
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
|
||||
template<class Generator>
|
||||
class generator_iterator
|
||||
: public iterator_facade<
|
||||
generator_iterator<Generator>
|
||||
, typename Generator::result_type
|
||||
, single_pass_traversal_tag
|
||||
, typename Generator::result_type const&
|
||||
>
|
||||
{
|
||||
typedef iterator_facade<
|
||||
generator_iterator<Generator>
|
||||
, typename Generator::result_type
|
||||
, single_pass_traversal_tag
|
||||
, typename Generator::result_type const&
|
||||
> super_t;
|
||||
|
||||
public:
|
||||
generator_iterator() {}
|
||||
generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}
|
||||
|
||||
void increment()
|
||||
{
|
||||
m_value = (*m_g)();
|
||||
}
|
||||
|
||||
const typename Generator::result_type&
|
||||
dereference() const
|
||||
{
|
||||
return m_value;
|
||||
}
|
||||
|
||||
bool equal(generator_iterator const& y) const
|
||||
{
|
||||
return this->m_g == y.m_g && this->m_value == y.m_value;
|
||||
}
|
||||
|
||||
private:
|
||||
Generator* m_g;
|
||||
typename Generator::result_type m_value;
|
||||
};
|
||||
|
||||
template<class Generator>
|
||||
struct generator_iterator_generator
|
||||
{
|
||||
typedef generator_iterator<Generator> type;
|
||||
};
|
||||
|
||||
template <class Generator>
|
||||
inline generator_iterator<Generator>
|
||||
make_generator_iterator(Generator & gen)
|
||||
{
|
||||
typedef generator_iterator<Generator> result_t;
|
||||
return result_t(&gen);
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
using iterators::generator_iterator;
|
||||
using iterators::generator_iterator_generator;
|
||||
using iterators::make_generator_iterator;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
|
||||
@ -1,43 +0,0 @@
|
||||
#ifndef INDIRECT_REFERENCE_DWA200415_HPP
|
||||
# define INDIRECT_REFERENCE_DWA200415_HPP
|
||||
|
||||
//
|
||||
// Copyright David Abrahams 2004. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// typename indirect_reference<P>::type provides the type of *p.
|
||||
//
|
||||
// http://www.boost.org/libs/iterator/doc/pointee.html
|
||||
//
|
||||
|
||||
# include <boost/detail/is_incrementable.hpp>
|
||||
# include <boost/iterator/iterator_traits.hpp>
|
||||
# include <boost/type_traits/remove_cv.hpp>
|
||||
# include <boost/mpl/eval_if.hpp>
|
||||
# include <boost/pointee.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <class P>
|
||||
struct smart_ptr_reference
|
||||
{
|
||||
typedef typename boost::pointee<P>::type& type;
|
||||
};
|
||||
}
|
||||
|
||||
template <class P>
|
||||
struct indirect_reference
|
||||
: mpl::eval_if<
|
||||
detail::is_incrementable<P>
|
||||
, iterator_reference<P>
|
||||
, detail::smart_ptr_reference<P>
|
||||
>
|
||||
{
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // INDIRECT_REFERENCE_DWA200415_HPP
|
||||
59
include/boost/iterator.hpp
Normal file
59
include/boost/iterator.hpp
Normal file
@ -0,0 +1,59 @@
|
||||
// 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
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org/libs/utility for documentation.
|
||||
|
||||
// Revision History
|
||||
// 12 Jan 01 added <cstddef> for std::ptrdiff_t (Jens Maurer)
|
||||
// 28 Jun 00 Workarounds to deal with known MSVC bugs (David Abrahams)
|
||||
// 26 Jun 00 Initial version (Jeremy Siek)
|
||||
|
||||
#ifndef BOOST_ITERATOR_HPP
|
||||
#define BOOST_ITERATOR_HPP
|
||||
|
||||
#include <iterator>
|
||||
#include <cstddef> // std::ptrdiff_t
|
||||
#include <boost/config.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
# if defined(BOOST_NO_STD_ITERATOR) && !defined(BOOST_MSVC_STD_ITERATOR)
|
||||
template <class Category, class T,
|
||||
class Distance = std::ptrdiff_t,
|
||||
class Pointer = T*, class Reference = T&>
|
||||
struct iterator
|
||||
{
|
||||
typedef T value_type;
|
||||
typedef Distance difference_type;
|
||||
typedef Pointer pointer;
|
||||
typedef Reference reference;
|
||||
typedef Category iterator_category;
|
||||
};
|
||||
# else
|
||||
|
||||
// declare iterator_base in namespace detail to work around MSVC bugs which
|
||||
// prevent derivation from an identically-named class in a different namespace.
|
||||
namespace detail {
|
||||
template <class Category, class T, class Distance, class Pointer, class Reference>
|
||||
# if !defined(BOOST_MSVC_STD_ITERATOR)
|
||||
struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
|
||||
# else
|
||||
struct iterator_base : std::iterator<Category, T, Distance>
|
||||
{
|
||||
typedef Reference reference;
|
||||
typedef Pointer pointer;
|
||||
typedef Distance difference_type;
|
||||
};
|
||||
# endif
|
||||
}
|
||||
|
||||
template <class Category, class T, class Distance = std::ptrdiff_t,
|
||||
class Pointer = T*, class Reference = T&>
|
||||
struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
|
||||
# endif
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ITERATOR_HPP
|
||||
@ -1,84 +0,0 @@
|
||||
// Copyright (C) 2017 Michel Morin.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_ITERATOR_ADVANCE_HPP
|
||||
#define BOOST_ITERATOR_ADVANCE_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/iterator/iterator_categories.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
|
||||
namespace detail {
|
||||
template <typename InputIterator, typename Distance>
|
||||
inline BOOST_CXX14_CONSTEXPR void
|
||||
advance_impl(
|
||||
InputIterator& it
|
||||
, Distance n
|
||||
, incrementable_traversal_tag
|
||||
)
|
||||
{
|
||||
while (n > 0) {
|
||||
++it;
|
||||
--n;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename BidirectionalIterator, typename Distance>
|
||||
inline BOOST_CXX14_CONSTEXPR void
|
||||
advance_impl(
|
||||
BidirectionalIterator& it
|
||||
, Distance n
|
||||
, bidirectional_traversal_tag
|
||||
)
|
||||
{
|
||||
if (n >= 0) {
|
||||
while (n > 0) {
|
||||
++it;
|
||||
--n;
|
||||
}
|
||||
}
|
||||
else {
|
||||
while (n < 0) {
|
||||
--it;
|
||||
++n;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename RandomAccessIterator, typename Distance>
|
||||
inline BOOST_CXX14_CONSTEXPR void
|
||||
advance_impl(
|
||||
RandomAccessIterator& it
|
||||
, Distance n
|
||||
, random_access_traversal_tag
|
||||
)
|
||||
{
|
||||
it += n;
|
||||
}
|
||||
}
|
||||
|
||||
namespace advance_adl_barrier {
|
||||
template <typename InputIterator, typename Distance>
|
||||
inline BOOST_CXX14_CONSTEXPR void
|
||||
advance(InputIterator& it, Distance n)
|
||||
{
|
||||
detail::advance_impl(
|
||||
it, n, typename iterator_traversal<InputIterator>::type()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
using namespace advance_adl_barrier;
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
using iterators::advance;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
@ -13,7 +13,6 @@
|
||||
# include <boost/mpl/eval_if.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
|
||||
template <
|
||||
class Incrementable
|
||||
@ -31,13 +30,13 @@ namespace detail
|
||||
{
|
||||
// For a while, this wasn't true, but we rely on it below. This is a regression assert.
|
||||
BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
|
||||
|
||||
|
||||
# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
|
||||
|
||||
|
||||
# else
|
||||
|
||||
|
||||
# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = (
|
||||
@ -47,20 +46,20 @@ namespace detail
|
||||
# else
|
||||
BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
|
||||
# endif
|
||||
|
||||
|
||||
# endif
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_numeric
|
||||
: mpl::bool_<(::boost::iterators::detail::is_numeric_impl<T>::value)>
|
||||
: mpl::bool_<(::boost::detail::is_numeric_impl<T>::value)>
|
||||
{};
|
||||
|
||||
# if defined(BOOST_HAS_LONG_LONG)
|
||||
template <>
|
||||
struct is_numeric< ::boost::long_long_type>
|
||||
: mpl::true_ {};
|
||||
|
||||
|
||||
template <>
|
||||
struct is_numeric< ::boost::ulong_long_type>
|
||||
: mpl::true_ {};
|
||||
@ -70,7 +69,7 @@ namespace detail
|
||||
template <>
|
||||
struct is_numeric<wchar_t>
|
||||
: mpl::true_ {};
|
||||
|
||||
|
||||
template <class T>
|
||||
struct numeric_difference
|
||||
{
|
||||
@ -78,7 +77,7 @@ namespace detail
|
||||
};
|
||||
|
||||
BOOST_STATIC_ASSERT(is_numeric<int>::value);
|
||||
|
||||
|
||||
template <class Incrementable, class CategoryOrTraversal, class Difference>
|
||||
struct counting_iterator_base
|
||||
{
|
||||
@ -90,7 +89,7 @@ namespace detail
|
||||
, iterator_traversal<Incrementable>
|
||||
>
|
||||
>::type traversal;
|
||||
|
||||
|
||||
typedef typename detail::ia_dflt_help<
|
||||
Difference
|
||||
, mpl::eval_if<
|
||||
@ -99,7 +98,7 @@ namespace detail
|
||||
, iterator_difference<Incrementable>
|
||||
>
|
||||
>::type difference;
|
||||
|
||||
|
||||
typedef iterator_adaptor<
|
||||
counting_iterator<Incrementable, CategoryOrTraversal, Difference> // self
|
||||
, Incrementable // Base
|
||||
@ -107,7 +106,7 @@ namespace detail
|
||||
# ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
|
||||
const // MSVC won't strip this. Instead we enable Thomas'
|
||||
// criterion (see boost/iterator/detail/facade_iterator_category.hpp)
|
||||
# endif
|
||||
# endif
|
||||
, traversal
|
||||
, Incrementable const& // reference
|
||||
, difference
|
||||
@ -137,7 +136,7 @@ namespace detail
|
||||
{
|
||||
static Difference distance(Incrementable1 x, Incrementable2 y)
|
||||
{
|
||||
return boost::detail::numeric_distance(x, y);
|
||||
return numeric_distance(x, y);
|
||||
}
|
||||
};
|
||||
}
|
||||
@ -155,14 +154,14 @@ class counting_iterator
|
||||
typedef typename detail::counting_iterator_base<
|
||||
Incrementable, CategoryOrTraversal, Difference
|
||||
>::type super_t;
|
||||
|
||||
|
||||
friend class iterator_core_access;
|
||||
|
||||
public:
|
||||
typedef typename super_t::difference_type difference_type;
|
||||
|
||||
counting_iterator() { }
|
||||
|
||||
|
||||
counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {}
|
||||
|
||||
counting_iterator(Incrementable x)
|
||||
@ -178,10 +177,10 @@ class counting_iterator
|
||||
)
|
||||
: super_t(t.base())
|
||||
{}
|
||||
# endif
|
||||
# endif
|
||||
|
||||
private:
|
||||
|
||||
|
||||
typename super_t::reference dereference() const
|
||||
{
|
||||
return this->base_reference();
|
||||
@ -210,11 +209,7 @@ make_counting_iterator(Incrementable x)
|
||||
return result_t(x);
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
using iterators::counting_iterator;
|
||||
using iterators::make_counting_iterator;
|
||||
|
||||
} // namespace boost
|
||||
} // namespace boost::iterator
|
||||
|
||||
#endif // COUNTING_ITERATOR_DWA200348_HPP
|
||||
|
||||
6
include/boost/iterator/detail/any_conversion_eater.hpp
Normal file → Executable file
6
include/boost/iterator/detail/any_conversion_eater.hpp
Normal file → Executable file
@ -4,9 +4,7 @@
|
||||
#ifndef ANY_CONVERSION_EATER_DWA20031117_HPP
|
||||
# define ANY_CONVERSION_EATER_DWA20031117_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
namespace detail {
|
||||
namespace boost { namespace detail {
|
||||
|
||||
// This type can be used in traits to "eat" up the one user-defined
|
||||
// implicit conversion allowed.
|
||||
@ -16,6 +14,6 @@ struct any_conversion_eater
|
||||
any_conversion_eater(T const&);
|
||||
};
|
||||
|
||||
}}} // namespace boost::iterators::detail
|
||||
}} // namespace boost::detail
|
||||
|
||||
#endif // ANY_CONVERSION_EATER_DWA20031117_HPP
|
||||
|
||||
@ -46,7 +46,8 @@
|
||||
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0)) \
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
|
||||
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531)) \
|
||||
|| (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
|
||||
|| BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) \
|
||||
|| BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
|
||||
@ -87,7 +88,8 @@
|
||||
# define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \
|
||||
#if BOOST_WORKAROUND(__GNUC__, == 2) \
|
||||
|| BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \
|
||||
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
||||
# define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
|
||||
|
||||
@ -114,9 +116,16 @@
|
||||
# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
|
||||
#endif
|
||||
|
||||
# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
|
||||
# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
# define BOOST_ARG_DEPENDENT_TYPENAME typename
|
||||
# else
|
||||
# define BOOST_ARG_DEPENDENT_TYPENAME
|
||||
# endif
|
||||
|
||||
// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
|
||||
# if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \
|
||||
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
|
||||
|
||||
// GCC-2.95 eagerly instantiates templated constructors and conversion
|
||||
// operators in convertibility checks, causing premature errors.
|
||||
//
|
||||
// Borland's problems are harder to diagnose due to lack of an
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#undef BOOST_NO_IS_CONVERTIBLE
|
||||
#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
|
||||
#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
|
||||
#undef BOOST_ARG_DEPENDENT_TYPENAME
|
||||
#undef BOOST_NO_LVALUE_RETURN_DETECTION
|
||||
#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
|
||||
|
||||
|
||||
@ -35,7 +35,7 @@ namespace boost
|
||||
typedef T type;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// For compilers that don't support "Substitution Failure Is Not An Error"
|
||||
// enable_if falls back to always enabled. See comments
|
||||
@ -70,8 +70,11 @@ namespace boost
|
||||
: enabled<(Cond::value)>::template base<Return>
|
||||
# else
|
||||
: mpl::identity<Return>
|
||||
# endif
|
||||
# endif
|
||||
{
|
||||
# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
typedef Return type;
|
||||
# endif
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
37
include/boost/iterator/detail/facade_iterator_category.hpp
Normal file → Executable file
37
include/boost/iterator/detail/facade_iterator_category.hpp
Normal file → Executable file
@ -30,13 +30,10 @@
|
||||
// iterator_category deduction for iterator_facade
|
||||
//
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
|
||||
// forward declaration
|
||||
struct use_default;
|
||||
namespace boost { struct use_default; }
|
||||
|
||||
namespace detail {
|
||||
namespace boost { namespace detail {
|
||||
|
||||
struct input_output_iterator_tag
|
||||
: std::input_iterator_tag
|
||||
@ -66,9 +63,9 @@ struct iterator_writability_disabled
|
||||
, boost::detail::indirect_traits::is_reference_to_const<Reference>
|
||||
, is_const<ValueParam>
|
||||
>
|
||||
# else
|
||||
# else
|
||||
: is_const<ValueParam>
|
||||
# endif
|
||||
# endif
|
||||
{};
|
||||
|
||||
|
||||
@ -76,10 +73,16 @@ struct iterator_writability_disabled
|
||||
// Convert an iterator_facade's traversal category, Value parameter,
|
||||
// and ::reference type to an appropriate old-style category.
|
||||
//
|
||||
// Due to changeset 21683, this now never results in a category convertible
|
||||
// to output_iterator_tag.
|
||||
// If writability has been disabled per the above metafunction, the
|
||||
// result will not be convertible to output_iterator_tag.
|
||||
//
|
||||
// Otherwise, if Traversal == single_pass_traversal_tag, the following
|
||||
// conditions will result in a tag that is convertible both to
|
||||
// input_iterator_tag and output_iterator_tag:
|
||||
//
|
||||
// 1. Reference is a reference to non-const
|
||||
// 2. Reference is not a reference and is convertible to Value
|
||||
//
|
||||
// Change at: https://svn.boost.org/trac/boost/changeset/21683
|
||||
template <class Traversal, class ValueParam, class Reference>
|
||||
struct iterator_facade_default_category
|
||||
: mpl::eval_if<
|
||||
@ -99,7 +102,7 @@ struct iterator_facade_default_category
|
||||
, typename mpl::eval_if<
|
||||
mpl::and_<
|
||||
is_convertible<Traversal, single_pass_traversal_tag>
|
||||
|
||||
|
||||
// check for readability
|
||||
, is_convertible<Reference, ValueParam>
|
||||
>
|
||||
@ -135,6 +138,7 @@ template <class Category, class Traversal>
|
||||
struct iterator_category_with_traversal
|
||||
: Category, Traversal
|
||||
{
|
||||
# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
// Make sure this isn't used to build any categories where
|
||||
// convertibility to Traversal is redundant. Should just use the
|
||||
// Category element in that case.
|
||||
@ -149,7 +153,8 @@ struct iterator_category_with_traversal
|
||||
BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
|
||||
# if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
|
||||
BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
};
|
||||
|
||||
// Computes an iterator_category tag whose traversal is Traversal and
|
||||
@ -157,12 +162,14 @@ struct iterator_category_with_traversal
|
||||
template <class Traversal, class ValueParam, class Reference>
|
||||
struct facade_iterator_category_impl
|
||||
{
|
||||
# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
|
||||
|
||||
# endif
|
||||
|
||||
typedef typename iterator_facade_default_category<
|
||||
Traversal,ValueParam,Reference
|
||||
>::type category;
|
||||
|
||||
|
||||
typedef typename mpl::if_<
|
||||
is_same<
|
||||
Traversal
|
||||
@ -186,7 +193,7 @@ struct facade_iterator_category
|
||||
{
|
||||
};
|
||||
|
||||
}}} // namespace boost::iterators::detail
|
||||
}} // namespace boost::detail
|
||||
|
||||
# include <boost/iterator/detail/config_undef.hpp>
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user