This commit was manufactured by cvs2svn to create branch

'unlabeled-1.11.2'.

[SVN r9365]

include/boost/assert.hpp

@@ -1,38 +0,0 @@
-//
-//  boost/assert.hpp - BOOST_ASSERT(expr)
-//
-//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-//
-//  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.
-//
-//  Note: There are no include guards. This is intentional.
-//
-//  See http://www.boost.org/libs/utility/assert.html for documentation.
-//
-
-#undef BOOST_ASSERT
-
-#if defined(BOOST_DISABLE_ASSERTS)
-
-# define BOOST_ASSERT(expr) ((void)0)
-
-#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
-
-#include <boost/current_function.hpp>
-
-namespace boost
-{
-
-void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
-
-} // namespace boost
-
-#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
-
-#else
-# include <assert.h>
-# define BOOST_ASSERT(expr) assert(expr)
-#endif

include/boost/call_traits.hpp

@@ -1,23 +0,0 @@
-//  (C) Copyright Boost.org 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.
-
-//  See http://www.boost.org/libs/utility/call_traits.htm for Documentation.
-//  See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
-//  for full copyright notices.
-
-#ifndef BOOST_CALL_TRAITS_HPP
-#define BOOST_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/detail/ob_call_traits.hpp>
-#else
-#include <boost/detail/call_traits.hpp>
-#endif
-
-#endif // BOOST_CALL_TRAITS_HPP

include/boost/checked_delete.hpp

