try a new interface

[SVN r9063]

call_traits_test.cpp

@@ -1,377 +0,0 @@
- // boost::compressed_pair test program   
-    
- //  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
- //  distribute this software is granted provided this copyright notice appears   
- //  in all copies. This software is provided "as is" without express or implied   
- //  warranty, and with no claim as to its suitability for any purpose.   
-
-// standalone test program for <boost/call_traits.hpp>
-// 03 Oct 2000:
-//    Enabled extra tests for VC6.
-
-#include <cassert>
-#include <iostream>
-#include <iomanip>
-#include <algorithm>
-#include <typeinfo>
-#include <boost/call_traits.hpp>
-
-#include <boost/type_traits/type_traits_test.hpp>
-//
-// struct contained models a type that contains a type (for example std::pair)
-// arrays are contained by value, and have to be treated as a special case:
-//
-template <class T>
-struct contained
-{
-   // define our typedefs first, arrays are stored by value
-   // so value_type is not the same as result_type:
-   typedef typename boost::call_traits<T>::param_type       param_type;
-   typedef typename boost::call_traits<T>::reference        reference;
-   typedef typename boost::call_traits<T>::const_reference  const_reference;
-   typedef T                                                value_type;
-   typedef typename boost::call_traits<T>::value_type       result_type;
-
-   // stored value:
-   value_type v_;
-   
-   // constructors:
-   contained() {}
-   contained(param_type p) : v_(p){}
-   // return byval:
-   result_type value()const { return v_; }
-   // return by_ref:
-   reference get() { return v_; }
-   const_reference const_get()const { return v_; }
-   // pass value:
-   void call(param_type p){}
-
-};
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, std::size_t N>
-struct contained<T[N]>
-{
-   typedef typename boost::call_traits<T[N]>::param_type       param_type;
-   typedef typename boost::call_traits<T[N]>::reference        reference;
-   typedef typename boost::call_traits<T[N]>::const_reference  const_reference;
-   typedef T                                                   value_type[N];
-   typedef typename boost::call_traits<T[N]>::value_type       result_type;
-
-   value_type v_;
-
-   contained(param_type p)
-   {
-      std::copy(p, p+N, v_);
-   }
-   // return byval:
-   result_type value()const { return v_; }
-   // return by_ref:
-   reference get() { return v_; }
-   const_reference const_get()const { return v_; }
-   void call(param_type p){}
-};
-#endif
-
-template <class T>
-contained<typename boost::call_traits<T>::value_type> wrap(const T& t)
-{
-   typedef typename boost::call_traits<T>::value_type ct;
-   return contained<ct>(t);
-}
-
-namespace test{
-
-template <class T1, class T2>
-std::pair<
-   typename boost::call_traits<T1>::value_type,
-   typename boost::call_traits<T2>::value_type>
-      make_pair(const T1& t1, const T2& t2)
-{
-   return std::pair<
-      typename boost::call_traits<T1>::value_type,
-      typename boost::call_traits<T2>::value_type>(t1, t2);
-}
-
-} // namespace test
-
-using namespace std;
-
-//
-// struct call_traits_checker:
-// verifies behaviour of contained example:
-//
-template <class T>
-struct call_traits_checker
-{
-   typedef typename boost::call_traits<T>::param_type param_type;
-   void operator()(param_type);
-};
-
-template <class T>
-void call_traits_checker<T>::operator()(param_type p)
-{
-   T t(p);
-   contained<T> c(t);
-   cout << "checking contained<" << typeid(T).name() << ">..." << endl;
-   assert(t == c.value());
-   assert(t == c.get());
-   assert(t == c.const_get());
-#ifndef __ICL
-   //cout << "typeof contained<" << typeid(T).name() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::value() is:      " << typeid(&contained<T>::value).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::get() is:        " << typeid(&contained<T>::get).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::const_get() is:  " << typeid(&contained<T>::const_get).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::call() is:       " << typeid(&contained<T>::call).name() << endl;
-   cout << endl;
-#endif
-}
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, std::size_t N>
-struct call_traits_checker<T[N]>
-{
-   typedef typename boost::call_traits<T[N]>::param_type param_type;
-   void operator()(param_type t)
-   {
-      contained<T[N]> c(t);
-      cout << "checking contained<" << typeid(T[N]).name() << ">..." << endl;
-      unsigned int i = 0;
-      for(i = 0; i < N; ++i)
-         assert(t[i] == c.value()[i]);
-      for(i = 0; i < N; ++i)
-         assert(t[i] == c.get()[i]);
-      for(i = 0; i < N; ++i)
-         assert(t[i] == c.const_get()[i]);
-
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::v_ is:         " << typeid(&contained<T[N]>::v_).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::value is:      " << typeid(&contained<T[N]>::value).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::get is:        " << typeid(&contained<T[N]>::get).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::const_get is:  " << typeid(&contained<T[N]>::const_get).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::call is:       " << typeid(&contained<T[N]>::call).name() << endl;
-      cout << endl;
-   }
-};
-#endif
-
-//
-// check_wrap:
-template <class T, class U>
-void check_wrap(const contained<T>& w, const U& u)
-{
-   cout << "checking contained<" << typeid(T).name() << ">..." << endl;
-   assert(w.value() == u);
-}
-
-//
-// check_make_pair:
-// verifies behaviour of "make_pair":
-//
-template <class T, class U, class V>
-void check_make_pair(T c, U u, V v)
-{
-   cout << "checking std::pair<" << typeid(c.first).name() << ", " << typeid(c.second).name() << ">..." << endl;
-   assert(c.first == u);
-   assert(c.second == v);
-   cout << endl;
-}
-
-
-struct comparible_UDT
-{
-   int i_;
-   comparible_UDT() : i_(2){}
-   bool operator == (const comparible_UDT& v){ return v.i_ == i_; }
-};
-
-int main(int argc, char *argv[ ])
-{
-   call_traits_checker<comparible_UDT> c1;
-   comparible_UDT u;
-   c1(u);
-   call_traits_checker<int> c2;
-   int i = 2;
-   c2(i);
-   int* pi = &i;
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
-   call_traits_checker<int*> c3;
-   c3(pi);
-   call_traits_checker<int&> c4;
-   c4(i);
-   call_traits_checker<const int&> c5;
-   c5(i);
-#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   int a[2] = {1,2};
-   call_traits_checker<int[2]> c6;
-   c6(a);
-#endif
-#endif
-
-   check_wrap(wrap(2), 2);
-   const char ca[4] = "abc";
-   // compiler can't deduce this for some reason:
-   //check_wrap(wrap(ca), ca);
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   check_wrap(wrap(a), a);
-   check_make_pair(test::make_pair(a, a), a, a);
-#endif
-
-   // cv-qualifiers applied to reference types should have no effect
-   // declare these here for later use with is_reference and remove_reference:
-   typedef int& r_type;
-   typedef const r_type cr_type;
-
-   type_test(comparible_UDT, boost::call_traits<comparible_UDT>::value_type)
-   type_test(comparible_UDT&, boost::call_traits<comparible_UDT>::reference)
-   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference)
-   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type)
-   type_test(int, boost::call_traits<int>::value_type)
-   type_test(int&, boost::call_traits<int>::reference)
-   type_test(const int&, boost::call_traits<int>::const_reference)
-   type_test(const int, boost::call_traits<int>::param_type)
-   type_test(int*, boost::call_traits<int*>::value_type)
-   type_test(int*&, boost::call_traits<int*>::reference)
-   type_test(int*const&, boost::call_traits<int*>::const_reference)
-   type_test(int*const, boost::call_traits<int*>::param_type)
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
-   type_test(int&, boost::call_traits<int&>::value_type)
-   type_test(int&, boost::call_traits<int&>::reference)
-   type_test(const int&, boost::call_traits<int&>::const_reference)
-   type_test(int&, boost::call_traits<int&>::param_type)
-#if !(defined(__GNUC__) && (__GNUC__ < 3))
-   type_test(int&, boost::call_traits<cr_type>::value_type)
-   type_test(int&, boost::call_traits<cr_type>::reference)
-   type_test(const int&, boost::call_traits<cr_type>::const_reference)
-   type_test(int&, boost::call_traits<cr_type>::param_type)
-#else
-   std::cout << "Your compiler cannot instantiate call_traits<int&const>, skipping four tests (4 errors)" << std::endl;
-   failures += 4;
-   test_count += 4;
-#endif
-   type_test(const int&, boost::call_traits<const int&>::value_type)
-   type_test(const int&, boost::call_traits<const int&>::reference)
-   type_test(const int&, boost::call_traits<const int&>::const_reference)
-   type_test(const int&, boost::call_traits<const int&>::param_type)
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   type_test(const int*, boost::call_traits<int[3]>::value_type)
-   type_test(int(&)[3], boost::call_traits<int[3]>::reference)
-   type_test(const int(&)[3], boost::call_traits<int[3]>::const_reference)
-   type_test(const int*const, boost::call_traits<int[3]>::param_type)
-   type_test(const int*, boost::call_traits<const int[3]>::value_type)
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::reference)
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::const_reference)
-   type_test(const int*const, boost::call_traits<const int[3]>::param_type)
-#else
-   std::cout << "You're compiler does not support partial template instantiation, skipping 8 tests (8 errors)" << std::endl;
-   failures += 8;
-   test_count += 8;
-#endif
-#else
-   std::cout << "You're compiler does not support partial template instantiation, skipping 20 tests (20 errors)" << std::endl;
-   failures += 20;
-   test_count += 20;
-#endif
-
-   return check_result(argc, argv);
-}
-
-//
-// define call_traits tests to check that the assertions in the docs do actually work
-// this is an instantiate only set of tests:
-//
-template <typename T, bool isarray = false>
-struct call_traits_test
-{
-   typedef ::boost::call_traits<T> ct;
-   typedef typename ct::param_type param_type;
-   typedef typename ct::reference reference;
-   typedef typename ct::const_reference const_reference;
-   typedef typename ct::value_type value_type;
-   static void assert_construct(param_type val);
-};
-
-template <typename T, bool isarray>
-void call_traits_test<T, isarray>::assert_construct(typename call_traits_test<T, isarray>::param_type val)
-{
-   //
-   // this is to check that the call_traits assertions are valid:
-   T t(val);
-   value_type v(t);
-   reference r(t);
-   const_reference cr(t);
-   param_type p(t);
-   value_type v2(v);
-   value_type v3(r);
-   value_type v4(p);
-   reference r2(v);
-   reference r3(r);
-   const_reference cr2(v);
-   const_reference cr3(r);
-   const_reference cr4(cr);
-   const_reference cr5(p);
-   param_type p2(v);
-   param_type p3(r);
-   param_type p4(p);
-}
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T>
-struct call_traits_test<T, true>
-{
-   typedef ::boost::call_traits<T> ct;
-   typedef typename ct::param_type param_type;
-   typedef typename ct::reference reference;
-   typedef typename ct::const_reference const_reference;
-   typedef typename ct::value_type value_type;
-   static void assert_construct(param_type val);
-};
-
-template <typename T>
-void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>::param_type val)
-{
-   //
-   // this is to check that the call_traits assertions are valid:
-   T t;
-   value_type v(t);
-   value_type v5(val);
-   reference r = t;
-   const_reference cr = t;
-   reference r2 = r;
-   #ifndef __BORLANDC__
-   // C++ Builder buglet:
-   const_reference cr2 = r;
-   #endif
-   param_type p(t);
-   value_type v2(v);
-   const_reference cr3 = cr;
-   value_type v3(r);
-   value_type v4(p);
-   param_type p2(v);
-   param_type p3(r);
-   param_type p4(p);
-}
-#endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// now check call_traits assertions by instantiating call_traits_test:
-template struct call_traits_test<int>;
-template struct call_traits_test<const int>;
-template struct call_traits_test<int*>;
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
-template struct call_traits_test<int&>;
-template struct call_traits_test<const int&>;
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template struct call_traits_test<int[2], true>;
-#endif
-#endif
-
-#ifdef BOOST_MSVC
-unsigned int expected_failures = 10;
-#elif defined(__BORLANDC__)
-unsigned int expected_failures = 2;
-#elif defined(__GNUC__)
-unsigned int expected_failures = 4;
-#else
-unsigned int expected_failures = 0;
-#endif
-
-
-

