This commit was manufactured by cvs2svn to create branch 'named-args'.

[SVN r9294]
2001-02-20 16:01:02 +00:00
13 changed files with 458 additions and 1525 deletions
--- a/include/boost/assert.hpp
+++ b/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
--- a/include/boost/call_traits.hpp
+++ b/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
--- a/include/boost/checked_delete.hpp
+++ b/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
--- a/include/boost/compressed_pair.hpp
+++ b/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
--- a/include/boost/current_function.hpp
+++ b/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
--- a/include/boost/generator_iterator.hpp
+++ b/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
--- a/include/boost/next_prior.hpp
+++ b/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
--- a/include/boost/noncopyable.hpp
+++ b/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
--- a/include/boost/operators.hpp
+++ b/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
--- a/include/boost/ref.hpp
+++ b/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
--- a/include/boost/utility.hpp
+++ b/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
--- a/include/boost/utility_fwd.hpp
+++ b/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
--- a/iterator_adaptor_test.cpp
+++ b/iterator_adaptor_test.cpp
@@ -0,0 +1,458 @@
 //  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
 //  19 Feb 01 Take adavantage of improved iterator_traits to do more tests
 //            on MSVC. Hack around an MSVC-with-STLport internal compiler
 //            error. (David Abrahams)
 //  11 Feb 01 Added test of operator-> for forward and input iterators.
 //            (Jeremy Siek)
 //  11 Feb 01 Borland fixes (David Abrahams)
 //  10 Feb 01 Use new adaptors interface. (David Abrahams)
 //  10 Feb 01 Use new filter_ interface. (David Abrahams)
 //  09 Feb 01 Use new reverse_ and indirect_ interfaces. Replace
 //            BOOST_NO_STD_ITERATOR_TRAITS with
 //            BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION to prove we've
 //            normalized to core compiler capabilities (David Abrahams)
 //  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 <boost/concept_archetype.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, dummyT> my_iterator;
 typedef boost::iterator_adaptor<const dummyT*, 
  boost::default_iterator_policies, const dummyT> 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
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        , 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
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        , int
 #endif
        >::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_TEMPLATE_PARTIAL_SPECIALIZATION
        , 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);
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
 #endif
    // check operator->
    assert((*i).m_x == i->foo());
    const_indirect_iterator j(ptr);
    boost::random_access_iterator_test(j, N, array);
    dummyT*const* const_ptr = ptr;
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    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*
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        , dummyT
 #endif
      >::type reverse_iterator;
    reverse_iterator i(reversed + N);
    boost::random_access_iterator_test(i, N, array);
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
 #endif
    typedef boost::reverse_iterator_generator<const dummyT*
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        , const dummyT
 #endif
      >::type const_reverse_iterator;
    const_reverse_iterator j(reversed + N);
    boost::random_access_iterator_test(j, N, array);
    const dummyT* const_reversed = reversed;
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    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 all platforms
  {
    std::deque<dummyT> reversed_container;
    std::reverse_copy(array, array + N, std::back_inserter(reversed_container));
    const std::deque<dummyT>::iterator reversed = reversed_container.begin();
    typedef boost::reverse_iterator_generator<
        std::deque<dummyT>::iterator>::type reverse_iterator;
    typedef boost::reverse_iterator_generator<
        std::deque<dummyT>::const_iterator, const dummyT>::type const_reverse_iterator;
    // MSVC/STLport gives an INTERNAL COMPILER ERROR when any computation
    // (e.g. "reversed + N") is used in the constructor below.
    const std::deque<dummyT>::iterator finish = reversed_container.end();
    reverse_iterator i(finish);
    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(finish);
    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);
    // Many compilers' builtin deque iterators don't interoperate well, though
    // STLport fixes that problem.
 #if defined(__SGI_STL_PORT) || !defined(__GNUC__) && !defined(__BORLANDC__) && !defined(BOOST_MSVC)
    boost::const_nonconst_iterator_test(i, ++j);
 #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
  {
    // Using typedefs for filter_gen::type and filter_gen::policies_type
    // confused Borland terribly.
    typedef boost::detail::non_bidirectional_category<dummyT*>::type category;
    typedef ::boost::filter_iterator_generator<one_or_four, dummyT*
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        , dummyT
 #endif
        >::type filter_iter;
    filter_iter i(array, filter_iter::policies_type(one_or_four(), array + N));
    boost::forward_iterator_test(i, dummyT(1), dummyT(4));
    enum { is_forward = boost::is_same<
           filter_iter::iterator_category,
           std::forward_iterator_tag>::value };
    BOOST_STATIC_ASSERT(is_forward);
    // On compilers not supporting partial specialization, we can do more type
    // deduction with deque iterators than with pointers... unless the library
    // is broken ;-(
 #if !defined(BOOST_MSVC) || defined(__SGI_STL_PORT)
    std::deque<dummyT> array2;
    std::copy(array+0, array+N, std::back_inserter(array2));
    boost::forward_iterator_test(
        boost::make_filter_iterator(array2.begin(), array2.end(), one_or_four()),
        dummyT(1), dummyT(4));
    boost::forward_iterator_test(
        boost::make_filter_iterator<one_or_four>(array2.begin(), array2.end()),
        dummyT(1), dummyT(4));
 #endif
 #if !defined(BOOST_MSVC) // This just freaks MSVC out completely
    boost::forward_iterator_test(
        boost::make_filter_iterator<one_or_four>(
            boost::make_reverse_iterator(array2.end()),
            boost::make_reverse_iterator(array2.begin())
            ),
        dummyT(4), dummyT(1));
 #endif
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    boost::forward_iterator_test(
        boost::make_filter_iterator(array+0, 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
  }
  // check operator-> with a forward iterator
  {
    boost::forward_iterator_archetype<dummyT> forward_iter;
    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
      boost::default_iterator_policies,
      dummyT, const dummyT&, const dummyT*, 
      std::forward_iterator_tag, std::ptrdiff_t> adaptor_type;
    adaptor_type i(forward_iter);
    if (0) // don't do this, just make sure it compiles
      assert((*i).m_x == i->foo());      
  }
  // check operator-> with an input iterator
  {
    boost::input_iterator_archetype<dummyT> input_iter;
    typedef boost::iterator_adaptor<boost::input_iterator_archetype<dummyT>,
      boost::default_iterator_policies,
      dummyT, const dummyT&, const dummyT*, 
      std::input_iterator_tag, std::ptrdiff_t> adaptor_type;
    adaptor_type i(input_iter);
    if (0) // don't do this, just make sure it compiles
      assert((*i).m_x == i->foo());      
  }
  std::cout << "test successful " << std::endl;
  return 0;
 }