<metaname="author"content="David Abrahams, Jeremy Siek, Thomas Witt"/>
<metaname="organization"content="Boost Consulting, Indiana University Open Systems Lab, University of Hanover Institute for Transport Railway Operation and Construction"/>
<td><aclass="first reference"href="http://www.boost-consulting.com">Boost Consulting</a>, Indiana University <aclass="reference"href="http://www.osl.iu.edu">Open Systems
Lab</a>, University of Hanover <aclass="last reference"href="http://www.ive.uni-hannover.de">Institute for Transport
<p>Each specialization of the <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> class template is derived from
a specialization of <ttclass="docutils literal"><spanclass="pre">iterator_facade</span></tt>. The core interface functions
expected by <ttclass="docutils literal"><spanclass="pre">iterator_facade</span></tt> are implemented in terms of the
<ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt>'s <ttclass="docutils literal"><spanclass="pre">Base</span></tt> template parameter. A class derived
from <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> typically redefines some of the core
interface functions to adapt the behavior of the <ttclass="docutils literal"><spanclass="pre">Base</span></tt> type.
<li><aclass="reference"href="#iterator-adaptor-base-class-parameters"id="id9"name="id9"><ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> base class parameters</a></li>
<li><aclass="reference"href="#iterator-adaptor-public-operations"id="id10"name="id10"><ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> public operations</a></li>
<li><aclass="reference"href="#iterator-adaptor-protected-member-functions"id="id11"name="id11"><ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> protected member functions</a></li>
<li><aclass="reference"href="#iterator-adaptor-private-member-functions"id="id12"name="id12"><ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> private member functions</a></li>
<p>The <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> class template adapts some <ttclass="docutils literal"><spanclass="pre">Base</span></tt><aclass="footnote-reference"href="#base"id="id1"name="id1">[1]</a>
type to create a new iterator. Instantiations of <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt>
are derived from a corresponding instantiation of <ttclass="docutils literal"><spanclass="pre">iterator_facade</span></tt>
and implement the core behaviors in terms of the <ttclass="docutils literal"><spanclass="pre">Base</span></tt> type. In
essence, <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> merely forwards all operations to an
instance of the <ttclass="docutils literal"><spanclass="pre">Base</span></tt> type, which it stores as a member.</p>
<tr><tdclass="label"><aname="base">[1]</a></td><td><em>(<aclass="fn-backref"href="#id1">1</a>, <aclass="fn-backref"href="#id3">2</a>)</em> The term "Base" here does not refer to a base class and is
<ttclass="docutils literal"><spanclass="pre">iterator_facade</span></tt> core requirements table. The <ttclass="docutils literal"><spanclass="pre">Base</span></tt> type need
: public iterator_facade<Derived, <em>V'</em>, <em>C'</em>, <em>R'</em>, <em>D'</em>> // see <aclass="reference"href="#base-parameters">details</a>
<h2><aclass="toc-backref"href="#id9"id="iterator-adaptor-base-class-parameters"name="iterator-adaptor-base-class-parameters"><spanid="base-parameters"></span><ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> base class parameters</a></h2>
<p>The <em>V'</em>, <em>C'</em>, <em>R'</em>, and <em>D'</em> parameters of the <ttclass="docutils literal"><spanclass="pre">iterator_facade</span></tt>
used as a base class in the summary of <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt>
<h2><aclass="toc-backref"href="#id10"id="iterator-adaptor-public-operations"name="iterator-adaptor-public-operations"><ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> public operations</a></h2>
<trclass="field"><thclass="field-name">Requires:</th><tdclass="field-body">The <ttclass="docutils literal"><spanclass="pre">Base</span></tt> type must be Default Constructible.</td>
<trclass="field"><thclass="field-name">Returns:</th><tdclass="field-body">An instance of <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> with
<trclass="field"><thclass="field-name">Returns:</th><tdclass="field-body">An instance of <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> with
<ttclass="docutils literal"><spanclass="pre">m_iterator</span></tt> copy constructed from <ttclass="docutils literal"><spanclass="pre">iter</span></tt>.</td>
<h2><aclass="toc-backref"href="#id11"id="iterator-adaptor-protected-member-functions"name="iterator-adaptor-protected-member-functions"><ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> protected member functions</a></h2>
<h2><aclass="toc-backref"href="#id12"id="iterator-adaptor-private-member-functions"name="iterator-adaptor-private-member-functions"><ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> private member functions</a></h2>
<p>In this section we'll further refine the <ttclass="docutils literal"><spanclass="pre">node_iter</span></tt> class
template we developed in the <aclass="reference"href="iterator_facade.html#tutorial-example"><ttclass="docutils literal"><spanclass="pre">iterator_facade</span></tt> tutorial</a>. If you haven't already
with the <ttclass="docutils literal"><spanclass="pre">node_iterator</span></tt> we're building. First, they share most
of the same associated types (<ttclass="docutils literal"><spanclass="pre">value_type</span></tt>, <ttclass="docutils literal"><spanclass="pre">reference</span></tt>,
<ttclass="docutils literal"><spanclass="pre">pointer</span></tt>, and <ttclass="docutils literal"><spanclass="pre">difference_type</span></tt>). Second, even some of the
core functionality is the same: <ttclass="docutils literal"><spanclass="pre">operator*</span></tt> and <ttclass="docutils literal"><spanclass="pre">operator==</span></tt> on
the <ttclass="docutils literal"><spanclass="pre">node_iterator</span></tt> return the result of invoking the same
operations on the underlying pointer, via the <ttclass="docutils literal"><spanclass="pre">node_iterator</span></tt>'s
<aclass="reference"href="iterator_facade.html#implementing-the-core-operations"><ttclass="docutils literal"><spanclass="pre">dereference</span></tt> and <ttclass="docutils literal"><spanclass="pre">equal</span></tt> member functions</a>). The only real behavioral difference
between <ttclass="docutils literal"><spanclass="pre">node_base*</span></tt> and <ttclass="docutils literal"><spanclass="pre">node_iterator</span></tt> can be observed when
they are incremented: <ttclass="docutils literal"><spanclass="pre">node_iterator</span></tt> follows the
<ttclass="docutils literal"><spanclass="pre">m_next</span></tt> pointer, while <ttclass="docutils literal"><spanclass="pre">node_base*</span></tt> just applies an address offset.</p>
iterator-like type (the <ttclass="docutils literal"><spanclass="pre">Base</span></tt><aclass="footnote-reference"href="#base"id="id3"name="id3">[1]</a> type) while modifying
<ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt>. Using <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> is very much like
using <ttclass="docutils literal"><spanclass="pre">iterator_facade</span></tt>, but because iterator_adaptor tries to
mimic as much of the <ttclass="docutils literal"><spanclass="pre">Base</span></tt> type's behavior as possible, we
neither have to supply a <ttclass="docutils literal"><spanclass="pre">Value</span></tt> argument, nor implement any core
behaviors other than <ttclass="docutils literal"><spanclass="pre">increment</span></tt>. The implementation of
<ttclass="docutils literal"><spanclass="pre">node_iter</span></tt> is thus reduced to:</p>
<p>Note the use of <ttclass="docutils literal"><spanclass="pre">node_iter::iterator_adaptor_</span></tt> here: because
<ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> defines a nested <ttclass="docutils literal"><spanclass="pre">iterator_adaptor_</span></tt> type
<p>In the case of <ttclass="docutils literal"><spanclass="pre">node_iter</span></tt>, it's not very compelling to pass
<ttclass="docutils literal"><spanclass="pre">boost::use_default</span></tt> as <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt>'s <ttclass="docutils literal"><spanclass="pre">Value</span></tt>
argument; we could have just passed <ttclass="docutils literal"><spanclass="pre">node_iter</span></tt>'s <ttclass="docutils literal"><spanclass="pre">Value</span></tt>
along to <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt>, and that'd even be shorter! Most
iterator class templates built with <ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt> are
<ttclass="docutils literal"><spanclass="pre">value_type</span></tt>. For example, <ttclass="docutils literal"><spanclass="pre">boost::reverse_iterator</span></tt> takes an
<aclass="reference"href="reverse_iterator.html"><ttclass="docutils literal"><spanclass="pre">reverse_iterator</span></tt></a> and the other Boost <aclass="reference"href="index.html#specialized-adaptors">specialized iterator
<ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt>. In particular, have a look at
<aclass="reference"href="transform_iterator.html"><ttclass="docutils literal"><spanclass="pre">transform_iterator</span></tt></a>, which is perhaps the most straightforward
adaptor, and also <aclass="reference"href="counting_iterator.html"><ttclass="docutils literal"><spanclass="pre">counting_iterator</span></tt></a>, which demonstrates that
<ttclass="docutils literal"><spanclass="pre">iterator_adaptor</span></tt>'s <ttclass="docutils literal"><spanclass="pre">Base</span></tt> type needn't be an iterator.</p>