counting_iterator.htm

@@ -1,325 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<title>Counting Iterator Adaptor Documentation</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
-align="center" width="277" height="86">
-
-<h1>Counting Iterator Adaptor</h1>
-
-Defined in header
-<a href="../../boost/counting_iterator.hpp">boost/counting_iterator.hpp</a>
-
-<p>
-How would you fill up a vector with the numbers zero
-through one hundred using <a
-href="http://www.sgi.com/tech/stl/copy.html"><tt>std::copy()</tt></a>? The
-only iterator operation missing from builtin integer types is an
-<tt>operator*()</tt> that returns the current
-value of the integer.  The counting iterator adaptor adds this crucial piece of
-functionality to whatever type it wraps. One can use the
-counting iterator adaptor not only with integer types, but with any
-type that is <tt>Incrementable</tt> (see type requirements <a href="#requirements">below</a>).  The
-following <b>pseudo-code</b> shows the general idea of how the
-counting iterator is implemented.
-</p>
-
-<pre>
-  // inside a hypothetical counting_iterator class...
-  typedef Incrementable value_type;
-  value_type counting_iterator::operator*() const {
-    return this->base; // no dereference!
-  }
-</pre>
-
-All of the other operators of the counting iterator behave in the same
-fashion as the <tt>Incrementable</tt> base type.
-
-<h2>Synopsis</h2>
-
-<pre>
-namespace boost {
-  template &lt;class Incrementable&gt;
-  struct <a href="#counting_iterator_traits">counting_iterator_traits</a>;
-
-  template &lt;class Incrementable&gt;
-  struct <a href="#counting_iterator_generator">counting_iterator_generator</a>;
-
-  template &lt;class Incrementable&gt;
-  typename counting_iterator_generator&lt;Incrementable&gt;::type
-  <a href="#make_counting_iterator">make_counting_iterator</a>(Incrementable x);
-}
-</pre>
-
-<hr>
-
-<h2><a name="counting_iterator_generator">The Counting Iterator Type
-Generator</a></h2>
-
-The class template <tt>counting_iterator_generator&lt;Incrementable&gt;</tt> is a <a href="../../more/generic_programming.html#type_generator">type generator</a> for counting iterators.
-
-<pre>
-template &lt;class Incrementable&gt;
-class counting_iterator_generator
-{
-public:
-    typedef <a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt; type;
-};
-</pre>
-
-<h3>Example</h3>
-
-In this example we use the counting iterator generator to create a
-counting iterator, and count from zero to four.
-
-<pre>
-#include &lt;boost/config.hpp&gt;
-#include &lt;iostream&gt;
-#include &lt;boost/counting_iterator.hpp&gt;
-
-int main(int, char*[])
-{
-  // Example of using counting_iterator_generator
-  std::cout &lt;&lt; "counting from 0 to 4:" &lt;&lt; std::endl;
-  boost::counting_iterator_generator&lt;int&gt;::type first(0), last(4);
-  std::copy(first, last, std::ostream_iterator&lt;int&gt;(std::cout, " "));
-  std::cout &lt;&lt; std::endl;
-
-  // to be continued...
-</pre>
-The output from this part is:
-<pre>
-counting from 0 to 4:
-0 1 2 3 
-</pre>
-
-<h3>Template Parameters</h3>
-
-<Table border>
-<TR>
-<TH>Parameter</TH><TH>Description</TH>
-</TR>
-
-<TR>
-<TD><tt>Incrementable</tt></TD>
-<TD>The type being wrapped by the adaptor.</TD>
-</TR>
-
-</Table>
-
-<h3>Model of</h3>
-
-If the <tt>Incrementable</tt> type has all of the functionality of a
-<a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
-Access Iterator</a> except the <tt>operator*()</tt>, then the counting
-iterator will be a model of <a
-href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
-Access Iterator</a>. If the <tt>Incrementable</tt> type has less
-functionality, then the counting iterator will have correspondingly
-less functionality.
-
-<h3><a name="requirements">Type Requirements</a></h3>
-
-The <tt>Incrementable</tt> type must be <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
-Constructible</a>, <a href="./CopyConstructible.html">Copy
-Constructible</a>, and <a href="./Assignable.html">Assignable</a>.
-Also, the <tt>Incrementable</tt> type must provide access to an
-associated <tt>difference_type</tt> and <tt>iterator_category</tt>
-through the <a
-href="#counting_iterator_traits"><tt>counting_iterator_traits</tt></a>
-class.
-
-<p>
-Furthermore, if you wish to create a counting iterator that is a <a
-href="http://www.sgi.com/tech/stl/ForwardIterator.html"> Forward
-Iterator</a>, then the following expressions must be valid:
-<pre>
-Incrementable i, j;
-++i         // pre-increment
-i == j      // operator equal
-</pre>
-If you wish to create a counting iterator that is a <a
-href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">
-Bidirectional Iterator</a>, then pre-decrement is also required:
-<pre>
---i
-</pre>
-If you wish to create a counting iterator that is a <a
-href="http://www.sgi.com/tech/stl/RandomAccessIterator.html"> Random
-Access Iterator</a>, then these additional expressions are also required:
-<pre>
-<a href="#counting_iterator_traits">counting_iterator_traits</a>&lt;Incrementable&gt;::difference_type n;
-i += n
-n = i - j
-i < j
-</pre>
-
-
-
-<h3>Members</h3>
-
-The counting iterator type implements the member functions and
-operators required of the <a
-href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
-Access Iterator</a> concept. In addition it has the following
-constructor:
-
-<pre>
-counting_iterator_generator::type(const Incrementable&amp; i)
-</pre>
-
-<p>
-<hr>
-<p>
-
-
-<h2><a name="make_counting_iterator">The Counting Iterator Object Generator</a></h2>
-
-<pre>
-template &lt;class Incrementable&gt;
-typename counting_iterator_generator&lt;Incrementable&gt;::type
-make_counting_iterator(Incrementable base);
-</pre>
-
-An <a href="../../more/generic_programming.html#object_generator">object
-generator</a> function that provides a convenient way to create counting
-iterators.<p>
-
-
-
-<h3>Example</h3>
-
-In this example we count from negative five to positive five, this
-time using the <tt>make_counting_iterator()</tt> function to save some
-typing.
-
-<pre>
-  // continuing from previous example...
-
-  std::cout &lt;&lt; "counting from -5 to 4:" &lt;&lt; std::endl;
-  std::copy(boost::make_counting_iterator(-5),
-	    boost::make_counting_iterator(5),
-	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
-  std::cout &lt;&lt; std::endl;
-
-  // to be continued...
-</pre>
-The output from this part is:
-<pre>
-counting from -5 to 4:
--5 -4 -3 -2 -1 0 1 2 3 4 
-</pre>
-
-In the next example we create an array of numbers, and then create a
-second array of pointers, where each pointer is the address of a
-number in the first array. The counting iterator makes it easy to do
-this since dereferencing a counting iterator that is wrapping an
-iterator over the array of numbers just returns a pointer to the
-current location in the array. We then use the <a
-href="./indirect_iterator.htm">indirect iterator adaptor</a> to print
-out the number in the array by accessing the numbers through the array
-of pointers.
-
-<pre>
-  // continuing from previous example...
-
-  const int N = 7;
-  std::vector&lt;int&gt; numbers;
-  // Fill "numbers" array with [0,N)
-  std::copy(boost::make_counting_iterator(0), boost::make_counting_iterator(N),
-	    std::back_inserter(numbers));
-
-  std::vector&lt;std::vector&lt;int&gt;::iterator&gt; pointers;
-
-  // Use counting iterator to fill in the array of pointers.
-  std::copy(boost::make_counting_iterator(numbers.begin()),
-	    boost::make_counting_iterator(numbers.end()),
-	    std::back_inserter(pointers));
-
-  // Use indirect iterator to print out numbers by accessing
-  // them through the array of pointers.
-  std::cout &lt;&lt; "indirectly printing out the numbers from 0 to " 
-	    &lt;&lt; N &lt;&lt; std::endl;
-  std::copy(boost::make_indirect_iterator(pointers.begin()),
-	    boost::make_indirect_iterator(pointers.end()),
-	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
-  std::cout &lt;&lt; std::endl;
-</pre>
-The output is:
-<pre>
-indirectly printing out the numbers from 0 to 7
-0 1 2 3 4 5 6 
-</pre>
-
-<hr>
-
-<h2><a name="counting_iterator_traits">Counting Iterator Traits</a></h2>
-
-The counting iterator adaptor needs to determine the appropriate
-<tt>difference_type</tt> and <tt>iterator_category</tt> to use based on the
-<tt>Incrementable</tt> type supplied by the user.  The
-<tt>counting_iterator_traits</tt> class provides these types.  If the
-<tt>Incrementable</tt> type is an integral type or an iterator, these types
-will be correctly deduced by the <tt>counting_iterator_traits</tt> provided by
-the library. Otherwise, the user must specialize
-<tt>counting_iterator_traits</tt> for her type or add nested typedefs to
-her type to fulfill the needs of
-<a href="http://www.sgi.com/tech/stl/iterator_traits.html">
-<tt>std::iterator_traits</tt></a>.
-
-<p>The following pseudocode describes how the <tt>counting_iterator_traits</tt> are determined:
-
-<pre>
-template &lt;class Incrementable&gt;
-struct counting_iterator_traits
-{
-  if (numeric_limits&lt;Incrementable&gt::is_specialized) {
-    if (!numeric_limits&lt;Incrementable&gt::is_integer)
-       COMPILE_TIME_ERROR;
-
-    if (!numeric_limits&lt;Incrementable&gt::is_bounded
-        &amp;&amp; numeric_limits&lt;Incrementable&gt;::is_signed) {
-        typedef Incrementable difference_type;
-    }
-    else if (numeric_limits&lt;Incrementable&gt::is_integral) {
-        typedef <i>next-larger-signed-type-or-intmax_t</i> difference_type;
-    }
-    typedef std::random_access_iterator_tag iterator_category;   
-  } else {
-    typedef std::iterator_traits&lt;Incrementable&gt;::difference_type difference_type;
-    typedef std::iterator_traits&lt;Incrementable&gt;::iterator_category iterator_category;
-  }
-};
-</pre>
-
-<p>The italicized sections above are implementation details, but it is important
-to know that the <tt>difference_type</tt> for integral types is selected so that
-it can always represent the difference between two values if such a built-in
-integer exists. On platforms with a working <tt>std::numeric_limits</tt>
-implementation, the <tt>difference_type</tt> for any variable-length signed
-integer type <tt>T</tt> is <tt>T</tt> itself.
-
-<hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->26 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14386" --></p>
-<p>© Copyright Jeremy Siek 2000. Permission to copy, use,
-modify, sell and distribute this document is granted provided this copyright
-notice appears in all copies. This document is provided &quot;as is&quot;
-without express or implied warranty, and with no claim as to its suitability for
-any purpose.</p>
-
-</body>
-
-</html>
-<!--  LocalWords:  html charset alt gif hpp incrementable const namespace htm
- -->
-<!--  LocalWords:  struct  typename iostream int Siek CopyConstructible pre
- -->
-

iterator_adaptor_test.cpp

@@ -0,0 +1,386 @@
+//  Demonstrate and test boost/operators.hpp on std::iterators  -------------//
+
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  08 Feb 01 Use Jeremy's new make_reverse_iterator form; add more
+//            comprehensive testing. Force-decay array function arguments to
+//            pointers.
+//  07 Feb 01 Added tests for the make_xxx_iterator() helper functions.
+//            (Jeremy Siek)
+//  07 Feb 01 Replaced use of xxx_pair_generator with xxx_generator where
+//            possible (which was all but the projection iterator).
+//            (Jeremy Siek)
+//  06 Feb 01 Removed now-defaulted template arguments where possible
+//            Updated names to correspond to new generator naming convention.
+//            Added a trivial test for make_transform_iterator().
+//            Gave traits for const iterators a mutable value_type, per std.
+//            Resurrected my original tests for indirect iterators.
+//            (David Abrahams)
+//  04 Feb 01 Fix for compilers without standard iterator_traits
+//            (David Abrahams)
+//  13 Jun 00 Added const version of the iterator tests (Jeremy Siek)
+//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
+
+#include <boost/config.hpp>
+#include <iostream>
+
+#include <algorithm>
+#include <functional>
+
+#include <boost/iterator_adaptors.hpp>
+#include <boost/pending/iterator_tests.hpp>
+#include <boost/pending/integer_range.hpp>
+#include <stdlib.h>
+#include <vector>
+#include <deque>
+#include <set>
+
+struct my_iterator_tag : public std::random_access_iterator_tag { };
+
+using boost::dummyT;
+
+struct my_iter_traits {
+  typedef dummyT value_type;
+  typedef dummyT* pointer;
+  typedef dummyT& reference;
+  typedef my_iterator_tag iterator_category;
+  typedef std::ptrdiff_t difference_type;
+};
+
+struct my_const_iter_traits {
+  typedef dummyT value_type;
+  typedef const dummyT* pointer;
+  typedef const dummyT& reference;
+  typedef my_iterator_tag iterator_category;
+  typedef std::ptrdiff_t difference_type;
+};
+
+typedef boost::iterator_adaptor<dummyT*, 
+  boost::default_iterator_policies, my_iter_traits> my_iterator;
+
+typedef boost::iterator_adaptor<const dummyT*, 
+  boost::default_iterator_policies, my_const_iter_traits> const_my_iterator;
+
+
+struct mult_functor {
+  typedef int result_type;
+  typedef int argument_type;
+  // Functors used with transform_iterator must be
+  // DefaultConstructible, as the transform_iterator must be
+  // DefaultConstructible to satisfy the requirements for
+  // TrivialIterator.
+  mult_functor() { }
+  mult_functor(int aa) : a(aa) { }
+  int operator()(int b) const { return a * b; }
+  int a;
+};
+
+template <class Pair>
+struct select1st_ 
+  : public std::unary_function<Pair, typename Pair::first_type>
+{
+  const typename Pair::first_type& operator()(const Pair& x) const {
+    return x.first;
+  }
+  typename Pair::first_type& operator()(Pair& x) const {
+    return x.first;
+  }
+};
+
+struct one_or_four {
+  bool operator()(dummyT x) const {
+    return x.foo() == 1 || x.foo() == 4;
+  }
+};
+
+typedef std::deque<int> storage;
+typedef std::deque<int*> pointer_deque;
+typedef std::set<storage::iterator> iterator_set;
+
+void more_indirect_iterator_tests()
+{
+// For some reason all heck breaks loose in the compiler under these conditions.
+#if !defined(BOOST_MSVC) || !defined(__STL_DEBUG)
+    storage store(1000);
+    std::generate(store.begin(), store.end(), rand);
+    
+    pointer_deque ptr_deque;
+    iterator_set iter_set;
+
+    for (storage::iterator p = store.begin(); p != store.end(); ++p)
+    {
+        ptr_deque.push_back(&*p);
+        iter_set.insert(p);
+    }
+
+    typedef boost::indirect_iterator_pair_generator<
+        pointer_deque::iterator
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+        , int, int*, int&, const int*, const int&
+#endif
+    > IndirectDeque;
+
+    IndirectDeque::iterator db(ptr_deque.begin());
+    IndirectDeque::iterator de(ptr_deque.end());
+    assert(static_cast<std::size_t>(de - db) == store.size());
+    assert(db + store.size() == de);
+    IndirectDeque::const_iterator dci(db);
+    assert(db == dci);
+    assert(dci == db);
+    assert(dci != de);
+    assert(dci < de);
+    assert(dci <= de);
+    assert(de >= dci);
+    assert(de > dci);
+    dci = de;
+    assert(dci == de);
+
+    boost::random_access_iterator_test(db + 1, store.size() - 1, boost::next(store.begin()));
+    
+    *db = 999;
+    assert(store.front() == 999);
+
+    typedef boost::indirect_iterator_generator<
+        iterator_set::iterator
+        >::type indirect_set_iterator;
+
+    typedef boost::indirect_iterator_generator<
+        iterator_set::iterator,
+        const int
+        >::type const_indirect_set_iterator;
+
+    indirect_set_iterator sb(iter_set.begin());
+    indirect_set_iterator se(iter_set.end());
+    const_indirect_set_iterator sci(iter_set.begin());
+    assert(sci == sb);
+    assert(sci != se);
+    sci = se;
+    assert(sci == se);
+    
+    *boost::prior(se) = 888;
+    assert(store.back() == 888);
+    assert(std::equal(sb, se, store.begin()));
+
+    boost::bidirectional_iterator_test(boost::next(sb), store[1], store[2]);
+    assert(std::equal(db, de, store.begin()));
+#endif    
+}
+
+int
+main()
+{
+  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+                     dummyT(3), dummyT(4), dummyT(5) };
+  const int N = sizeof(array)/sizeof(dummyT);
+
+  // sanity check, if this doesn't pass the test is buggy
+  boost::random_access_iterator_test(array,N,array);
+
+  // Check that the policy concept checks and the default policy
+  // implementation match up.
+  boost::function_requires< 
+     boost::RandomAccessIteratorPoliciesConcept<
+       boost::default_iterator_policies, int*,
+       boost::iterator<std::random_access_iterator_tag, int, std::ptrdiff_t,
+                      int*, int&>
+      > >();
+
+  // Test the iterator_adaptor
+  {
+    my_iterator i = array;
+    boost::random_access_iterator_test(i, N, array);
+    
+    const_my_iterator j = array;
+    boost::random_access_iterator_test(j, N, array);
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+  // Test transform_iterator
+  {
+    int x[N], y[N];
+    for (int k = 0; k < N; ++k)
+      x[k] = k;
+    std::copy(x, x + N, y);
+
+    for (int k2 = 0; k2 < N; ++k2)
+      x[k2] = x[k2] * 2;
+
+    boost::transform_iterator_generator<mult_functor, int*>::type
+      i(y, mult_functor(2));
+    boost::input_iterator_test(i, x[0], x[1]);
+    boost::input_iterator_test(boost::make_transform_iterator(&y[0], mult_functor(2)), x[0], x[1]);
+  }
+  
+  // Test indirect_iterator_generator
+  {
+    dummyT* ptr[N];
+    for (int k = 0; k < N; ++k)
+      ptr[k] = array + k;
+
+    typedef boost::indirect_iterator_generator<dummyT**
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+        , dummyT
+#endif
+      >::type indirect_iterator;
+
+    typedef boost::indirect_iterator_generator<dummyT**, const dummyT>::type const_indirect_iterator;
+
+    indirect_iterator i = ptr;
+    boost::random_access_iterator_test(i, N, array);
+
+    typedef boost::iterator<std::random_access_iterator_tag, dummyT> InnerTraits;
+    
+//    boost::random_access_iterator_test(boost::make_indirect_iterator(ptr, InnerTraits()), N, array);
+
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+//    boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
+#endif
+    
+    const_indirect_iterator j = ptr;
+    boost::random_access_iterator_test(j, N, array);
+
+    dummyT*const* const_ptr = ptr;
+    
+    typedef boost::iterator<std::random_access_iterator_tag,dummyT,std::ptrdiff_t,const dummyT*,const dummyT&> ConstInnerTraits;
+//    boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr, ConstInnerTraits()), N, array);
+
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+//    boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr), N, array);
+#endif
+
+    boost::const_nonconst_iterator_test(i, ++j);
+
+    more_indirect_iterator_tests();
+  }
+  
+  // Test projection_iterator_pair_generator
+  {    
+    typedef std::pair<dummyT,dummyT> Pair;
+    Pair pair_array[N];
+    for (int k = 0; k < N; ++k)
+      pair_array[k].first = array[k];
+
+    typedef boost::projection_iterator_pair_generator<select1st_<Pair>,
+      Pair*, const Pair*
+      > Projection;
+    
+    Projection::iterator i = pair_array;
+    boost::random_access_iterator_test(i, N, array);
+
+    boost::random_access_iterator_test(boost::make_projection_iterator(pair_array, select1st_<Pair>()), N, array);    
+    boost::random_access_iterator_test(boost::make_projection_iterator< select1st_<Pair> >(pair_array), N, array);    
+
+    Projection::const_iterator j = pair_array;
+    boost::random_access_iterator_test(j, N, array);
+
+    boost::random_access_iterator_test(boost::make_const_projection_iterator(pair_array, select1st_<Pair>()), N, array);
+    boost::random_access_iterator_test(boost::make_const_projection_iterator< select1st_<Pair> >(pair_array), N, array);
+
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+  // Test reverse_iterator_generator
+  {
+    dummyT reversed[N];
+    std::copy(array, array + N, reversed);
+    std::reverse(reversed, reversed + N);
+    
+    typedef boost::reverse_iterator_generator<dummyT*, 
+      boost::iterator<std::random_access_iterator_tag,dummyT>
+      >::type reverse_iterator;
+    typedef boost::reverse_iterator_generator<const dummyT*,
+      boost::iterator<std::random_access_iterator_tag,const dummyT>
+      >::type const_reverse_iterator;
+    reverse_iterator i = reversed + N;
+    boost::random_access_iterator_test(i, N, array);
+
+    typedef boost::iterator<std::random_access_iterator_tag,dummyT> ReverseTraits;
+    boost::random_access_iterator_test(boost::make_reverse_iterator<ReverseTraits>(reversed + N), N, array);
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+#endif
+
+    const_reverse_iterator j = reversed + N;
+    boost::random_access_iterator_test(j, N, array);
+
+    const dummyT* const_reversed = reversed;
+    typedef boost::iterator<std::random_access_iterator_tag,const dummyT> ConstReverseTraits;
+    boost::random_access_iterator_test(boost::make_reverse_iterator<ConstReverseTraits>(const_reversed + N), N, array);
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+#endif
+
+    boost::const_nonconst_iterator_test(i, ++j);    
+  }
+
+  // Test reverse_iterator_generator again, with traits fully deducible on most platforms
+#if !defined(BOOST_MSVC) || defined(__SGI_STL_PORT)
+  {
+    std::deque<dummyT> reversed_container;
+    std::copy(array, array + N, std::back_inserter(reversed_container));
+    const std::deque<dummyT>::iterator reversed = reversed_container.begin();
+    std::reverse(reversed, reversed + N);
+    
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::iterator>::type reverse_iterator;
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::const_iterator>::type const_reverse_iterator;
+
+    reverse_iterator i = reversed + N;
+    boost::random_access_iterator_test(i, N, array);
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+
+    const_reverse_iterator j = reverse_iterator(reversed + N);
+    boost::random_access_iterator_test(j, N, array);
+
+    const std::deque<dummyT>::const_iterator const_reversed = reversed;
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+
+#if !defined(__GNUC__) || defined(__SGI_STL_PORT)  // GCC deque iterators don't allow all const/non-const comparisons
+    boost::const_nonconst_iterator_test(i, ++j);
+#endif
+  }
+#endif
+  
+  // Test integer_range's iterators
+  {
+    int int_array[] = { 0, 1, 2, 3, 4, 5 };
+    boost::integer_range<int> r(0, 5);
+    boost::random_access_iterator_test(r.begin(), r.size(), int_array);
+  }
+
+  // Test filter iterator
+  {
+    typedef boost::filter_iterator_generator<one_or_four, dummyT*,
+      boost::iterator<std::forward_iterator_tag, dummyT, std::ptrdiff_t,
+      dummyT*, dummyT&> > FilterGen;
+    typedef FilterGen::type FilterIter;
+    typedef FilterGen::policies_type FilterPolicies;
+    FilterIter i(array, FilterPolicies(one_or_four(), array + N));
+    boost::forward_iterator_test(i, dummyT(1), dummyT(4));
+
+    typedef boost::iterator<std::forward_iterator_tag, dummyT, std::ptrdiff_t, dummyT*, dummyT&> FilterTraits;
+    boost::forward_iterator_test(boost::make_filter_iterator<FilterTraits>
+       (array, array + N, one_or_four() ), dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(boost::make_filter_iterator<FilterTraits, one_or_four>
+        (array, array + N), dummyT(1), dummyT(4));
+
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+    boost::forward_iterator_test(boost::make_filter_iterator(
+        array, array + N, one_or_four()), dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(boost::make_filter_iterator<one_or_four>(
+        array, array + N), dummyT(1), dummyT(4));
+#endif
+    
+
+  }
+  std::cout << "test successful " << std::endl;
+  return 0;
+}

iterator_adaptors.htm

@@ -1,789 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-<head>
-    <meta name="generator" content="HTML Tidy, see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-    <meta name="ProgId" content="FrontPage.Editor.Document">
-
-    <title>Boost Iterator Adaptor Library</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-    <img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
-    "center" width="277" height="86"> 
-
-    <h1>Boost Iterator Adaptor Library</h1>
-
-    <h2>Introduction</h2>
-
-    <p>The Iterator Adaptor library allows you transform an arbitrary ``base''
-    type into a standard-conforming iterator with the behaviors you choose.
-    Doing so is especially easy if the ``base'' type is itself an iterator. The
-    library also supplies several example <a href=
-    "../../more/generic_programming.html#adaptors">adaptors</a> which apply
-    specific useful behaviors to arbitrary base iterators.
-
-    <h2>Table of Contents</h2>
-
-    <ul>
-      <li>
-        Header <tt><a href=
-        "../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a></tt>
-        
-
-        <ul>
-          <li>
-            Generalized Iterator Adaptor 
-
-            <ul>
-              <li>Class template <tt><a href=
-              "#iterator_adaptor">iterator_adaptor</a></tt>
-
-              <li><a href="#template_parameters">Template Parameters</a>
-
-              <li><a href="#policies">The Policies Class</a>
-
-              <li><a href="#additional_members">Additional Class Members</a>
-
-              <li><a href="#example">Example</a>
-
-              <li>(<tt>const</tt>/non-<tt>const</tt>) <a href=
-              "#iterator_interactions">Iterator Interactions</a>
-
-              <li><a href="#challenge">Challenge</a>
-
-              <li><a href="#concept_model">Concept Model</a>
-
-              <li><a href="#declaration_synopsis">Declaration Synopsis</a>
-
-              <li><a href="#notes">Notes</a>
-            </ul>
-
-          <li>
-            Specialized Iterator Adaptors 
-
-            <ul>
-              <li><a href="indirect_iterator.htm">Indirect Iterator Adaptor</a>
-
-              <li><a href="reverse_iterator.htm">Reverse Iterator Adaptor</a>
-
-              <li><a href="transform_iterator.htm">Transform Iterator
-              Adaptor</a>
-
-              <li><a href="projection_iterator.htm">Projection Iterator
-              Adaptor</a>
-
-              <li><a href="filter_iterator.htm">Filter Iterator Adaptor</a>
-            </ul>
-        </ul>
-
-      <li>Header <tt><a href=
-      "../../boost/counting_iterator.hpp">boost/counting_iterator.hpp</a></tt><br>
-
-       <a href="counting_iterator.htm">Counting Iterator Adaptor</a>
-
-      <li>Header <tt><a href=
-      "../../boost/function_output_iterator.hpp">boost/function_output_iterator.hpp</a></tt><br>
-
-       <a href="function_output_iterator.htm">Function Output Iterator Adaptor</a>
-    </ul>
-
-    <p><b><a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-    Abrahams</a></b> started the library, applying <a href=
-    "../../more/generic_programming.html#policy">policy class</a> technique and
-    handling const/non-const iterator interactions. He also contributed the
-    <tt><a href="indirect_iterator.htm">indirect_</a></tt> and <tt><a href=
-    "reverse_iterator.htm">reverse_</a></tt> iterator generators, and expanded
-    <tt><a href="counting_iterator.htm">counting_iterator_generator</a></tt> to
-    cover all incrementable types. He edited most of the documentation,
-    sometimes heavily.<br>
-     <b><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy
-    Siek</a></b> contributed the <a href="transform_iterator.htm">transform
-    iterator</a> adaptor, the integer-only version of <tt><a href=
-    "counting_iterator.htm">counting_iterator_generator</a></tt>, 
-    the <a href="function_output_iterator.htm">function output iterator</a> 
-    adaptor, and most of the documentation.<br>
-     <b><a href="http://www.boost.org/people/john_potter.htm">John
-    Potter</a></b> contributed the <tt><a href=
-    "projection_iterator.htm">projection_</a></tt> and <tt><a href=
-    "filter_iterator.htm">filter_</a></tt> iterator generators and made some
-    simplifications to the main <tt><a href=
-    "#iterator_adaptor">iterator_adaptor</a></tt> template.<br>
-
-
-    <h2><a name="iterator_adaptor">Class template</a>
-    <tt>iterator_adaptor</tt></h2>
-    Implementing standard conforming iterators is a non-trivial task. There are
-    some fine points such as the interactions between an iterator and its
-    corresponding const_iterator, and there are myriad operators that should be
-    implemented but are easily forgotten or mishandled, such as
-    <tt>operator-&gt;()</tt>. Using <tt>iterator_adaptor</tt>, you can easily
-    implement an iterator class, and even more easily extend and <a href=
-    "../../more/generic_programming.html#adaptors">adapt</a> existing iterator
-    types. Moreover, it is easy to make a pair of interoperable <tt>const</tt>
-    and <tt>non-const</tt> iterators. 
-
-    <p><tt>iterator_adaptor</tt> is declared like this:
-<pre>
-template &lt;class Base, class Policies, 
-    class Value = typename std::iterator_traits&lt;Base&gt;::value_type,
-    class Reference = <i>...(see below)</i>,
-    class Pointer = <i>...(see below)</i>,
-    class Category = typename std::iterator_traits&lt;Base&gt;::iterator_category,
-    class Distance = typename std::iterator_traits&lt;Base&gt;::difference_type&gt;
-struct iterator_adaptor;
-</pre>
-
-    <h3><a name="template_parameters">Template Parameters</a></h3>
-
-    <p>Although <tt>iterator_adaptor</tt> takes seven template parameters,
-    defaults have been carefully chosen to minimize the number of parameters
-    you must supply in most cases, especially if <tt>BaseType</tt> is an
-    iterator.
-
-    <table border="1" summary="iterator_adaptor template parameters">
-      <tr>
-        <th>Parameter
-
-        <th>Description
-
-      <tr>
-        <td><tt>BaseType</tt> 
-
-        <td>The type being wrapped.
-
-      <tr>
-        <td><tt>Policies</tt> 
-
-        <td>A <a href="../../more/generic_programming.html#policy">policy
-        class</a> that supplies core functionality to the resulting iterator. A
-        detailed description can be found <a href="#policies">below</a>.
-
-      <tr>
-        <td><tt>Value</tt> 
-
-        <td>The <tt>value_type</tt> of the resulting iterator, unless const. If
-        Value is <tt>const X</tt> the
-        <tt>value_type</tt> will be (<i>non-</i><tt>const</tt>) <tt>X</tt><a href=
-        "#1">[1]</a>.<br>
-         <b>Default:</b>
-        <tt>std::iterator_traits&lt;BaseType&gt;::value_type</tt> <a href=
-        "#2">[2]</a>
-
-      <tr>
-        <td><tt>Reference</tt> 
-
-        <td>The <tt>reference</tt> type of the resulting iterator, and in
-        particular, the result type of <tt>operator*()</tt>.<br>
-         <b>Default:</b> If <tt>Value</tt> is supplied, <tt>Value&amp;</tt> is
-        used. Otherwise
-        <tt>std::iterator_traits&lt;BaseType&gt;::reference</tt> is used.
-
-      <tr>
-        <td><tt>Pointer</tt> 
-
-        <td>The <tt>pointer</tt> type of the resulting iterator, and in
-        particular, the result type of <tt>operator-&gt;()</tt>.<br>
-         <b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
-        otherwise <tt>std::iterator_traits&lt;BaseType&gt;::pointer</tt>.
-
-      <tr>
-        <td><tt>Category</tt> 
-
-        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
-         <b>Default:</b>
-        <tt>std::iterator_traits&lt;BaseType&gt;::iterator_category</tt> 
-
-      <tr>
-        <td><tt>Distance</tt> 
-
-        <td>The <tt>difference_type</tt> for the resulting iterator.<br>
-         <b>Default:</b>
-        <tt>std::iterator_traits&lt;BaseType&gt;::difference_type</tt> 
-    </table>
-
-    <h3><a name="policies">The Policies Class</a></h3>
-
-    <p>The main task in using <tt>iterator_adaptor</tt> is creating an
-    appropriate <tt>Policies</tt> class. The <tt>Policies</tt> class will
-    become the functional heart of the iterator adaptor, supplying the core
-    iterator operations that will determine how your new adaptor class will
-    behave. The <tt>iterator_adaptor</tt> template defines all of the operators
-    required of a <a href=
-    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
-    Iterator</a>. Your <tt>Policies</tt> class must implement three, four, or
-    seven of the core iterator operations below depending on the iterator
-    categories you want it to support.<br>
-    <br>
-    
-
-    <table border="1" summary="iterator_adaptor Policies operations">
-      <caption>
-        <b>Core Iterator Operations</b><br>
-        <tt>T</tt>: iterator type; <tt>p</tt>: object of type T; <tt>n</tt>: <tt>T::size_type</tt>; <tt>x</tt>: <tt>T::difference_type</tt>; <tt>p1</tt>, <tt>p2</tt>: iterators
-      </caption>
-
-      <tr>
-        <th>Operation
-
-        <th>Effects
-
-        <th>Implements Operations
-
-        <th>Required for Iterator Categories
-
-      <tr>
-        <td><tt>dereference</tt> 
-
-        <td>returns an element of the iterator's <tt>reference</tt> type
-        
-        <td><tt>*p</tt>, <tt>p[n]</tt>
-
-        <td rowspan="3"><a href=
-        "http://www.sgi.com/tech/stl/InputIterator.html">Input</a>/ <a href=
-        "http://www.sgi.com/tech/stl/OutputIterator.html">Output</a>/ <a href=
-        "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward</a>/ <a
-        href=
-        "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional</a>/
-        <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
-        Access</a> 
-
-      <tr>
-        <td><tt>equal</tt> 
-
-        <td>tests the iterator for equality
-
-        <td><tt>p1&nbsp;==&nbsp;p2</tt>, <tt>p1&nbsp;!=&nbsp;p2</tt>
-
-      <tr>
-        <td><tt>increment</tt> 
-
-        <td>increments the iterator
-
-        <td><tt>++p</tt>, <tt>p++</tt>
-
-      <tr>
-        <td><tt>decrement</tt> 
-
-        <td>decrements the iterator
-
-        <td><tt>--p</tt>, <tt>p--</tt>
-
-        <td><a href=
-        "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional</a>/
-        <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
-        Access</a> 
-
-      <tr>
-        <td><tt>less</tt> 
-
-        <td>imposes a <a href=
-        "http://www.sgi.com/tech/stl/StrictWeakOrdering.html">Strict Weak
-        Ordering</a> relation on iterators
-
-        <td> 
-           <tt>p1&nbsp;&lt;&nbsp;p2</tt>,
-           <tt>p1&nbsp;&lt;=&nbsp;p2</tt>,
-           <tt>p1&nbsp;&gt;&nbsp;p2</tt>,
-           <tt>p1&nbsp;&gt;=&nbsp;p2</tt>
-
-        <td rowspan="3"><a href=
-        "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
-        Access</a> 
-
-      <tr>
-        <td><tt>distance</tt> 
-
-        <td>measures the distance between iterators
-
-        <td><tt>p1 - p2</tt>
-
-      <tr>
-        <td><tt>advance</tt> 
-
-        <td>adds an integer offset to iterators
-
-        <td>
-<tt>p&nbsp;+&nbsp;x</tt>,
-<tt>x&nbsp;+&nbsp;p</tt>,
-<tt>p&nbsp;+=&nbsp;x</tt>,
-<tt>p&nbsp;-&nbsp;x</tt>,
-<tt>p&nbsp;-=&nbsp;x</tt>
-        
-    </table>
-
-    <p>The library also supplies a "trivial" policy class,
-    <tt>default_iterator_policies</tt>, which implements all seven of the core
-    operations in the usual way. If you wish to create an iterator adaptor that
-    only changes a few of the base type's behaviors, then you can derive your
-    new policy class from <tt>default_iterator_policies</tt> to avoid retyping
-    the usual behaviors. You should also look at
-    <tt>default_iterator_policies</tt> as the ``boilerplate'' for your own
-    policy classes, defining functions with the same interface. This is the
-    definition of <tt>default_iterator_policies</tt>:<br>
-    <br>
-
-    <blockquote>
-<pre>
-struct <a name="default_iterator_policies">default_iterator_policies</a>
-{
-  template &lt;class Reference, class BaseType&gt;
-  Reference dereference(type&lt;Reference&gt;, const BaseType&amp; x) const
-    { return *x; }
-
-  template &lt;class BaseType&gt;
-  static void increment(BaseType&amp; x)
-    { ++x; }
-
-  template &lt;class BaseType1, class BaseType2&gt;
-  bool equal(BaseType1&amp; x, BaseType2&amp; y) const
-    { return x == y; }
-
-  template &lt;class BaseType&gt;
-  static void decrement(BaseType&amp; x)
-    { --x; }
-
-  template &lt;class BaseType, class DifferenceType&gt;
-  static void advance(BaseType&amp; x, DifferenceType n)
-    { x += n; }
-
-  template &lt;class Difference, class BaseType1, class BaseType2&gt;
-  Difference distance(type&lt;Difference&gt;, BaseType1&amp; x, BaseType2&amp; y) const
-    { return y - x; }
-
-  template &lt;class BaseType1, class BaseType2&gt;
-  bool less(BaseType1&amp; x, BaseType2&amp; y) const
-    { return x &lt; y; }
-};
-</pre>
-    </blockquote>
-
-    <p>Template member functions are used throughout
-    <tt>default_iterator_policies</tt> so that it can be employed with a wide
-    range of iterators. If we had used concrete types above, we'd have tied the
-    usefulness of <tt>default_iterator_policies</tt> to a particular range of
-    adapted iterators. If you follow the same pattern with your
-    <tt>Policies</tt> classes, you may achieve the same sort of reusability.
-
-    <h3><a name="additional_members">Additional Members</a></h3>
-    In addition to all of the member functions required of a <a href=
-    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
-    Iterator</a>, the <tt>iterator_adaptor</tt> class template defines the
-    following members. <br>
-     <br>
-     
-
-    <table border="1" summary="additional iterator_adaptor members">
-      <tr>
-        <td><tt>explicit iterator_adaptor(const Base&amp;, const Policies&amp; =
-        Policies())</tt>
-         <br><br>
-         Construct an adapted iterator from a base object and a policies
-         object. As this constructor is <tt>explicit</tt>, it does not
-         provide for implicit conversions from the <tt>Base</tt> type to
-         the iterator adaptor.
-
-      <tr>
-        <td><tt>template &lt;class B, class V, class R, class P&gt;<br>
-         iterator_adaptor(const
-        iterator_adaptor&lt;B,Policies,V,R,P,Category,Distance&gt;&amp;)</tt>
-        <br><br>
-         This constructor allows for conversion from non-<tt>const</tt> to
-        constant adapted iterators. See <a href=
-        "#iterator_interactions">below</a> for more details.<br>
-         Requires: <tt>B</tt> is convertible to <tt>Base</tt>.
-
-      <tr>
-        <td><tt>base_type base() const;</tt>
-         <br><br>
-         Return a copy of the base object.
-    </table>
-
-    <h3><a name="example">Example</a></h3>
-
-    <p>It is often useful to automatically apply some function to the value
-    returned by dereferencing an iterator. The <a href=
-    "./transform_iterator.htm">transform iterator</a> makes it easy to create
-    an iterator adaptor which does just that. Here we will show how easy it is
-    to implement the transform iterator using the <tt>iterator_adaptor</tt>
-    template.
-
-    <p>We want to be able to adapt a range of iterators and functions, so the
-    policies class will have a template parameter for the function type and it
-    will have a data member of that type. We know that the function takes one
-    argument and that we'll need to be able to deduce the <tt>result_type</tt>
-    of the function so we can use it for the adapted iterator's
-    <tt>value_type</tt>. <a href=
-    "http://www.sgi.com/Technology/STL/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>
-    is the <a href="../../more/generic_programming.html#concept">Concept</a>
-    that fulfills those requirements.
-
-    <p>To implement a transform iterator we will only change one of the base
-    iterator's behaviors, so the <tt>transform_iterator_policies</tt> class can
-    inherit the rest from <tt>default_iterator_policies</tt>. We will define
-    the <tt>dereference()</tt> member function, which is used to implement
-    <tt>operator*()</tt> of the adapted iterator. The implementation will
-    dereference the base iterator and apply the function object. The
-    <tt>type&lt;Reference&gt;</tt> parameter is used to convey the appropriate
-    return type. The complete code for <tt>transform_iterator_policies</tt>
-    is:<br>
-    <br>
-
-
-    <blockquote>
-<pre>
-  template &lt;class AdaptableUnaryFunction&gt;
-  struct transform_iterator_policies : public default_iterator_policies
-  {
-    transform_iterator_policies() { }
-
-    transform_iterator_policies(const AdaptableUnaryFunction&amp; f)
-      : m_f(f) { }
-
-    template &lt;class Reference, class BaseIterator&gt;
-    Reference dereference(type&lt;Reference&gt;, const BaseIterator&amp; i) const
-      { return m_f(*i); }
-
-    AdaptableUnaryFunction m_f;
-  };
-</pre>
-    </blockquote>
-
-    <p>The next step is to use the <tt>iterator_adaptor</tt> template to
-    construct the transform iterator type. The nicest way to package the
-    construction of the transform iterator is to create a <a href=
-    "../../more/generic_programming.html#type_generator">type generator</a>.
-    The first template parameter to the generator will be the type of the
-    function object and the second will be the base iterator type. We use
-    <tt>iterator_adaptor</tt> to define the transform iterator type as a nested
-    <tt>typedef</tt> inside the <tt>transform_iterator_generator</tt> class.
-    Because the function may return by-value, we must limit the
-    <tt>iterator_category</tt> to <a href=
-    "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>, and
-    the iterator's <tt>reference</tt> type cannot be a true reference (the
-    standard allows this for input iterators), so in this case we can use few
-    of <tt>iterator_adaptor</tt>'s default template arguments.<br>
-    <br>
-
-
-    <blockquote>
-<pre>
-template &lt;class AdaptableUnaryFunction, class Iterator&gt;
-struct transform_iterator_generator
-{
-    typedef typename AdaptableUnaryFunction::result_type value_type;
-public:
-    typedef iterator_adaptor&lt;Iterator, 
-        transform_iterator_policies&lt;AdaptableUnaryFunction&gt;,
-        value_type, value_type, value_type*, std::input_iterator_tag&gt;
-      type;
-};
-</pre>
-    </blockquote>
-
-    <p>As a finishing touch, we will create an <a href=
-    "../../more/generic_programming.html#object_generator">object generator</a>
-    for the transform iterator. This is a function that makes it more
-    convenient to create a transform iterator.<br>
-    <br>
-
-
-    <blockquote>
-<pre>
-template &lt;class AdaptableUnaryFunction, class Iterator&gt;
-typename transform_iterator_generator&lt;AdaptableUnaryFunction,Iterator&gt;::type
-make_transform_iterator(Iterator base,
-                        const AdaptableUnaryFunction&amp; f = AdaptableUnaryFunction())
-{
-    typedef typename transform_iterator_generator&lt;AdaptableUnaryFunction,
-      Iterator&gt;::type result_t;
-    return result_t(base, f);
-}
-</pre>
-    </blockquote>
-
-    <p>Here is an example that shows how to use a transform iterator to iterate
-    through a range of numbers, multiplying each of them by 2 and printing the
-    result to standard output.<br>
-    <br>
-
-
-    <blockquote>
-<pre>
-#include &lt;functional&gt;
-#include &lt;algorithm&gt;
-#include &lt;iostream&gt;
-#include &lt;boost/iterator_adaptors.hpp&gt;
-
-int main(int, char*[])
-{
-  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
-  const int N = sizeof(x)/sizeof(int);
-  std::cout &lt;&lt; "multiplying the array by 2:" &lt;&lt; std::endl;
-  std::copy(boost::make_transform_iterator(x, std::bind1st(std::multiplies&lt;int&gt;(), 2)),
-      boost::make_transform_iterator(x + N, std::bind1st(std::multiplies&lt;int&gt;(), 2)),
-      std::ostream_iterator&lt;int&gt;(std::cout, " "));
-  std::cout &lt;&lt; std::endl;
-  return 0;
-}
-</pre>
-      This output is: 
-<pre>
-2 4 6 8 10 12 14 16
-</pre>
-    </blockquote>
-
-    <h3><a name="iterator_interactions">Iterator Interactions</a></h3>
-
-    <p>C++ allows <tt>const</tt> and non-<tt>const</tt> pointers to interact in
-    the following intuitive ways:
-
-    <ul>
-      <li>a non-<tt>const</tt> pointer to <tt>T</tt> can be implicitly
-      converted to a <tt>const</tt> pointer to <tt>T</tt>.
-
-      <li><tt>const</tt> and non-<tt>const</tt> pointers to <tt>T</tt> can be
-      freely mixed in comparison expressions.
-
-      <li><tt>const</tt> and non-<tt>const</tt> pointers to <tt>T</tt> can be
-      freely subtracted, in any order.
-    </ul>
-
-    Getting user-defined iterators to work together that way is nontrivial (see
-    <a href="reverse_iterator.htm#interactions">here</a> for an example of where
-    the C++ standard got it wrong), but <tt>iterator_adaptor</tt> can make it
-    easy. The rules are as follows:
-
-    <ul>
-      <li><a name="interoperable">Adapted iterators that share the same <tt>Policies</tt>,
-      <tt>Category</tt>, and <tt>Distance</tt> parameters are called
-      <i>interoperable</i>.</a>
-
-      <li>An adapted iterator can be implicitly converted to any other adapted
-      iterator with which it is interoperable, so long as the <tt>Base</tt>
-      type of the source iterator can be converted to the <tt>Base</tt> type of
-      the target iterator.
-
-      <li>Interoperable iterators can be freely mixed in comparison expressions
-      so long as the <tt>Policies</tt> class has <tt>equal</tt> (and, for
-      random access iterators, <tt>less</tt>) members that can accept both
-      <tt>Base</tt> types in either order.
-
-      <li>Interoperable iterators can be freely mixed in subtraction
-      expressions so long as the <tt>Policies</tt> class has a
-      <tt>distance</tt> member that can accept both <tt>Base</tt> types in
-      either order.
-    </ul>
-
-    <h4>Example</h4>
-    
-    <p>The <a href="projection_iterator.htm">Projection Iterator</a> adaptor is similar to the <a
-href="./transform_iterator.htm">transform iterator adaptor</a> in that
-its <tt>operator*()</tt> applies some function to the result of
-dereferencing the base iterator and then returns the result. The
-difference is that the function must return a reference to some
-existing object (for example, a data member within the
-<tt>value_type</tt> of the base iterator). 
-
-    <p>
-The <a
-    href="projection_iterator.htm#projection_iterator_pair_generator">projection_iterator_pair_generator</a> template
-    is a special two-<a href="../../more/generic_programming.html#type_generator">type generator</a> for mutable and constant versions of a
-    projection iterator. It is defined as follows:
-<blockquote>
-<pre>
-template &lt;class AdaptableUnaryFunction, class Iterator, class ConstIterator&gt;
-struct projection_iterator_pair_generator {
-    typedef typename AdaptableUnaryFunction::result_type value_type;
-    typedef projection_iterator_policies&lt;AdaptableUnaryFunction&gt; policies;
-public:
-    typedef iterator_adaptor&lt;Iterator,policies,value_type&gt; iterator;
-    typedef iterator_adaptor&lt;ConstIterator,policies,value_type,
-        const value_type&amp;,const value_type*&gt; const_iterator;
-};
-</pre>
-</blockquote>
-
-<p>It is assumed that the <tt>Iterator</tt> and <tt>ConstIterator</tt> arguments are corresponding mutable
-and constant iterators. <ul>
-<li>
-Clearly, then, the
-<tt>projection_iterator_pair_generator</tt>'s <tt>iterator</tt> and
-<tt>const_iterator</tt> are <a href="#interoperable">interoperable</a>, since
-they share the same <tt>Policies</tt> and since <tt>Category</tt> and
-<tt>Distance</tt> as supplied by <tt>std::iterator_traits</tt> through the
-<a href="#template_parameters">default template parameters</a> to
-<tt>iterator_adaptor</tt> should be the same.
-
-<li>Since <tt>Iterator</tt> can presumably be converted to
-<tt>ConstIterator</tt>, the projection <tt>iterator</tt> will be convertible to
-the projection <tt>const_iterator</tt>.
-
-<li> Since <tt>projection_iterator_policies</tt> implements only the
-<tt>dereference</tt> operation, and inherits all other behaviors from <tt><a
-href="#default_iterator_policies">default_iterator_policies</a></tt>, which has
-fully-templatized <tt>equal</tt>, <tt>less</tt>, and <tt>distance</tt>
-operations, the <tt>iterator</tt> and <tt>const_iterator</tt> can be freely
-mixed in comparison and subtraction expressions.
-
-</ul>
-
-    <h3><a name="challenge">Challenge</a></h3>
-
-    <p>There is an unlimited number of ways the <tt>iterator_adaptors</tt>
-    class can be used to create iterators. One interesting exercise would be to
-    re-implement the iterators of <tt>std::list</tt> and <tt>std::slist</tt>
-    using <tt>iterator_adaptors</tt>, where the adapted <tt>Iterator</tt> types
-    would be node pointers.
-
-    <h3><a name="concept_model">Concept Model</a></h3>
-    Depending on the <tt>Base</tt> and <tt>Policies</tt> template parameters,
-    an <tt>iterator_adaptor</tt> can be a <a href=
-    "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>, <a
-    href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
-    Iterator</a>, <a href=
-    "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional
-    Iterator</a>, or <a href=
-    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
-    Iterator</a>. 
-
-    <h3><a name="declaration_synopsis">Declaration Synopsis</a></h3>
-<pre>
-template &lt;class Base, class Policies, 
-    class Value = typename std::iterator_traits&lt;Base&gt;::value_type,
-    class Reference = <i>...(see below)</i>,
-    class Pointer = <i>...(see below)</i>,
-    class Category = typename std::iterator_traits&lt;Base&gt;::iterator_category,
-    class Distance = typename std::iterator_traits&lt;Base&gt;::difference_type
-         &gt;
-struct iterator_adaptor
-{
-    typedef Distance difference_type;
-    typedef typename boost::remove_const&lt;Value&gt;::type value_type;
-    typedef Pointer pointer;
-    typedef Reference reference;
-    typedef Category iterator_category;
-    typedef Base base_type;
-    typedef Policies policies_type;
-
-    iterator_adaptor();
-    explicit iterator_adaptor(const Base&amp;, const Policies&amp; = Policies());
-
-    base_type base() const;
-
-    template &lt;class B, class V, class R, class P&gt;
-    iterator_adaptor(
-        const iterator_adaptor&lt;B,Policies,V,R,P,Category,Distance&gt;&amp;);
-
-    reference operator*() const;
-    <i>operator_arrow_result_type</i> operator-&gt;() const; <a href=
-"#3">[3]</a>
-    <i>value_type</i> operator[](difference_type n) const; <a href="#3">[4]</a>
-
-    iterator_adaptor&amp; operator++();
-    iterator_adaptor&amp; operator++(int);
-    iterator_adaptor&amp; operator--();
-    iterator_adaptor&amp; operator--(int);
-
-    iterator_adaptor&amp; operator+=(difference_type n);
-    iterator_adaptor&amp; operator-=(difference_type n);
-
-    iterator_adaptor&amp; operator-(Distance x) const;
-};
-
-template &lt;class B, class P, class V, class R, class Ptr, 
-    class C, class D1, class D2&gt;
-iterator_adaptor&lt;B,P,V,R,Ptr,C,D1&gt;
-operator+(iterator_adaptor&lt;B,P,V,R,Ptr,C,D1&gt;, D2);
-
-template &lt;class B, class P, class V, class R, class Ptr,
-    class C, class D1, class D2&gt;
-iterator_adaptor&lt;B,P,V,R,P,C,D1&gt;
-operator+(D2, iterator_adaptor&lt;B,P,V,R,Ptr,C,D1&gt; p);
-
-template &lt;class B1, class B2, class P, class V1, class V2,
-    class R1, class R2, class P1, class P2, class C, class D&gt;
-Distance operator-(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;, 
-                   const iterator_adaptor&lt;B2,P,V2,R2,P2,C,D&gt;&amp;);
-
-template &lt;class B1, class B2, class P, class V1, class V2,
-    class R1, class R2, class P1, class P2, class C, class D&gt;
-bool operator==(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;, 
-                const iterator_adaptor&lt;B2,P,V2,R2,P2,C,D&gt;&amp;);
-
-// and similarly for operators !=, &lt;, &lt;=, &gt;=, &gt;
-</pre>
-
-    <h3><a name="notes">Notes</a></h3>
-
-    <p><a name="1">[1]</a> The standard specifies that the <tt>value_type</tt>
-    of <tt>const</tt> iterators to <tt>T</tt> (e.g. <tt>const T*</tt>) is
-    <tt><i>non-</i>const T</tt>, while the <tt>pointer</tt> and
-    <tt>reference</tt> types for all <a href=
-    "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterators</a> are
-    <tt>const T*</tt> and <tt>const T&amp;</tt>, respectively. Stripping the
-    <tt>const</tt>-ness of <tt>Value</tt> allows you to easily
-    make a <tt>const</tt> iterator adaptor by supplying a <tt>const</tt> type
-    for <tt>Value</tt>, and allowing the defaults for the <tt>Pointer</tt> and
-    <tt>Reference</tt> parameters to take effect. Although compilers that don't
-    support partial specialization won't strip <tt>const</tt> for you, having a
-    <tt>const value_type</tt> is often harmless in practice.
-
-    <p><a name="2">[2]</a> If your compiler does not support partial
-    specialization and the base iterator is a builtin pointer type, you
-    will not be able to use the default for <tt>Value</tt> and will have to
-    specify this type explicitly.
-
-    <p><a name="3">[3]</a> The result type for the <tt>operator-&gt;()</tt>
-    depends on the category and value type of the iterator and is somewhat
-    complicated to describe. But be assured, it works in a stardard conforming
-    fashion, providing access to members of the objects pointed to by the
-    iterator.
-
-    <p><a name="4">[4]</a> The result type of <tt>operator[]()</tt> is
-    <tt>value_type</tt> instead of <tt>reference</tt> as might be expected.
-    There are two reasons for this choice. First, the C++ standard only
-    requires that the return type of an arbitrary <a href=
-    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
-    Iterator</a>'s <tt>operator[]</tt>be ``convertible to T'' (Table 76), so
-    when adapting an arbitrary base iterator we may not have a reference to
-    return. Second, and more importantly, for certain kinds of iterators,
-    returning a reference could cause serious memory problems due to the
-    reference being bound to a temporary object whose lifetime ends inside of
-    the <tt>operator[]</tt>.
-    <hr>
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->27 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14388" -->
-
-
-    <p>&copy; Copyright Dave Abrahams and Jeremy Siek 2001. Permission to copy,
-    use, modify, sell and distribute this document is granted provided this
-    copyright notice appears in all copies. This document is provided "as is"
-    without express or implied warranty, and with no claim as to its
-    suitability for any purpose. 
-
-</body>
-
-    <!--  LocalWords:  HTML html charset alt gif abrahams htm const
-        incrementable david abrahams
-         -->
-     
-    <!--  LocalWords:  jeremy siek mishandled interoperable typename struct Iter iter src
-         -->
-     
-    <!--  LocalWords:  int bool ForwardIterator BidirectionalIterator BaseIterator
-         -->
-     
-    <!--  LocalWords:  RandomAccessIterator DifferenceType AdaptableUnaryFunction
-         -->
-     
-    <!--  LocalWords:  iostream hpp sizeof InputIterator constness ConstIterator
-         David Abrahams
-         -->
-</body>
-</html>
-