@@ -1,63 +0,0 @@
-#ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
-#define BOOST_CHECKED_DELETE_HPP_INCLUDED
-
-#if _MSC_VER >= 1020
-#pragma once
-#endif
-
-//
-//  boost/checked_delete.hpp
-//
-//  Copyright (c) 1999, 2000, 2001, 2002 boost.org
-//  Copyright (c) 2002, 2003 Peter Dimov
-//
-//  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/libs/utility/checked_delete.html for documentation.
-//
-
-namespace boost
-{
-
-// verify that types are complete for increased safety
-
-template<class T> inline void checked_delete(T * x)
-{
-    typedef char type_must_be_complete[sizeof(T)];
-    delete x;
-}
-
-template<class T> inline void checked_array_delete(T * x)
-{
-    typedef char type_must_be_complete[sizeof(T)];
-    delete [] x;
-}
-
-template<class T> struct checked_deleter
-{
-    typedef void result_type;
-    typedef T * argument_type;
-
-    void operator()(T * x) const
-    {
-        boost::checked_delete(x);
-    }
-};
-
-template<class T> struct checked_array_deleter
-{
-    typedef void result_type;
-    typedef T * argument_type;
-
-    void operator()(T * x) const
-    {
-        boost::checked_array_delete(x);
-    }
-};
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED

include/boost/compressed_pair.hpp

@@ -1,23 +0,0 @@
-//  (C) Copyright Boost.org 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.
-
-//  See http://www.boost.org for most recent version including documentation.
-//  See boost/detail/compressed_pair.hpp and boost/detail/ob_compressed_pair.hpp
-//  for full copyright notices.
-
-#ifndef BOOST_COMPRESSED_PAIR_HPP
-#define BOOST_COMPRESSED_PAIR_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/detail/ob_compressed_pair.hpp>
-#else
-#include <boost/detail/compressed_pair.hpp>
-#endif
-
-#endif // BOOST_COMPRESSED_PAIR_HPP

include/boost/current_function.hpp

@@ -1,62 +0,0 @@
-#ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
-#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
-
-#if _MSC_VER >= 1020
-#pragma once
-#endif
-
-//
-//  boost/current_function.hpp - BOOST_CURRENT_FUNCTION
-//
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//
-//  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.
-//
-//  http://www.boost.org/libs/utility/current_function.html
-//
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void current_function_helper()
-{
-
-#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600))
-
-# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
-
-#elif defined(__FUNCSIG__)
-
-# define BOOST_CURRENT_FUNCTION __FUNCSIG__
-
-#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
-
-# define BOOST_CURRENT_FUNCTION __FUNCTION__
-
-#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
-
-# define BOOST_CURRENT_FUNCTION __FUNC__
-
-#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
-
-# define BOOST_CURRENT_FUNCTION __func__
-
-#else
-
-# define BOOST_CURRENT_FUNCTION "(unknown)"
-
-#endif
-
-}
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED

include/boost/generator_iterator.hpp

@@ -1,75 +0,0 @@
-// (C) Copyright Jens Maurer 2001. 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.
-//
-// 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_adaptors.hpp>
-#include <boost/ref.hpp>
-
-namespace boost {
-
-template<class Generator>
-class generator_iterator_policies
-{
-public:
-    generator_iterator_policies() { }
-
-    template<class Base>
-    void initialize(Base& base) {
-      m_value = (*base)();
-    }
-
-    // The Iter template argument is necessary for compatibility with a MWCW
-    // bug workaround
-    template <class IteratorAdaptor>
-    void increment(IteratorAdaptor& iter) {
-      m_value = (*iter.base())();
-    }
-
-    template <class IteratorAdaptor>
-    const typename Generator::result_type&
-    dereference(const IteratorAdaptor&) const
-        { return m_value; }
-
-    template <class IteratorAdaptor1, class IteratorAdaptor2>
-    bool equal(const IteratorAdaptor1& x, const IteratorAdaptor2& y) const
-        { return x.base() == y.base() &&
-            x.policies().m_value == y.policies().m_value; }
-
-private:
-  typename Generator::result_type m_value;
-};
-
-template<class Generator>
-struct generator_iterator_generator
-{
-  typedef iterator_adaptor<Generator*, generator_iterator_policies<Generator>,
-    typename Generator::result_type, const typename Generator::result_type&,
-    const typename Generator::result_type*, std::input_iterator_tag,
-    long>       type;
-};
-
-template <class Generator>
-inline typename generator_iterator_generator<Generator>::type
-make_generator_iterator(Generator & gen)
-{
-  typedef typename generator_iterator_generator<Generator>::type result_t;
-  return result_t(&gen);
-}
-
-} // namespace boost
-
-
-#endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
-

include/boost/next_prior.hpp

@@ -1,33 +0,0 @@
-//  Boost next_prior.hpp header file  ---------------------------------------//
-
-//  (C) Copyright Boost.org 1999-2003. 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/libs/utility for documentation.
-
-#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
-#define BOOST_NEXT_PRIOR_HPP_INCLUDED
-
-namespace boost {
-
-//  Helper functions for classes like bidirectional iterators not supporting
-//  operator+ and operator-
-//
-//  Usage:
-//    const std::list<T>::iterator p = get_some_iterator();
-//    const std::list<T>::iterator prev = boost::prior(p);
-
-//  Contributed by Dave Abrahams
-
-template <class T>
-inline T next(T x) { return ++x; }
-
-template <class T>
-inline T prior(T x) { return --x; }
-
-} // namespace boost
-
-#endif  // BOOST_NEXT_PRIOR_HPP_INCLUDED

include/boost/noncopyable.hpp

@@ -1,33 +0,0 @@
-//  Boost noncopyable.hpp header file  --------------------------------------//
-
-//  (C) Copyright Boost.org 1999-2003. 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/libs/utility for documentation.
-
-#ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
-#define BOOST_NONCOPYABLE_HPP_INCLUDED
-
-namespace boost {
-
-//  Private copy constructor and copy assignment ensure classes derived from
-//  class noncopyable cannot be copied.
-
-//  Contributed by Dave Abrahams
-
-class noncopyable
-{
- protected:
-    noncopyable() {}
-    ~noncopyable() {}
- private:  // emphasize the following members are private
-    noncopyable( const noncopyable& );
-    const noncopyable& operator=( const noncopyable& );
-};
-
-} // namespace boost
-
-#endif  // BOOST_NONCOPYABLE_HPP_INCLUDED

include/boost/operators.hpp

@@ -1,957 +0,0 @@
-//  Boost operators.hpp header file  ----------------------------------------//
-
-//  (C) Copyright David Abrahams, Jeremy Siek, and Daryle Walker 1999-2001.
-//  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/libs/utility/operators.htm for documentation.
-
-//  Revision History
-//  04 May 05 Added operator class bool_testable.  (Sam Partington)
-//  21 Oct 02 Modified implementation of operators to allow compilers with a
-//            correct named return value optimization (NRVO) to produce optimal
-//            code.  (Daniel Frey)
-//  02 Dec 01 Bug fixed in random_access_iteratable.  (Helmut Zeisel)
-//  28 Sep 01 Factored out iterator operator groups.  (Daryle Walker)
-//  27 Aug 01 'left' form for non commutative operators added;
-//            additional classes for groups of related operators added;
-//            workaround for empty base class optimization
-//            bug of GCC 3.0 (Helmut Zeisel)
-//  25 Jun 01 output_iterator_helper changes: removed default template 
-//            parameters, added support for self-proxying, additional 
-//            documentation and tests (Aleksey Gurtovoy)
-//  29 May 01 Added operator classes for << and >>.  Added input and output
-//            iterator helper classes.  Added classes to connect equality and
-//            relational operators.  Added classes for groups of related
-//            operators.  Reimplemented example operator and iterator helper
-//            classes in terms of the new groups.  (Daryle Walker, with help
-//            from Alexy Gurtovoy)
-//  11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
-//            supplied arguments from actually being used (Dave Abrahams)
-//  04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
-//            refactoring of compiler workarounds, additional documentation
-//            (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
-//            Dave Abrahams) 
-//  28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
-//            Jeremy Siek (Dave Abrahams)
-//  20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
-//            (Mark Rodgers)
-//  20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
-//  10 Jun 00 Support for the base class chaining technique was added
-//            (Aleksey Gurtovoy). See documentation and the comments below 
-//            for the details. 
-//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
-//  18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
-//            specializations of dividable, subtractable, modable (Ed Brey) 
-//  17 Nov 99 Add comments (Beman Dawes)
-//            Remove unnecessary specialization of operators<> (Ed Brey)
-//  15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
-//            operators.(Beman Dawes)
-//  12 Nov 99 Add operators templates (Ed Brey)
-//  11 Nov 99 Add single template parameter version for compilers without
-//            partial specialization (Beman Dawes)
-//  10 Nov 99 Initial version
-
-// 10 Jun 00:
-// An additional optional template parameter was added to most of 
-// operator templates to support the base class chaining technique (see 
-// documentation for the details). Unfortunately, a straightforward
-// implementation of this change would have broken compatibility with the
-// previous version of the library by making it impossible to use the same
-// template name (e.g. 'addable') for both the 1- and 2-argument versions of
-// an operator template. This implementation solves the backward-compatibility
-// issue at the cost of some simplicity.
-//
-// One of the complications is an existence of special auxiliary class template
-// 'is_chained_base<>' (see 'detail' namespace below), which is used
-// to determine whether its template parameter is a library's operator template
-// or not. You have to specialize 'is_chained_base<>' for each new 
-// operator template you add to the library.
-//
-// However, most of the non-trivial implementation details are hidden behind 
-// several local macros defined below, and as soon as you understand them,
-// you understand the whole library implementation. 
-
-#ifndef BOOST_OPERATORS_HPP
-#define BOOST_OPERATORS_HPP
-
-#include <boost/config.hpp>
-#include <boost/iterator.hpp>
-#include <boost/preprocessor/seq/cat.hpp>
-
-#if defined(__sgi) && !defined(__GNUC__)
-#   pragma set woff 1234
-#endif
-
-#if defined(BOOST_MSVC)
-#   pragma warning( disable : 4284 ) // complaint about return type of 
-#endif                               // operator-> not begin a UDT
-
-namespace boost {
-namespace detail {
-
-// Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
-#if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
-class empty_base {
-  bool dummy; 
-};
-#else
-class empty_base {};
-#endif
-
-} // namespace detail
-} // namespace boost
-
-// In this section we supply the xxxx1 and xxxx2 forms of the operator
-// templates, which are explicitly targeted at the 1-type-argument and
-// 2-type-argument operator forms, respectively. Some compilers get confused
-// when inline friend functions are overloaded in namespaces other than the
-// global namespace. When BOOST_NO_OPERATORS_IN_NAMESPACE is defined, all of
-// these templates must go in the global namespace.
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-namespace boost
-{
-#endif
-
-//  Basic operator classes (contributed by Dave Abrahams) ------------------//
-
-//  Note that friend functions defined in a class are implicitly inline.
-//  See the C++ std, 11.4 [class.friend] paragraph 5
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct less_than_comparable2 : B
-{
-     friend bool operator<=(const T& x, const U& y) { return !(x > y); }
-     friend bool operator>=(const T& x, const U& y) { return !(x < y); }
-     friend bool operator>(const U& x, const T& y)  { return y < x; }
-     friend bool operator<(const U& x, const T& y)  { return y > x; }
-     friend bool operator<=(const U& x, const T& y) { return !(y < x); }
-     friend bool operator>=(const U& x, const T& y) { return !(y > x); }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct less_than_comparable1 : B
-{
-     friend bool operator>(const T& x, const T& y)  { return y < x; }
-     friend bool operator<=(const T& x, const T& y) { return !(y < x); }
-     friend bool operator>=(const T& x, const T& y) { return !(x < y); }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct equality_comparable2 : B
-{
-     friend bool operator==(const U& y, const T& x) { return x == y; }
-     friend bool operator!=(const U& y, const T& x) { return !(x == y); }
-     friend bool operator!=(const T& y, const U& x) { return !(y == x); }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct equality_comparable1 : B
-{
-     friend bool operator!=(const T& x, const T& y) { return !(x == y); }
-};
-
-// A macro which produces "name_2left" from "name".
-#define BOOST_OPERATOR2_LEFT(name) BOOST_PP_SEQ_CAT_S(1,(name)(2)(_)(left))
-
-//  NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
-
-#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-// This is the optimal implementation for ISO/ANSI C++,
-// but it requires the compiler to implement the NRVO.
-// If the compiler has no NRVO, this is the best symmetric
-// implementation available.
-
-#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
-struct NAME##2 : B                                                            \
-{                                                                             \
-  friend T operator OP( const T& lhs, const U& rhs )                          \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
-  friend T operator OP( const U& lhs, const T& rhs )                          \
-    { T nrv( rhs ); nrv OP##= lhs; return nrv; }                              \
-};                                                                            \
-                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
-struct NAME##1 : B                                                            \
-{                                                                             \
-  friend T operator OP( const T& lhs, const T& rhs )                          \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
-};
-
-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )           \
-template <class T, class U, class B = ::boost::detail::empty_base>  \
-struct NAME##2 : B                                                  \
-{                                                                   \
-  friend T operator OP( const T& lhs, const U& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
-};                                                                  \
-                                                                    \
-template <class T, class U, class B = ::boost::detail::empty_base>  \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                               \
-{                                                                   \
-  friend T operator OP( const U& lhs, const T& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
-};                                                                  \
-                                                                    \
-template <class T, class B = ::boost::detail::empty_base>           \
-struct NAME##1 : B                                                  \
-{                                                                   \
-  friend T operator OP( const T& lhs, const T& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
-};
-
-#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-// For compilers without NRVO the following code is optimal, but not
-// symmetric!  Note that the implementation of
-// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
-// optimization opportunities to the compiler :)
-
-#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
-struct NAME##2 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
-  friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; }       \
-};                                                                            \
-                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
-struct NAME##1 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
-};
-
-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-template <class T, class U, class B = ::boost::detail::empty_base>      \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
-};                                                                      \
-                                                                        \
-template <class T, class U, class B = ::boost::detail::empty_base>      \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
-{                                                                       \
-  friend T operator OP( const U& lhs, const T& rhs )                    \
-    { return T( lhs ) OP##= rhs; }                                      \
-};                                                                      \
-                                                                        \
-template <class T, class B = ::boost::detail::empty_base>               \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
-};
-
-#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
-BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
-BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
-BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
-
-#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
-#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
-#undef BOOST_OPERATOR2_LEFT
-
-//  incrementable and decrementable contributed by Jeremy Siek
-
-template <class T, class B = ::boost::detail::empty_base>
-struct incrementable : B
-{
-  friend T operator++(T& x, int)
-  {
-    incrementable_type nrv(x);
-    ++x;
-    return nrv;
-  }
-private: // The use of this typedef works around a Borland bug
-  typedef T incrementable_type;
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct decrementable : B
-{
-  friend T operator--(T& x, int)
-  {
-    decrementable_type nrv(x);
-    --x;
-    return nrv;
-  }
-private: // The use of this typedef works around a Borland bug
-  typedef T decrementable_type;
-};
-
-//  Iterator operator classes (contributed by Jeremy Siek) ------------------//
-
-template <class T, class P, class B = ::boost::detail::empty_base>
-struct dereferenceable : B
-{
-  P operator->() const
-  { 
-    return &*static_cast<const T&>(*this); 
-  }
-};
-
-template <class T, class I, class R, class B = ::boost::detail::empty_base>
-struct indexable : B
-{
-  R operator[](I n) const
-  {
-    return *(static_cast<const T&>(*this) + n);
-  }
-};
-
-//  bool_testable -----------------------------------------------------------//
-//  (contributed by Sam Partington, David Abrahams and Daniel Frey) ---------//
-
-template <class T, class B = ::boost::detail::empty_base>
-struct bool_testable : B
-{
-    friend bool operator!(const T& t) { return !static_cast<bool>(t); }
-private:
-    typedef signed char private_number_type;
-    operator private_number_type() const;
-};
- 
-//  More operator classes (contributed by Daryle Walker) --------------------//
-//  (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
-
-#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-#define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
-struct NAME##2 : B                                                            \
-{                                                                             \
-  friend T operator OP( const T& lhs, const U& rhs )                          \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
-};                                                                            \
-                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
-struct NAME##1 : B                                                            \
-{                                                                             \
-  friend T operator OP( const T& lhs, const T& rhs )                          \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
-};
-
-#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-#define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
-struct NAME##2 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
-};                                                                            \
-                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
-struct NAME##1 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
-};
-
-#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-BOOST_BINARY_OPERATOR( left_shiftable, << )
-BOOST_BINARY_OPERATOR( right_shiftable, >> )
-
-#undef BOOST_BINARY_OPERATOR
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct equivalent2 : B
-{
-  friend bool operator==(const T& x, const U& y)
-  {
-    return !(x < y) && !(x > y);
-  }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct equivalent1 : B
-{
-  friend bool operator==(const T&x, const T&y)
-  {
-    return !(x < y) && !(y < x);
-  }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct partially_ordered2 : B
-{
-  friend bool operator<=(const T& x, const U& y)
-    { return (x < y) || (x == y); }
-  friend bool operator>=(const T& x, const U& y)
-    { return (x > y) || (x == y); }
-  friend bool operator>(const U& x, const T& y)
-    { return y < x; }
-  friend bool operator<(const U& x, const T& y)
-    { return y > x; }
-  friend bool operator<=(const U& x, const T& y)
-    { return (y > x) || (y == x); }
-  friend bool operator>=(const U& x, const T& y)
-    { return (y < x) || (y == x); }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct partially_ordered1 : B
-{
-  friend bool operator>(const T& x, const T& y)
-    { return y < x; }
-  friend bool operator<=(const T& x, const T& y)
-    { return (x < y) || (x == y); }
-  friend bool operator>=(const T& x, const T& y)
-    { return (y < x) || (x == y); }
-};
-
-//  Combined operator classes (contributed by Daryle Walker) ----------------//
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct totally_ordered2
-    : less_than_comparable2<T, U
-    , equality_comparable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct totally_ordered1
-    : less_than_comparable1<T
-    , equality_comparable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct additive2
-    : addable2<T, U
-    , subtractable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct additive1
-    : addable1<T
-    , subtractable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct multiplicative2
-    : multipliable2<T, U
-    , dividable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct multiplicative1
-    : multipliable1<T
-    , dividable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct integer_multiplicative2
-    : multiplicative2<T, U
-    , modable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct integer_multiplicative1
-    : multiplicative1<T
-    , modable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct arithmetic2
-    : additive2<T, U
-    , multiplicative2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct arithmetic1
-    : additive1<T
-    , multiplicative1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct integer_arithmetic2
-    : additive2<T, U
-    , integer_multiplicative2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct integer_arithmetic1
-    : additive1<T
-    , integer_multiplicative1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct bitwise2
-    : xorable2<T, U
-    , andable2<T, U
-    , orable2<T, U, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct bitwise1
-    : xorable1<T
-    , andable1<T
-    , orable1<T, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct unit_steppable
-    : incrementable<T
-    , decrementable<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct shiftable2
-    : left_shiftable2<T, U
-    , right_shiftable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct shiftable1
-    : left_shiftable1<T
-    , right_shiftable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct ring_operators2
-    : additive2<T, U
-    , subtractable2_left<T, U
-    , multipliable2<T, U, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct ring_operators1
-    : additive1<T
-    , multipliable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct ordered_ring_operators2
-    : ring_operators2<T, U
-    , totally_ordered2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct ordered_ring_operators1
-    : ring_operators1<T
-    , totally_ordered1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct field_operators2
-    : ring_operators2<T, U
-    , dividable2<T, U
-    , dividable2_left<T, U, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct field_operators1
-    : ring_operators1<T
-    , dividable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct ordered_field_operators2
-    : field_operators2<T, U
-    , totally_ordered2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct ordered_field_operators1
-    : field_operators1<T
-    , totally_ordered1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct euclidian_ring_operators2
-    : ring_operators2<T, U
-    , dividable2<T, U
-    , dividable2_left<T, U
-    , modable2<T, U
-    , modable2_left<T, U, B
-      > > > > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct euclidian_ring_operators1
-    : ring_operators1<T
-    , dividable1<T
-    , modable1<T, B
-      > > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct ordered_euclidian_ring_operators2
-    : totally_ordered2<T, U
-    , euclidian_ring_operators2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct ordered_euclidian_ring_operators1
-    : totally_ordered1<T
-    , euclidian_ring_operators1<T, B
-      > > {};
-      
-template <class T, class P, class B = ::boost::detail::empty_base>
-struct input_iteratable
-    : equality_comparable1<T
-    , incrementable<T
-    , dereferenceable<T, P, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct output_iteratable
-    : incrementable<T, B
-      > {};
-
-template <class T, class P, class B = ::boost::detail::empty_base>
-struct forward_iteratable
-    : input_iteratable<T, P, B
-      > {};
-
-template <class T, class P, class B = ::boost::detail::empty_base>
-struct bidirectional_iteratable
-    : forward_iteratable<T, P
-    , decrementable<T, B
-      > > {};
-
-//  To avoid repeated derivation from equality_comparable,
-//  which is an indirect base class of bidirectional_iterable,
-//  random_access_iteratable must not be derived from totally_ordered1
-//  but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
-template <class T, class P, class D, class R, class B = ::boost::detail::empty_base>
-struct random_access_iteratable
-    : bidirectional_iteratable<T, P
-    , less_than_comparable1<T
-    , additive2<T, D
-    , indexable<T, D, R, B
-      > > > > {};
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-} // namespace boost
-#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
-
-
-// BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE4 -
-//
-// When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
-// operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
-// for one-argument forms of operator templates; BOOST_IMPORT_TEMPLATE2 for
-// two-argument forms. Note that these macros expect to be invoked from within
-// boost.
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-
-  // The template is already in boost so we have nothing to do.
-# define BOOST_IMPORT_TEMPLATE4(template_name)
-# define BOOST_IMPORT_TEMPLATE3(template_name)
-# define BOOST_IMPORT_TEMPLATE2(template_name)
-# define BOOST_IMPORT_TEMPLATE1(template_name)
-
-#else // BOOST_NO_OPERATORS_IN_NAMESPACE
-
-#  ifndef BOOST_NO_USING_TEMPLATE
-
-     // Bring the names in with a using-declaration
-     // to avoid stressing the compiler.
-#    define BOOST_IMPORT_TEMPLATE4(template_name) using ::template_name;
-#    define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name;
-#    define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
-#    define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
-
-#  else
-
-     // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
-     // from working, we are forced to use inheritance for that compiler.
-#    define BOOST_IMPORT_TEMPLATE4(template_name)                                          \
-     template <class T, class U, class V, class W, class B = ::boost::detail::empty_base>  \
-     struct template_name : ::template_name<T, U, V, W, B> {};
-
-#    define BOOST_IMPORT_TEMPLATE3(template_name)                                 \
-     template <class T, class U, class V, class B = ::boost::detail::empty_base>  \
-     struct template_name : ::template_name<T, U, V, B> {};
-
-#    define BOOST_IMPORT_TEMPLATE2(template_name)                              \
-     template <class T, class U, class B = ::boost::detail::empty_base>        \
-     struct template_name : ::template_name<T, U, B> {};
-
-#    define BOOST_IMPORT_TEMPLATE1(template_name)                              \
-     template <class T, class B = ::boost::detail::empty_base>                 \
-     struct template_name : ::template_name<T, B> {};
-
-#  endif // BOOST_NO_USING_TEMPLATE
-
-#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
-
-//
-// Here's where we put it all together, defining the xxxx forms of the templates
-// in namespace boost. We also define specializations of is_chained_base<> for
-// the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
-// neccessary.
-//
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-// is_chained_base<> - a traits class used to distinguish whether an operator
-// template argument is being used for base class chaining, or is specifying a
-// 2nd argument type.
-
-namespace boost {
-// A type parameter is used instead of a plain bool because Borland's compiler
-// didn't cope well with the more obvious non-type template parameter.
-namespace detail {
-  struct true_t {};
-  struct false_t {};
-} // namespace detail
-
-// Unspecialized version assumes that most types are not being used for base
-// class chaining. We specialize for the operator templates defined in this
-// library.
-template<class T> struct is_chained_base {
-  typedef ::boost::detail::false_t value;
-};
-
-} // namespace boost
-
-// Import a 4-type-argument operator template into boost (if neccessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE4(template_name4)                     \
-  BOOST_IMPORT_TEMPLATE4(template_name4)                              \
-  template<class T, class U, class V, class W, class B>               \
-  struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > {  \
-    typedef ::boost::detail::true_t value;                            \
-  };
-
-// Import a 3-type-argument operator template into boost (if neccessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE3(template_name3)                     \
-  BOOST_IMPORT_TEMPLATE3(template_name3)                              \
-  template<class T, class U, class V, class B>                        \
-  struct is_chained_base< ::boost::template_name3<T, U, V, B> > {     \
-    typedef ::boost::detail::true_t value;                            \
-  };
-
-// Import a 2-type-argument operator template into boost (if neccessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE2(template_name2)                  \
-  BOOST_IMPORT_TEMPLATE2(template_name2)                           \
-  template<class T, class U, class B>                              \
-  struct is_chained_base< ::boost::template_name2<T, U, B> > {     \
-    typedef ::boost::detail::true_t value;                         \
-  };
-
-// Import a 1-type-argument operator template into boost (if neccessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE1(template_name1)                  \
-  BOOST_IMPORT_TEMPLATE1(template_name1)                           \
-  template<class T, class B>                                       \
-  struct is_chained_base< ::boost::template_name1<T, B> > {        \
-    typedef ::boost::detail::true_t value;                         \
-  };
-
-// BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
-// can be used for specifying both 1-argument and 2-argument forms. Requires the
-// existence of two previously defined class templates named '<template_name>1'
-// and '<template_name>2' which must implement the corresponding 1- and 2-
-// argument forms.
-//
-// The template type parameter O == is_chained_base<U>::value is used to
-// distinguish whether the 2nd argument to <template_name> is being used for
-// base class chaining from another boost operator template or is describing a
-// 2nd operand type. O == true_t only when U is actually an another operator
-// template from the library. Partial specialization is used to select an
-// implementation in terms of either '<template_name>1' or '<template_name>2'.
-//
-
-# define BOOST_OPERATOR_TEMPLATE(template_name)                    \
-template <class T                                                  \
-         ,class U = T                                              \
-         ,class B = ::boost::detail::empty_base                    \
-         ,class O = typename is_chained_base<U>::value             \
-         >                                                         \
-struct template_name : template_name##2<T, U, B> {};               \
-                                                                   \
-template<class T, class U, class B>                                \
-struct template_name<T, U, B, ::boost::detail::true_t>             \
-  : template_name##1<T, U> {};                                     \
-                                                                   \
-template <class T, class B>                                        \
-struct template_name<T, T, B, ::boost::detail::false_t>            \
-  : template_name##1<T, B> {};                                     \
-                                                                   \
-template<class T, class U, class B, class O>                       \
-struct is_chained_base< ::boost::template_name<T, U, B, O> > {     \
-  typedef ::boost::detail::true_t value;                           \
-};                                                                 \
-                                                                   \
-BOOST_OPERATOR_TEMPLATE2(template_name##2)                         \
-BOOST_OPERATOR_TEMPLATE1(template_name##1)
-
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#  define BOOST_OPERATOR_TEMPLATE4(template_name4) \
-        BOOST_IMPORT_TEMPLATE4(template_name4)
-#  define BOOST_OPERATOR_TEMPLATE3(template_name3) \
-        BOOST_IMPORT_TEMPLATE3(template_name3)
-#  define BOOST_OPERATOR_TEMPLATE2(template_name2) \
-        BOOST_IMPORT_TEMPLATE2(template_name2)
-#  define BOOST_OPERATOR_TEMPLATE1(template_name1) \
-        BOOST_IMPORT_TEMPLATE1(template_name1)
-
-   // In this case we can only assume that template_name<> is equivalent to the
-   // more commonly needed template_name1<> form.
-#  define BOOST_OPERATOR_TEMPLATE(template_name)                   \
-   template <class T, class B = ::boost::detail::empty_base>       \
-   struct template_name : template_name##1<T, B> {};
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace boost {
-    
-BOOST_OPERATOR_TEMPLATE(less_than_comparable)
-BOOST_OPERATOR_TEMPLATE(equality_comparable)
-BOOST_OPERATOR_TEMPLATE(multipliable)
-BOOST_OPERATOR_TEMPLATE(addable)
-BOOST_OPERATOR_TEMPLATE(subtractable)
-BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
-BOOST_OPERATOR_TEMPLATE(dividable)
-BOOST_OPERATOR_TEMPLATE2(dividable2_left)
-BOOST_OPERATOR_TEMPLATE(modable)
-BOOST_OPERATOR_TEMPLATE2(modable2_left)
-BOOST_OPERATOR_TEMPLATE(xorable)
-BOOST_OPERATOR_TEMPLATE(andable)
-BOOST_OPERATOR_TEMPLATE(orable)
-
-BOOST_OPERATOR_TEMPLATE1(incrementable)
-BOOST_OPERATOR_TEMPLATE1(decrementable)
-
-BOOST_OPERATOR_TEMPLATE2(dereferenceable)
-BOOST_OPERATOR_TEMPLATE3(indexable)
-
-BOOST_OPERATOR_TEMPLATE1(bool_testable)
-
-BOOST_OPERATOR_TEMPLATE(left_shiftable)
-BOOST_OPERATOR_TEMPLATE(right_shiftable)
-BOOST_OPERATOR_TEMPLATE(equivalent)
-BOOST_OPERATOR_TEMPLATE(partially_ordered)
-
-BOOST_OPERATOR_TEMPLATE(totally_ordered)
-BOOST_OPERATOR_TEMPLATE(additive)
-BOOST_OPERATOR_TEMPLATE(multiplicative)
-BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
-BOOST_OPERATOR_TEMPLATE(arithmetic)
-BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
-BOOST_OPERATOR_TEMPLATE(bitwise)
-BOOST_OPERATOR_TEMPLATE1(unit_steppable)
-BOOST_OPERATOR_TEMPLATE(shiftable)
-BOOST_OPERATOR_TEMPLATE(ring_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
-BOOST_OPERATOR_TEMPLATE(field_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
-BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
-BOOST_OPERATOR_TEMPLATE2(input_iteratable)
-BOOST_OPERATOR_TEMPLATE1(output_iteratable)
-BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
-BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
-BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)
-
-#undef BOOST_OPERATOR_TEMPLATE
-#undef BOOST_OPERATOR_TEMPLATE4
-#undef BOOST_OPERATOR_TEMPLATE3
-#undef BOOST_OPERATOR_TEMPLATE2
-#undef BOOST_OPERATOR_TEMPLATE1
-#undef BOOST_IMPORT_TEMPLATE1
-#undef BOOST_IMPORT_TEMPLATE2
-#undef BOOST_IMPORT_TEMPLATE3
-#undef BOOST_IMPORT_TEMPLATE4
-
-// The following 'operators' classes can only be used portably if the derived class
-// declares ALL of the required member operators.
-template <class T, class U>
-struct operators2
-    : totally_ordered2<T,U
-    , integer_arithmetic2<T,U
-    , bitwise2<T,U
-      > > > {};
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, class U = T>
-struct operators : operators2<T, U> {};
-
-template <class T> struct operators<T, T>
-#else
-template <class T> struct operators
-#endif
-    : totally_ordered<T
-    , integer_arithmetic<T
-    , bitwise<T
-    , unit_steppable<T
-      > > > > {};
-
-//  Iterator helper classes (contributed by Jeremy Siek) -------------------//
-//  (Input and output iterator helpers contributed by Daryle Walker) -------//
-//  (Changed to use combined operator classes by Daryle Walker) ------------//
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V const *,
-          class R = V const &>
-struct input_iterator_helper
-  : input_iteratable<T, P
-  , boost::iterator<std::input_iterator_tag, V, D, P, R
-    > > {};
-
-template<class T>
-struct output_iterator_helper
-  : output_iteratable<T
-  , boost::iterator<std::output_iterator_tag, void, void, void, void
-  > >
-{
-  T& operator*()  { return static_cast<T&>(*this); }
-  T& operator++() { return static_cast<T&>(*this); }
-};
-
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct forward_iterator_helper
-  : forward_iteratable<T, P
-  , boost::iterator<std::forward_iterator_tag, V, D, P, R
-    > > {};
-
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct bidirectional_iterator_helper
-  : bidirectional_iteratable<T, P
-  , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
-    > > {};
-
-template <class T,
-          class V, 
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct random_access_iterator_helper
-  : random_access_iteratable<T, P, D, R
-  , boost::iterator<std::random_access_iterator_tag, V, D, P, R
-    > >
-{
-  friend D requires_difference_operator(const T& x, const T& y) {
-    return x - y;
-  }
-}; // random_access_iterator_helper
-
-} // namespace boost
-
-#if defined(__sgi) && !defined(__GNUC__)
-#pragma reset woff 1234
-#endif
-
-#endif // BOOST_OPERATORS_HPP

include/boost/ref.hpp

@@ -1,163 +0,0 @@
-#ifndef BOOST_REF_HPP_INCLUDED
-# define BOOST_REF_HPP_INCLUDED
-
-# if _MSC_VER+0 >= 1020
-#  pragma once
-# endif
-
-# include <boost/config.hpp>
-# include <boost/utility/addressof.hpp>
-# include <boost/mpl/bool.hpp>
-
-//
-//  ref.hpp - ref/cref, useful helper functions
-//
-//  Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-//  Copyright (C) 2001, 2002 Peter Dimov
-//  Copyright (C) 2002 David Abrahams
-//
-//  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/libs/bind/ref.html for documentation.
-//
-
-namespace boost
-{
-
-template<class T> class reference_wrapper
-{ 
-public:
-    typedef T type;
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-
-    explicit reference_wrapper(T& t): t_(&t) {}
-
-#else
-
-    explicit reference_wrapper(T& t): t_(addressof(t)) {}
-
-#endif
-
-    operator T& () const { return *t_; }
-
-    T& get() const { return *t_; }
-
-    T* get_pointer() const { return t_; }
-
-private:
-
-    T* t_;
-};
-
-# if defined(__BORLANDC__) && (__BORLANDC__ <= 0x570)
-#  define BOOST_REF_CONST
-# else
-#  define BOOST_REF_CONST const
-# endif
-
-template<class T> inline reference_wrapper<T> BOOST_REF_CONST ref(T & t)
-{ 
-    return reference_wrapper<T>(t);
-}
-
-template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const & t)
-{
-    return reference_wrapper<T const>(t);
-}
-
-# undef BOOST_REF_CONST
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template<typename T>
-class is_reference_wrapper
-    : public mpl::false_
-{
-};
-
-template<typename T>
-class is_reference_wrapper<reference_wrapper<T> >
-    : public mpl::true_
-{
-};
-
-template<typename T>
-class unwrap_reference
-{
- public:
-    typedef T type;
-};
-
-template<typename T>
-class unwrap_reference<reference_wrapper<T> >
-{
- public:
-    typedef T type;
-};
-# else // no partial specialization
-
-} // namespace boost
-
-#include <boost/type.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-  typedef char (&yes_reference_wrapper_t)[1];
-  typedef char (&no_reference_wrapper_t)[2];
-      
-  no_reference_wrapper_t is_reference_wrapper_test(...);
-
-  template<typename T>
-  yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper<T> >);
-
-  template<bool wrapped>
-  struct reference_unwrapper
-  {
-      template <class T>
-      struct apply
-      {
-          typedef T type;
-      };
-  };
-
-  template<>
-  struct reference_unwrapper<true>
-  {
-      template <class T>
-      struct apply
-      {
-          typedef typename T::type type;
-      };
-  };
-}
-
-template<typename T>
-class is_reference_wrapper
-{
- public:
-    BOOST_STATIC_CONSTANT(
-        bool, value = (
-             sizeof(detail::is_reference_wrapper_test(type<T>()))
-            == sizeof(detail::yes_reference_wrapper_t)));
-    
-    typedef ::boost::mpl::bool_<value> type;
-};
-
-template <typename T>
-class unwrap_reference
-    : public detail::reference_unwrapper<
-        is_reference_wrapper<T>::value
-      >::template apply<T>
-{};
-
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-} // namespace boost
-
-#endif // #ifndef BOOST_REF_HPP_INCLUDED

include/boost/utility.hpp

@@ -1,21 +0,0 @@
-//  Boost utility.hpp header file  -------------------------------------------//
-
-//  (C) Copyright Boost.org 1999-2003. 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/libs/utility for documentation.
-
-#ifndef BOOST_UTILITY_HPP
-#define BOOST_UTILITY_HPP
-
-#include <boost/utility/addressof.hpp>
-#include <boost/utility/base_from_member.hpp>  
-#include <boost/checked_delete.hpp>
-#include <boost/next_prior.hpp>
-#include <boost/noncopyable.hpp>
-
-#endif  // BOOST_UTILITY_HPP
-

include/boost/utility_fwd.hpp

@@ -1,34 +0,0 @@
-//  Boost utility_fwd.hpp header file  ---------------------------------------//
-
-//  (C) Copyright boost.org 2001.  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/libs/utility for documentation.
-
-#ifndef BOOST_UTILITY_FWD_HPP
-#define BOOST_UTILITY_FWD_HPP
-
-
-namespace boost
-{
-
-
-//  From <boost/utility/base_from_member.hpp>  -------------------------------//
-
-template < typename MemberType, int UniqueID = 0 >
-    class base_from_member;
-
-
-//  From <boost/utility.hpp>  ------------------------------------------------//
-
-class noncopyable;
-
-// Also has a few function templates
-
-}  // namespace boost
-
-
-#endif  // BOOST_UTILITY_FWD_HPP

indirect_iterator.htm

@@ -0,0 +1,443 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//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>Indirect 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>Indirect Iterator Adaptor</h1>
+    Defined in header <a href=
+    "../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a> 
+
+    <p>The indirect iterator adaptor augments an iterator by applying an
+    <b>extra</b> dereference inside of <tt>operator*()</tt>. For example, this
+    iterator makes it possible to view a container of pointers or
+    smart-pointers (e.g. <tt>std::list&lt;boost::shared_ptr&lt;foo&gt;
+    &gt;</tt>) as if it were a container of the pointed-to type. The following
+    <b>pseudo-code</b> shows the basic idea of the indirect iterator:
+
+    <blockquote>
+<pre>
+// inside a hypothetical indirect_iterator class...
+typedef std::iterator_traits&lt;BaseIterator&gt;::value_type Pointer;
+typedef std::iterator_traits&lt;Pointer&gt;::reference reference;
+
+reference indirect_iterator::operator*() const {
+  return **this-&gt;base_iterator;
+}
+</pre>
+    </blockquote>
+
+    <h2>Synopsis</h2>
+
+    <blockquote>
+<pre>
+namespace boost {
+  template &lt;class BaseIterator,
+            class Value, class Reference, class Category, class Pointer&gt;
+  struct indirect_iterator_generator;
+  
+  template &lt;class BaseIterator,
+            class Value, class Reference, class ConstReference, 
+            class Category, class Pointer, class ConstPointer&gt;
+  struct indirect_iterator_pair_generator;
+
+  template &lt;class BaseIterator&gt;
+  typename indirect_iterator_generator&lt;BaseIterator&gt;::type
+  make_indirect_iterator(BaseIterator base)  
+}
+</pre>
+    </blockquote>
+    <hr>
+
+    <h2><a name="indirect_iterator_generator">The Indirect Iterator Type
+    Generator</a></h2>
+    The <tt>indirect_iterator_generator</tt> template is a <a href=
+    "../../more/generic_programming.html#type_generator">generator</a> of
+    indirect iterator types. The main template parameter for this class is the
+    <tt>BaseIterator</tt> type that is being wrapped. In most cases the type of
+    the elements being pointed to can be deduced using
+    <tt>std::iterator_traits</tt>, but in some situations the user may want to
+    override this type, so there are also template parameters that allow a user
+    to control the <tt>value_type</tt>, <tt>pointer</tt>, and
+    <tt>reference</tt> types of the resulting iterators. 
+
+    <blockquote>
+<pre>
+template &lt;class BaseIterator,
+          class Value, class Reference, class Pointer&gt;
+class indirect_iterator_generator
+{
+public:
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> type; // the resulting indirect iterator type 
+};
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    This example uses the <tt>indirect_iterator_generator</tt> to create
+    indirect iterators which dereference the pointers stored in the
+    <tt>pointers_to_chars</tt> array to access the <tt>char</tt>s in the
+    <tt>characters</tt> array. 
+
+    <blockquote>
+<pre>
+#include &lt;boost/config.hpp&gt;
+#include &lt;vector&gt;
+#include &lt;iostream&gt;
+#include &lt;iterator&gt;
+#include &lt;boost/iterator_adaptors.hpp&gt;
+
+int main(int, char*[])
+{
+  char characters[] = "abcdefg";
+  const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
+  char* pointers_to_chars[N];                        // at the end.
+  for (int i = 0; i &lt; N; ++i)
+    pointers_to_chars[i] = &amp;characters[i];
+  
+  boost::indirect_iterator_generator&lt;char**, char&gt;::type 
+    indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
+
+  std::copy(indirect_first, indirect_last, std::ostream_iterator&lt;char&gt;(std::cout, ","));
+  std::cout &lt;&lt; std::endl;
+  
+  // to be continued...
+</pre>
+    </blockquote>
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>BaseIterator</tt> 
+
+        <td>The iterator type being wrapped. The <tt>value_type</tt>
+        of the base iterator should itself be dereferenceable.  
+        The return type of the <tt>operator*</tt> for the
+        <tt>value_type</tt> should match the <tt>Reference</tt> type.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The <tt>value_type</tt> of the resulting iterator, unless const. If
+        Value is <tt>const X</tt>, a conforming compiler makes the
+        <tt>value_type</tt> <tt><i>non-</i>const X</tt><a href=
+        "iterator_adaptors.htm#1">[1]</a>. Note that if the default
+         is used for <tt>Value</tt>, then there must be a valid specialization
+         of <tt>iterator_traits</tt> for the value type of the base iterator.
+         <br>
+         <b>Default:</b> <tt>std::iterator_traits&lt;<br>
+         <20> std::iterator_traits&lt;BaseIterator&gt;::value_type
+        &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> <tt>Value&amp;</tt> 
+
+      <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> <tt>Value*</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;BaseIterator&gt;::iterator_category</tt> 
+
+    </table>
+
+    <h3>Concept Model</h3>
+    The indirect iterator will model whichever <a href=
+    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator
+    concept category</a> is modeled by the base iterator. Thus, if the
+    base iterator is a model of <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+    Access Iterator</a> then so is the resulting indirect iterator. If
+    the base iterator models a more restrictive concept, the resulting
+    indirect iterator will model the same concept <a href="#3">[3]</a>.
+
+    <h3>Members</h3>
+    The indirect 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>
+explicit indirect_iterator_generator::type(const BaseIterator&amp; it)
+</pre>
+    <br>
+     <br>
+     
+    <hr>
+
+    <p>
+
+    <h2><a name="indirect_iterator_pair_generator">The Indirect Iterator Pair
+    Generator</a></h2>
+    Sometimes a pair of <tt>const</tt>/non-<tt>const</tt> pair of iterators is
+    needed, such as when implementing a container. The
+    <tt>indirect_iterator_pair_generator</tt> class makes it more convenient to
+    create this pair of iterator types. 
+
+    <blockquote>
+<pre>
+template &lt;class BaseIterator,
+          class Value, class Pointer, class Reference,
+          class ConstPointer, class ConstReference&gt;
+class indirect_iterator_pair_generator
+{
+public:
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> iterator;       // the mutable indirect iterator type 
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> const_iterator; // the immutable indirect iterator type 
+};
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+
+    <blockquote>
+<pre>
+  // continuing from the last example...
+
+  typedef boost::indirect_iterator_pair_generator&lt;char**,
+    char, char*, char&amp;, const char*, const char&amp;&gt; PairGen;
+
+  char mutable_characters[N];
+  char* pointers_to_mutable_chars[N];
+  for (int i = 0; i &lt; N; ++i)
+    pointers_to_mutable_chars[i] = &amp;mutable_characters[i];
+
+  PairGen::iterator mutable_indirect_first(pointers_to_mutable_chars),
+    mutable_indirect_last(pointers_to_mutable_chars + N);
+  PairGen::const_iterator const_indirect_first(pointers_to_chars),
+    const_indirect_last(pointers_to_chars + N);
+
+  std::transform(const_indirect_first, const_indirect_last,
+     mutable_indirect_first, std::bind1st(std::plus&lt;char&gt;(), 1));
+
+  std::copy(mutable_indirect_first, mutable_indirect_last,
+      std::ostream_iterator&lt;char&gt;(std::cout, ","));
+  std::cout &lt;&lt; std::endl;
+  // to be continued...
+</pre>
+    </blockquote>
+
+    <p>The output is:
+
+    <blockquote>
+<pre>
+b,c,d,e,f,g,h,
+</pre>
+    </blockquote>
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>BaseIterator</tt> 
+
+        <td>The iterator type being wrapped. The <tt>value_type</tt> of the
+        base iterator should itself be dereferenceable.
+        The return type of the <tt>operator*</tt> for the
+        <tt>value_type</tt> should match the <tt>Reference</tt> type.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The <tt>value_type</tt> of the resulting iterators.
+         If Value is <tt>const X</tt>, a conforming compiler makes the
+         <tt>value_type</tt> <tt><i>non-</i>const X</tt><a href=
+         "iterator_adaptors.htm#1">[1]</a>. Note that if the default
+         is used for <tt>Value</tt>, then there must be a valid
+         specialization of <tt>iterator_traits</tt> for the value type
+         of the base iterator.<br>
+
+         <b>Default:</b> <tt>std::iterator_traits&lt;<br>
+         <20> std::iterator_traits&lt;BaseIterator&gt;::value_type
+        &gt;::value_type</tt><a href="#2">[2]</a> 
+
+      <tr>
+        <td><tt>Reference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting <tt>iterator</tt>, and
+        in particular, the result type of its <tt>operator*()</tt>.<br>
+         <b>Default:</b> <tt>Value&amp;</tt> 
+
+      <tr>
+        <td><tt>Pointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting <tt>iterator</tt>, and
+        in particular, the result type of its <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> <tt>Value*</tt> 
+
+      <tr>
+        <td><tt>ConstReference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting
+        <tt>const_iterator</tt>, and in particular, the result type of its
+        <tt>operator*()</tt>.<br>
+         <b>Default:</b> <tt>const Value&amp;</tt> 
+
+      <tr>
+        <td><tt>ConstPointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting <tt>const_iterator</tt>,
+        and in particular, the result type of its <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> <tt>const Value*</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;BaseIterator&gt;::iterator_category</tt> 
+    </table>
+
+    <h3>Concept Model</h3>
+
+    The indirect iterators will model whichever <a href=
+    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator
+    concept category</a> is modeled by the base iterator. Thus, if the
+    base iterator is a model of <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+    Access Iterator</a> then so are the resulting indirect
+    iterators. If the base iterator models a more restrictive concept,
+    the resulting indirect iterators will model the same concept <a
+    href="#3">[3]</a>.
+
+
+    <h3>Members</h3>
+    The resulting <tt>iterator</tt> and <tt>const_iterator</tt> types implement
+    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 they support the following constructors: 
+
+    <blockquote>
+<pre>
+explicit indirect_iterator_pair_generator::iterator(const BaseIterator&amp; it)
+explicit indirect_iterator_pair_generator::const_iterator(const BaseIterator&amp; it)
+</pre>
+    </blockquote>
+    <br>
+     <br>
+     
+    <hr>
+
+    <p>
+
+    <h2><a name="make_indirect_iterator">The Indirect Iterator Object
+    Generator</a></h2>
+    The <tt>make_indirect_iterator()</tt> function provides a more convenient
+    way to create indirect iterator objects. The function saves the user the
+    trouble of explicitly writing out the iterator types. 
+
+    <blockquote>
+<pre>
+template &lt;class BaseIterator&gt;
+typename indirect_iterator_generator&lt;BaseIterator&gt;::type
+make_indirect_iterator(BaseIterator base)  
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    Here we again print the <tt>char</tt>s from the array <tt>characters</tt>
+    by accessing them through the array of pointers <tt>pointer_to_chars</tt>,
+    but this time we use the <tt>make_indirect_iterator()</tt> function which
+    saves us some typing. 
+
+    <blockquote>
+<pre>
+  // continuing from the last example...
+
+  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
+      boost::make_indirect_iterator(pointers_to_chars + N),
+      std::ostream_iterator&lt;char&gt;(std::cout, ","));
+  std::cout &lt;&lt; std::endl;
+
+  return 0;
+}
+</pre>
+    </blockquote>
+    The output is: 
+
+    <blockquote>
+<pre>
+a,b,c,d,e,f,g,
+</pre>
+    </blockquote>
+    <hr>
+
+    <h3>Notes</h3>
+
+    <p>
+
+    <p><a name="2">[2]</a> If your compiler does not support partial
+    specialization and the base iterator or its <tt>value_type</tt> is a
+    builtin pointer type, you will not be able to use the default for
+    <tt>Value</tt> and will need to specify this type explicitly.
+
+    <p><a name="3">[3]</a>There is a caveat to which concept the
+    indirect iterator can model.  If the return type of the
+    <tt>operator*</tt> for the base iterator's value type is not a
+    true reference, then strickly speaking, the indirect iterator can
+    not be a model of <a href=
+    "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+    Iterator</a> or any of the concepts that refine it. In this case
+    the <tt>Category</tt> for the indirect iterator should be
+    specified as <tt>std::input_iterator_tag</tt>. However, even in
+    this case, if the base iterator is a random access iterator, the
+    resulting indirect iterator will still satisfy most of the
+    requirements for <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+    Access Iterator</a>.
+    
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->18 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14389" -->
+
+
+    <p>&copy; Copyright Jeremy Siek and David Abrahams 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. 
+    <!--  LocalWords:  html charset alt gif hpp BaseIterator const namespace struct
+             -->
+     
+    <!--  LocalWords:  ConstPointer ConstReference typename iostream int abcdefg
+             -->
+     <!--  LocalWords:  sizeof  PairGen pre Jeremy Siek David Abrahams
+             -->
+
+
+</body>
+</html>