This commit was manufactured by cvs2svn to create branch

'array_wrapper'.

[SVN r31998]

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/detail/call_traits.hpp

@@ -0,0 +1,155 @@
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/utility for most recent version including documentation.
+
+// call_traits: defines typedefs for function usage
+// (see libs/utility/call_traits.htm)
+
+/* Release notes:
+   23rd July 2000:
+      Fixed array specialization. (JM)
+      Added Borland specific fixes for reference types
+      (issue raised by Steve Cleary).
+*/
+
+#ifndef BOOST_DETAIL_CALL_TRAITS_HPP
+#define BOOST_DETAIL_CALL_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+#include <cstddef>
+
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/detail/workaround.hpp>
+
+namespace boost{
+
+namespace detail{
+
+template <typename T, bool small_>
+struct ct_imp2
+{
+   typedef const T& param_type;
+};
+
+template <typename T>
+struct ct_imp2<T, true>
+{
+   typedef const T param_type;
+};
+
+template <typename T, bool isp, bool b1>
+struct ct_imp
+{
+   typedef const T& param_type;
+};
+
+template <typename T, bool isp>
+struct ct_imp<T, isp, true>
+{
+   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
+};
+
+template <typename T, bool b1>
+struct ct_imp<T, true, b1>
+{
+   typedef T const param_type;
+};
+
+}
+
+template <typename T>
+struct call_traits
+{
+public:
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   //
+   // C++ Builder workaround: we should be able to define a compile time
+   // constant and pass that as a single template parameter to ct_imp<T,bool>,
+   // however compiler bugs prevent this - instead pass three bool's to
+   // ct_imp<T,bool,bool,bool> and add an extra partial specialisation
+   // of ct_imp to handle the logic. (JM)
+   typedef typename boost::detail::ct_imp<
+      T,
+      ::boost::is_pointer<T>::value,
+      ::boost::is_arithmetic<T>::value
+   >::param_type param_type;
+};
+
+template <typename T>
+struct call_traits<T&>
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;  // hh removed const
+};
+
+#if BOOST_WORKAROUND( __BORLANDC__,  BOOST_TESTED_AT( 0x570 ) )
+// these are illegal specialisations; cv-qualifies applied to
+// references have no effect according to [8.3.2p1],
+// C++ Builder requires them though as it treats cv-qualified
+// references as distinct types...
+template <typename T>
+struct call_traits<T&const>
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;  // hh removed const
+};
+template <typename T>
+struct call_traits<T&volatile>
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;  // hh removed const
+};
+template <typename T>
+struct call_traits<T&const volatile>
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;  // hh removed const
+};
+#endif
+#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+template <typename T, std::size_t N>
+struct call_traits<T [N]>
+{
+private:
+   typedef T array_type[N];
+public:
+   // degrades array to pointer:
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+
+template <typename T, std::size_t N>
+struct call_traits<const T [N]>
+{
+private:
+   typedef const T array_type[N];
+public:
+   // degrades array to pointer:
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+#endif
+
+}
+
+#endif // BOOST_DETAIL_CALL_TRAITS_HPP

include/boost/detail/compressed_pair.hpp

@@ -0,0 +1,432 @@
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/utility for most recent version including documentation.
+
+// compressed_pair: pair that "compresses" empty members
+// (see libs/utility/compressed_pair.htm)
+//
+// JM changes 25 Jan 2004:
+// For the case where T1 == T2 and both are empty, then first() and second()
+// should return different objects.
+// JM changes 25 Jan 2000:
+// Removed default arguments from compressed_pair_switch to get
+// C++ Builder 4 to accept them
+// rewriten swap to get gcc and C++ builder to compile.
+// added partial specialisations for case T1 == T2 to avoid duplicate constructor defs.
+
+#ifndef BOOST_DETAIL_COMPRESSED_PAIR_HPP
+#define BOOST_DETAIL_COMPRESSED_PAIR_HPP
+
+#include <algorithm>
+
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/is_empty.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/call_traits.hpp>
+
+namespace boost
+{
+
+template <class T1, class T2>
+class compressed_pair;
+
+
+// compressed_pair
+
+namespace details
+{
+   // JM altered 26 Jan 2000:
+   template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
+   struct compressed_pair_switch;
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, false, false, false>
+      {static const int value = 0;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, false, true, true>
+      {static const int value = 3;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, false, true, false>
+      {static const int value = 1;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, false, false, true>
+      {static const int value = 2;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, true, true, true>
+      {static const int value = 4;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, true, false, false>
+      {static const int value = 5;};
+
+   template <class T1, class T2, int Version> class compressed_pair_imp;
+
+#ifdef __GNUC__
+   // workaround for GCC (JM):
+   using std::swap;
+#endif
+   //
+   // can't call unqualified swap from within classname::swap
+   // as Koenig lookup rules will find only the classname::swap
+   // member function not the global declaration, so use cp_swap
+   // as a forwarding function (JM):
+   template <typename T>
+   inline void cp_swap(T& t1, T& t2)
+   {
+#ifndef __GNUC__
+      using std::swap;
+#endif
+      swap(t1, t2);
+   }
+
+   // 0    derive from neither
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 0>
+   {
+   public:
+      typedef T1                                                 first_type;
+      typedef T2                                                 second_type;
+      typedef typename call_traits<first_type>::param_type       first_param_type;
+      typedef typename call_traits<second_type>::param_type      second_param_type;
+      typedef typename call_traits<first_type>::reference        first_reference;
+      typedef typename call_traits<second_type>::reference       second_reference;
+      typedef typename call_traits<first_type>::const_reference  first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {} 
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_(x), second_(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_(x) {}
+
+      compressed_pair_imp(second_param_type y)
+         : second_(y) {}
+
+      first_reference       first()       {return first_;}
+      first_const_reference first() const {return first_;}
+
+      second_reference       second()       {return second_;}
+      second_const_reference second() const {return second_;}
+
+      void swap(::boost::compressed_pair<T1, T2>& y)
+      {
+         cp_swap(first_, y.first());
+         cp_swap(second_, y.second());
+      }
+   private:
+      first_type first_;
+      second_type second_;
+   };
+
+   // 1    derive from T1
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 1>
+      : private ::boost::remove_cv<T1>::type
+   {
+   public:
+      typedef T1                                                 first_type;
+      typedef T2                                                 second_type;
+      typedef typename call_traits<first_type>::param_type       first_param_type;
+      typedef typename call_traits<second_type>::param_type      second_param_type;
+      typedef typename call_traits<first_type>::reference        first_reference;
+      typedef typename call_traits<second_type>::reference       second_reference;
+      typedef typename call_traits<first_type>::const_reference  first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_type(x), second_(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_type(x) {}
+
+      compressed_pair_imp(second_param_type y)
+         : second_(y) {}
+
+      first_reference       first()       {return *this;}
+      first_const_reference first() const {return *this;}
+
+      second_reference       second()       {return second_;}
+      second_const_reference second() const {return second_;}
+
+      void swap(::boost::compressed_pair<T1,T2>& y)
+      {
+         // no need to swap empty base class:
+         cp_swap(second_, y.second());
+      }
+   private:
+      second_type second_;
+   };
+
+   // 2    derive from T2
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 2>
+      : private ::boost::remove_cv<T2>::type
+   {
+   public:
+      typedef T1                                                 first_type;
+      typedef T2                                                 second_type;
+      typedef typename call_traits<first_type>::param_type       first_param_type;
+      typedef typename call_traits<second_type>::param_type      second_param_type;
+      typedef typename call_traits<first_type>::reference        first_reference;
+      typedef typename call_traits<second_type>::reference       second_reference;
+      typedef typename call_traits<first_type>::const_reference  first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : second_type(y), first_(x) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_(x) {}
+
+      compressed_pair_imp(second_param_type y)
+         : second_type(y) {}
+
+      first_reference       first()       {return first_;}
+      first_const_reference first() const {return first_;}
+
+      second_reference       second()       {return *this;}
+      second_const_reference second() const {return *this;}
+
+      void swap(::boost::compressed_pair<T1,T2>& y)
+      {
+         // no need to swap empty base class:
+         cp_swap(first_, y.first());
+      }
+
+   private:
+      first_type first_;
+   };
+
+   // 3    derive from T1 and T2
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 3>
+      : private ::boost::remove_cv<T1>::type,
+        private ::boost::remove_cv<T2>::type
+   {
+   public:
+      typedef T1                                                 first_type;
+      typedef T2                                                 second_type;
+      typedef typename call_traits<first_type>::param_type       first_param_type;
+      typedef typename call_traits<second_type>::param_type      second_param_type;
+      typedef typename call_traits<first_type>::reference        first_reference;
+      typedef typename call_traits<second_type>::reference       second_reference;
+      typedef typename call_traits<first_type>::const_reference  first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_type(x), second_type(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_type(x) {}
+
+      compressed_pair_imp(second_param_type y)
+         : second_type(y) {}
+
+      first_reference       first()       {return *this;}
+      first_const_reference first() const {return *this;}
+
+      second_reference       second()       {return *this;}
+      second_const_reference second() const {return *this;}
+      //
+      // no need to swap empty bases:
+      void swap(::boost::compressed_pair<T1,T2>&) {}
+   };
+
+   // JM
+   // 4    T1 == T2, T1 and T2 both empty
+   //      Note does not actually store an instance of T2 at all -
+   //      but reuses T1 base class for both first() and second().
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 4>
+      : private ::boost::remove_cv<T1>::type
+   {
+   public:
+      typedef T1                                                 first_type;
+      typedef T2                                                 second_type;
+      typedef typename call_traits<first_type>::param_type       first_param_type;
+      typedef typename call_traits<second_type>::param_type      second_param_type;
+      typedef typename call_traits<first_type>::reference        first_reference;
+      typedef typename call_traits<second_type>::reference       second_reference;
+      typedef typename call_traits<first_type>::const_reference  first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_type(x), m_second(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_type(x), m_second(x) {}
+
+      first_reference       first()       {return *this;}
+      first_const_reference first() const {return *this;}
+
+      second_reference       second()       {return m_second;}
+      second_const_reference second() const {return m_second;}
+
+      void swap(::boost::compressed_pair<T1,T2>&) {}
+   private:
+      T2 m_second;
+   };
+
+   // 5    T1 == T2 and are not empty:   //JM
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 5>
+   {
+   public:
+      typedef T1                                                 first_type;
+      typedef T2                                                 second_type;
+      typedef typename call_traits<first_type>::param_type       first_param_type;
+      typedef typename call_traits<second_type>::param_type      second_param_type;
+      typedef typename call_traits<first_type>::reference        first_reference;
+      typedef typename call_traits<second_type>::reference       second_reference;
+      typedef typename call_traits<first_type>::const_reference  first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_(x), second_(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_(x), second_(x) {}
+
+      first_reference       first()       {return first_;}
+      first_const_reference first() const {return first_;}
+
+      second_reference       second()       {return second_;}
+      second_const_reference second() const {return second_;}
+
+      void swap(::boost::compressed_pair<T1, T2>& y)
+      {
+         cp_swap(first_, y.first());
+         cp_swap(second_, y.second());
+      }
+   private:
+      first_type first_;
+      second_type second_;
+   };
+
+}  // details
+
+template <class T1, class T2>
+class compressed_pair
+   : private ::boost::details::compressed_pair_imp<T1, T2,
+             ::boost::details::compressed_pair_switch<
+                    T1,
+                    T2,
+                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
+                    ::boost::is_empty<T1>::value,
+                    ::boost::is_empty<T2>::value>::value>
+{
+private:
+   typedef details::compressed_pair_imp<T1, T2,
+             ::boost::details::compressed_pair_switch<
+                    T1,
+                    T2,
+                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
+                    ::boost::is_empty<T1>::value,
+                    ::boost::is_empty<T2>::value>::value> base;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair() : base() {}
+            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
+   explicit compressed_pair(first_param_type x) : base(x) {}
+   explicit compressed_pair(second_param_type y) : base(y) {}
+
+   first_reference       first()       {return base::first();}
+   first_const_reference first() const {return base::first();}
+
+   second_reference       second()       {return base::second();}
+   second_const_reference second() const {return base::second();}
+
+   void swap(compressed_pair& y) { base::swap(y); }
+};
+
+// JM
+// Partial specialisation for case where T1 == T2:
+//
+template <class T>
+class compressed_pair<T, T>
+   : private details::compressed_pair_imp<T, T,
+             ::boost::details::compressed_pair_switch<
+                    T,
+                    T,
+                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
+                    ::boost::is_empty<T>::value,
+                    ::boost::is_empty<T>::value>::value>
+{
+private:
+   typedef details::compressed_pair_imp<T, T,
+             ::boost::details::compressed_pair_switch<
+                    T,
+                    T,
+                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
+                    ::boost::is_empty<T>::value,
+                    ::boost::is_empty<T>::value>::value> base;
+public:
+   typedef T                                                  first_type;
+   typedef T                                                  second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair() : base() {}
+            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
+#if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530))
+   explicit 
+#endif
+      compressed_pair(first_param_type x) : base(x) {}
+
+   first_reference       first()       {return base::first();}
+   first_const_reference first() const {return base::first();}
+
+   second_reference       second()       {return base::second();}
+   second_const_reference second() const {return base::second();}
+
+   void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
+};
+
+template <class T1, class T2>
+inline
+void
+swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
+{
+   x.swap(y);
+}
+
+} // boost
+
+#endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP
+

include/boost/detail/ob_call_traits.hpp

@@ -0,0 +1,168 @@
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/utility for most recent version including documentation.
+//
+//  Crippled version for crippled compilers:
+//  see libs/utility/call_traits.htm
+//
+
+/* Release notes:
+   01st October 2000:
+      Fixed call_traits on VC6, using "poor man's partial specialisation",
+      using ideas taken from "Generative programming" by Krzysztof Czarnecki 
+      & Ulrich Eisenecker.
+*/
+
+#ifndef BOOST_OB_CALL_TRAITS_HPP
+#define BOOST_OB_CALL_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+
+#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
+#include <boost/type_traits/arithmetic_traits.hpp>
+#endif
+#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
+#include <boost/type_traits/composite_traits.hpp>
+#endif
+
+namespace boost{
+
+#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
+//
+// use member templates to emulate
+// partial specialisation:
+//
+namespace detail{
+
+template <class T>
+struct standard_call_traits
+{
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef const T& param_type;
+};
+template <class T>
+struct simple_call_traits
+{
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef const T param_type;
+};
+template <class T>
+struct reference_call_traits
+{
+   typedef T value_type;
+   typedef T reference;
+   typedef T const_reference;
+   typedef T param_type;
+};
+
+template <bool pointer, bool arithmetic, bool reference>
+struct call_traits_chooser
+{
+   template <class T>
+   struct rebind
+   {
+      typedef standard_call_traits<T> type;
+   };
+};
+
+template <>
+struct call_traits_chooser<true, false, false>
+{
+   template <class T>
+   struct rebind
+   {
+      typedef simple_call_traits<T> type;
+   };
+};
+
+template <>
+struct call_traits_chooser<false, false, true>
+{
+   template <class T>
+   struct rebind
+   {
+      typedef reference_call_traits<T> type;
+   };
+};
+
+template <bool size_is_small> 
+struct call_traits_sizeof_chooser2
+{
+   template <class T>
+   struct small_rebind
+   {
+      typedef simple_call_traits<T> small_type;
+   };
+};
+
+template<> 
+struct call_traits_sizeof_chooser2<false>
+{
+   template <class T>
+   struct small_rebind
+   {
+      typedef standard_call_traits<T> small_type;
+   };
+};
+
+template <>
+struct call_traits_chooser<false, true, false>
+{
+   template <class T>
+   struct rebind
+   {
+      enum { sizeof_choice = (sizeof(T) <= sizeof(void*)) };
+      typedef call_traits_sizeof_chooser2<(sizeof(T) <= sizeof(void*))> chooser;
+      typedef typename chooser::template small_rebind<T> bound_type;
+      typedef typename bound_type::small_type type;
+   };
+};
+
+} // namespace detail
+template <typename T>
+struct call_traits
+{
+private:
+    typedef detail::call_traits_chooser<
+         ::boost::is_pointer<T>::value,
+         ::boost::is_arithmetic<T>::value, 
+         ::boost::is_reference<T>::value
+      > chooser;
+   typedef typename chooser::template rebind<T> bound_type;
+   typedef typename bound_type::type call_traits_type;
+public:
+   typedef typename call_traits_type::value_type       value_type;
+   typedef typename call_traits_type::reference        reference;
+   typedef typename call_traits_type::const_reference  const_reference;
+   typedef typename call_traits_type::param_type       param_type;
+};
+
+#else
+//
+// sorry call_traits is completely non-functional
+// blame your broken compiler:
+//
+
+template <typename T>
+struct call_traits
+{
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef const T& param_type;
+};
+
+#endif // member templates
+
+}
+
+#endif // BOOST_OB_CALL_TRAITS_HPP

include/boost/detail/ob_compressed_pair.hpp

@@ -0,0 +1,510 @@
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/utility for most recent version including documentation.
+//  see libs/utility/compressed_pair.hpp
+//
+/* Release notes:
+   20 Jan 2001:
+        Fixed obvious bugs (David Abrahams)
+   07 Oct 2000:
+      Added better single argument constructor support.
+   03 Oct 2000:
+      Added VC6 support (JM).
+   23rd July 2000:
+      Additional comments added. (JM)
+   Jan 2000:
+      Original version: this version crippled for use with crippled compilers
+      - John Maddock Jan 2000.
+*/
+
+
+#ifndef BOOST_OB_COMPRESSED_PAIR_HPP
+#define BOOST_OB_COMPRESSED_PAIR_HPP
+
+#include <algorithm>
+#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
+#include <boost/type_traits/object_traits.hpp>
+#endif
+#ifndef BOOST_SAME_TRAITS_HPP
+#include <boost/type_traits/same_traits.hpp>
+#endif
+#ifndef BOOST_CALL_TRAITS_HPP
+#include <boost/call_traits.hpp>
+#endif
+
+namespace boost
+{
+#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
+//
+// use member templates to emulate
+// partial specialisation.  Note that due to
+// problems with overload resolution with VC6
+// each of the compressed_pair versions that follow
+// have one template single-argument constructor
+// in place of two specific constructors:
+//
+
+template <class T1, class T2>
+class compressed_pair;
+
+namespace detail{
+
+template <class A, class T1, class T2>
+struct best_conversion_traits
+{
+   typedef char one;
+   typedef char (&two)[2];
+   static A a;
+   static one test(T1);
+   static two test(T2);
+
+   enum { value = sizeof(test(a)) };
+};
+
+template <int>
+struct init_one;
+
+template <>
+struct init_one<1>
+{
+   template <class A, class T1, class T2>
+   static void init(const A& a, T1* p1, T2*)
+   {
+      *p1 = a;
+   }
+};
+
+template <>
+struct init_one<2>
+{
+   template <class A, class T1, class T2>
+   static void init(const A& a, T1*, T2* p2)
+   {
+      *p2 = a;
+   }
+};
+
+
+// T1 != T2, both non-empty
+template <class T1, class T2>
+class compressed_pair_0
+{
+private:
+   T1 _first;
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_0() : _first(), _second() {}
+            compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+   template <class A>
+   explicit compressed_pair_0(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
+   }
+   compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
+      : _first(x.first()), _second(x.second()) {}
+
+#if 0
+  compressed_pair_0& operator=(const compressed_pair_0& x) {
+    cout << "assigning compressed pair 0" << endl;
+    _first = x._first;
+    _second = x._second;
+    cout << "finished assigning compressed pair 0" << endl;
+    return *this;
+  }
+#endif
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair_0& y)
+   {
+      using std::swap;
+      swap(_first, y._first);
+      swap(_second, y._second);
+   }
+};
+
+// T1 != T2, T2 empty
+template <class T1, class T2>
+class compressed_pair_1 : T2
+{
+private:
+   T1 _first;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_1() : T2(), _first() {}
+            compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}
+
+   template <class A>
+   explicit compressed_pair_1(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
+   }
+
+   compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
+      : T2(x.second()), _first(x.first()) {}
+
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
+  // Total weirdness. If the assignment to _first is moved after
+  // the call to the inherited operator=, then this breaks graph/test/graph.cpp
+  // by way of iterator_adaptor.
+  compressed_pair_1& operator=(const compressed_pair_1& x) {
+    _first = x._first;
+    T2::operator=(x);
+    return *this;
+  }
+#endif
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return *this; }
+   second_const_reference second() const { return *this; }
+
+   void swap(compressed_pair_1& y)
+   {
+      // no need to swap empty base class:
+      using std::swap;
+      swap(_first, y._first);
+   }
+};
+
+// T1 != T2, T1 empty
+template <class T1, class T2>
+class compressed_pair_2 : T1
+{
+private:
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_2() : T1(), _second() {}
+            compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
+   template <class A>
+   explicit compressed_pair_2(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
+   }
+   compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
+      : T1(x.first()), _second(x.second()) {}
+
+#if 0
+  compressed_pair_2& operator=(const compressed_pair_2& x) {
+    cout << "assigning compressed pair 2" << endl;
+    T1::operator=(x);
+    _second = x._second;
+    cout << "finished assigning compressed pair 2" << endl;
+    return *this;
+  }
+#endif
+   first_reference       first()       { return *this; }
+   first_const_reference first() const { return *this; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair_2& y)
+   {
+      // no need to swap empty base class:
+      using std::swap;
+      swap(_second, y._second);
+   }
+};
+
+// T1 != T2, both empty
+template <class T1, class T2>
+class compressed_pair_3 : T1, T2
+{
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_3() : T1(), T2() {}
+            compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
+   template <class A>
+   explicit compressed_pair_3(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));
+   }
+   compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
+      : T1(x.first()), T2(x.second()) {}
+
+   first_reference       first()       { return *this; }
+   first_const_reference first() const { return *this; }
+
+   second_reference       second()       { return *this; }
+   second_const_reference second() const { return *this; }
+
+   void swap(compressed_pair_3& y)
+   {
+      // no need to swap empty base classes:
+   }
+};
+
+// T1 == T2, and empty
+template <class T1, class T2>
+class compressed_pair_4 : T1
+{
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_4() : T1() {}
+            compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {}
+   // only one single argument constructor since T1 == T2
+   explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {}
+   compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)
+      : T1(x.first()), m_second(x.second()) {}
+
+   first_reference       first()       { return *this; }
+   first_const_reference first() const { return *this; }
+
+   second_reference       second()       { return m_second; }
+   second_const_reference second() const { return m_second; }
+
+   void swap(compressed_pair_4& y)
+   {
+      // no need to swap empty base classes:
+   }
+private:
+   T2 m_second;
+};
+
+// T1 == T2, not empty
+template <class T1, class T2>
+class compressed_pair_5
+{
+private:
+   T1 _first;
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_5() : _first(), _second() {}
+            compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+   // only one single argument constructor since T1 == T2
+   explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}
+   compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c) 
+      : _first(c.first()), _second(c.second()) {}
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair_5& y)
+   {
+      using std::swap;
+      swap(_first, y._first);
+      swap(_second, y._second);
+   }
+};
+
+template <bool e1, bool e2, bool same>
+struct compressed_pair_chooser
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_0<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<false, true, false>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_1<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<true, false, false>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_2<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<true, true, false>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_3<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<true, true, true>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_4<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<false, false, true>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_5<T1, T2> type;
+   };
+};
+
+template <class T1, class T2>
+struct compressed_pair_traits
+{
+private:
+   typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;
+   typedef typename chooser::template rebind<T1, T2> bound_type;
+public:
+   typedef typename bound_type::type type;
+};
+
+} // namespace detail
+
+template <class T1, class T2>
+class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type
+{
+private:
+   typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair() : base_type() {}
+            compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}
+   template <class A>
+   explicit compressed_pair(const A& x) : base_type(x){}
+
+   first_reference       first()       { return base_type::first(); }
+   first_const_reference first() const { return base_type::first(); }
+
+   second_reference       second()       { return base_type::second(); }
+   second_const_reference second() const { return base_type::second(); }
+};
+
+template <class T1, class T2>
+inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
+{
+   x.swap(y);
+}
+
+#else
+// no partial specialisation, no member templates:
+
+template <class T1, class T2>
+class compressed_pair
+{
+private:
+   T1 _first;
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair() : _first(), _second() {}
+            compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+   explicit compressed_pair(first_param_type x) : _first(x), _second() {}
+   // can't define this in case T1 == T2:
+   // explicit compressed_pair(second_param_type y) : _first(), _second(y) {}
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair& y)
+   {
+      using std::swap;
+      swap(_first, y._first);
+      swap(_second, y._second);
+   }
+};
+
+template <class T1, class T2>
+inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
+{
+   x.swap(y);
+}
+
+#endif
+
+} // boost
+
+#endif // BOOST_OB_COMPRESSED_PAIR_HPP
+
+
+

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