This commit was manufactured by cvs2svn to create tag

'Version_1_20_1'.

[SVN r8548]

include/boost/blank.hpp

@@ -1,100 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost blank.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2003
-// Eric Friedman
-//
-// Distributed under 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)
-
-#ifndef BOOST_BLANK_HPP
-#define BOOST_BLANK_HPP
-
-#include "boost/blank_fwd.hpp"
-
-#include <iosfwd> // for std::basic_ostream forward declare
-
-#include "boost/detail/templated_streams.hpp"
-#include "boost/mpl/bool.hpp"
-#include "boost/type_traits/is_empty.hpp"
-#include "boost/type_traits/is_pod.hpp"
-#include "boost/type_traits/is_stateless.hpp"
-
-namespace boost {
-
-struct blank
-{
-};
-
-// type traits specializations
-//
-
-template <>
-struct is_pod< blank >
-    : mpl::true_
-{
-};
-
-template <>
-struct is_empty< blank >
-    : mpl::true_
-{
-};
-
-template <>
-struct is_stateless< blank >
-    : mpl::true_
-{
-};
-
-// relational operators
-//
-
-inline bool operator==(const blank&, const blank&)
-{
-    return true;
-}
-
-inline bool operator<=(const blank&, const blank&)
-{
-    return true;
-}
-
-inline bool operator>=(const blank&, const blank&)
-{
-    return true;
-}
-
-inline bool operator!=(const blank&, const blank&)
-{
-    return false;
-}
-
-inline bool operator<(const blank&, const blank&)
-{
-    return false;
-}
-
-inline bool operator>(const blank&, const blank&)
-{
-    return false;
-}
-
-// streaming support
-//
-BOOST_TEMPLATED_STREAM_TEMPLATE(E,T)
-inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
-      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
-    , const blank&
-    )
-{
-    // (output nothing)
-    return out;
-}
-
-} // namespace boost
-
-#endif // BOOST_BLANK_HPP

include/boost/blank_fwd.hpp

@@ -1,22 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost blank_fwd.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2003
-// Eric Friedman
-//
-// Distributed under 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)
-
-#ifndef BOOST_BLANK_FWD_HPP
-#define BOOST_BLANK_FWD_HPP
-
-namespace boost {
-
-struct blank;
-
-} // namespace boost
-
-#endif // BOOST_BLANK_FWD_HPP

include/boost/cstdlib.hpp

@@ -1,41 +0,0 @@
-//  boost/cstdlib.hpp header  ------------------------------------------------//
-
-//  Copyright Beman Dawes 2001.  Distributed under 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/cstdlib.html for documentation.
-
-//  Revision History
-//   26 Feb 01  Initial version (Beman Dawes)
-
-#ifndef BOOST_CSTDLIB_HPP
-#define BOOST_CSTDLIB_HPP
-
-#include <cstdlib>
-
-namespace boost
-{
-   //  The intent is to propose the following for addition to namespace std
-   //  in the C++ Standard Library, and to then deprecate EXIT_SUCCESS and
-   //  EXIT_FAILURE.  As an implementation detail, this header defines the
-   //  new constants in terms of EXIT_SUCCESS and EXIT_FAILURE.  In a new
-   //  standard, the constants would be implementation-defined, although it
-   //  might be worthwhile to "suggest" (which a standard is allowed to do)
-   //  values of 0 and 1 respectively.
-
-   //  Rationale for having multiple failure values: some environments may
-   //  wish to distinguish between different classes of errors.
-   //  Rationale for choice of values: programs often use values < 100 for
-   //  their own error reporting.  Values > 255 are sometimes reserved for
-   //  system detected errors.  200/201 were suggested to minimize conflict.
-
-   const int exit_success = EXIT_SUCCESS;  // implementation-defined value
-   const int exit_failure = EXIT_FAILURE;  // implementation-defined value
-   const int exit_exception_failure = 200; // otherwise uncaught exception
-   const int exit_test_failure = 201;      // report_error or
-                                           //  report_critical_error called.
-}
-
-#endif
-

include/boost/detail/allocator_utilities.hpp

@@ -1,185 +0,0 @@
-/* Copyright 2003-2005 Joaqu<71>n M L<>pez Mu<4D>oz.
- * Distributed under 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 Boost website at http://www.boost.org/
- */
-
-#ifndef BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP
-#define BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/aux_/msvc_never_true.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <cstddef>
-#include <memory>
-#include <new>
-
-namespace boost{
-
-namespace detail{
-
-/* Allocator adaption layer. Some stdlibs provide allocators without rebind
- * and template ctors. These facilities are simulated with the external
- * template class rebind_to and the aid of partial_std_allocator_wrapper.
- */
-
-namespace allocator{
-
-/* partial_std_allocator_wrapper inherits the functionality of a std
- * allocator while providing a templatized ctor.
- */
-
-template<typename Type>
-class partial_std_allocator_wrapper:public std::allocator<Type>
-{
-public:
-  partial_std_allocator_wrapper(){};
-
-  template<typename Other>
-  partial_std_allocator_wrapper(const partial_std_allocator_wrapper<Other>&){}
-
-  partial_std_allocator_wrapper(const std::allocator<Type>& x):
-    std::allocator<Type>(x)
-  {
-  };
-
-#if defined(BOOST_DINKUMWARE_STDLIB)
-  /* Dinkumware guys didn't provide a means to call allocate() without
-   * supplying a hint, in disagreement with the standard.
-   */
-
-  Type* allocate(std::size_t n,const void* hint=0)
-  {
-    std::allocator<Type>& a=*this;
-    return a.allocate(n,hint);
-  }
-#endif
-
-};
-
-/* Detects whether a given allocator belongs to a defective stdlib not
- * having the required member templates.
- * Note that it does not suffice to check the Boost.Config stdlib
- * macros, as the user might have passed a custom, compliant allocator.
- * The checks also considers partial_std_allocator_wrapper to be
- * a standard defective allocator.
- */
-
-#if defined(BOOST_NO_STD_ALLOCATOR)&&\
-  (defined(BOOST_HAS_PARTIAL_STD_ALLOCATOR)||defined(BOOST_DINKUMWARE_STDLIB))
-
-template<typename Allocator>
-struct is_partial_std_allocator
-{
-  BOOST_STATIC_CONSTANT(bool,
-    value=
-      (is_same<
-        std::allocator<BOOST_DEDUCED_TYPENAME Allocator::value_type>,
-        Allocator
-      >::value)||
-      (is_same<
-        partial_std_allocator_wrapper<
-          BOOST_DEDUCED_TYPENAME Allocator::value_type>,
-        Allocator
-      >::value));
-};
-
-#else
-
-template<typename Allocator>
-struct is_partial_std_allocator
-{
-  BOOST_STATIC_CONSTANT(bool,value=false);
-};
-
-#endif
-
-/* rebind operations for defective std allocators */
-
-template<typename Allocator,typename Type>
-struct partial_std_allocator_rebind_to
-{
-  typedef partial_std_allocator_wrapper<Type> type;
-};
-
-/* rebind operation in all other cases */
-
-#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
-/* Workaround for a problem in MSVC with dependent template typedefs
- * when doing rebinding of allocators.
- * Modeled after <boost/mpl/aux_/msvc_dtw.hpp> (thanks, Aleksey!)
- */
-
-template<typename Allocator>
-struct rebinder
-{
-  template<bool> struct fake_allocator:Allocator{};
-  template<> struct fake_allocator<true>
-  {
-    template<typename Type> struct rebind{};
-  };
-
-  template<typename Type>
-  struct result:
-    fake_allocator<mpl::aux::msvc_never_true<Allocator>::value>::
-      template rebind<Type>
-  {
-  };
-};
-#else
-template<typename Allocator>
-struct rebinder
-{
-  template<typename Type>
-  struct result
-  {
-      typedef typename Allocator::BOOST_NESTED_TEMPLATE 
-          rebind<Type>::other other;
-  };
-};
-#endif
-
-template<typename Allocator,typename Type>
-struct compliant_allocator_rebind_to
-{
-  typedef typename rebinder<Allocator>::
-      BOOST_NESTED_TEMPLATE result<Type>::other type;
-};
-
-/* rebind front-end */
-
-template<typename Allocator,typename Type>
-struct rebind_to:
-  mpl::eval_if_c<
-    is_partial_std_allocator<Allocator>::value,
-    partial_std_allocator_rebind_to<Allocator,Type>,
-    compliant_allocator_rebind_to<Allocator,Type>
-  >
-{
-};
-
-/* allocator-independent versions of construct and destroy */
-
-template<typename Type>
-void construct(void* p,const Type& t)
-{
-  new (p) Type(t);
-}
-
-template<typename Type>
-void destroy(const Type* p)
-{
-  p->~Type();
-}
-
-} /* namespace boost::detail::allocator */
-
-} /* namespace boost::detail */
-
-} /* namespace boost */
-
-#endif

include/boost/detail/binary_search.hpp

@@ -1,216 +0,0 @@
-// Copyright (c)  2000 David Abrahams. 
-// Distributed under 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)
-// 
-// Copyright (c) 1994
-// Hewlett-Packard Company
-// 
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  Hewlett-Packard Company makes no
-// representations about the suitability of this software for any
-// purpose.  It is provided "as is" without express or implied warranty.
-// 
-// Copyright (c) 1996
-// Silicon Graphics Computer Systems, Inc.
-// 
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  Silicon Graphics makes no
-// representations about the suitability of this software for any
-// purpose.  It is provided "as is" without express or implied warranty.
-// 
-#ifndef BINARY_SEARCH_DWA_122600_H_
-# define BINARY_SEARCH_DWA_122600_H_
-
-# include <boost/detail/iterator.hpp>
-# include <utility>
-
-namespace boost { namespace detail {
-
-template <class ForwardIter, class Tp>
-ForwardIter lower_bound(ForwardIter first, ForwardIter last,
-                             const Tp& val) 
-{
-    typedef detail::iterator_traits<ForwardIter> traits;
-    
-    typename traits::difference_type len = boost::detail::distance(first, last);
-    typename traits::difference_type half;
-    ForwardIter middle;
-
-    while (len > 0) {
-      half = len >> 1;
-      middle = first;
-      std::advance(middle, half);
-      if (*middle < val) {
-        first = middle;
-        ++first;
-        len = len - half - 1;
-      }
-      else
-        len = half;
-    }
-    return first;
-}
-
-template <class ForwardIter, class Tp, class Compare>
-ForwardIter lower_bound(ForwardIter first, ForwardIter last,
-                              const Tp& val, Compare comp)
-{
-  typedef detail::iterator_traits<ForwardIter> traits;
-
-  typename traits::difference_type len = boost::detail::distance(first, last);
-  typename traits::difference_type half;
-  ForwardIter middle;
-
-  while (len > 0) {
-    half = len >> 1;
-    middle = first;
-    std::advance(middle, half);
-    if (comp(*middle, val)) {
-      first = middle;
-      ++first;
-      len = len - half - 1;
-    }
-    else
-      len = half;
-  }
-  return first;
-}
-
-template <class ForwardIter, class Tp>
-ForwardIter upper_bound(ForwardIter first, ForwardIter last,
-                           const Tp& val)
-{
-  typedef detail::iterator_traits<ForwardIter> traits;
-
-  typename traits::difference_type len = boost::detail::distance(first, last);
-  typename traits::difference_type half;
-  ForwardIter middle;
-
-  while (len > 0) {
-    half = len >> 1;
-    middle = first;
-    std::advance(middle, half);
-    if (val < *middle)
-      len = half;
-    else {
-      first = middle;
-      ++first;
-      len = len - half - 1;
-    }
-  }
-  return first;
-}
-
-template <class ForwardIter, class Tp, class Compare>
-ForwardIter upper_bound(ForwardIter first, ForwardIter last,
-                           const Tp& val, Compare comp)
-{
-  typedef detail::iterator_traits<ForwardIter> traits;
-
-  typename traits::difference_type len = boost::detail::distance(first, last);
-  typename traits::difference_type half;
-  ForwardIter middle;
-
-  while (len > 0) {
-    half = len >> 1;
-    middle = first;
-    std::advance(middle, half);
-    if (comp(val, *middle))
-      len = half;
-    else {
-      first = middle;
-      ++first;
-      len = len - half - 1;
-    }
-  }
-  return first;
-}
-
-template <class ForwardIter, class Tp>
-std::pair<ForwardIter, ForwardIter>
-equal_range(ForwardIter first, ForwardIter last, const Tp& val)
-{
-  typedef detail::iterator_traits<ForwardIter> traits;
-
-  typename traits::difference_type len = boost::detail::distance(first, last);
-  typename traits::difference_type half;
-  ForwardIter middle, left, right;
-
-  while (len > 0) {
-    half = len >> 1;
-    middle = first;
-    std::advance(middle, half);
-    if (*middle < val) {
-      first = middle;
-      ++first;
-      len = len - half - 1;
-    }
-    else if (val < *middle)
-      len = half;
-    else {
-      left = boost::detail::lower_bound(first, middle, val);
-      std::advance(first, len);
-      right = boost::detail::upper_bound(++middle, first, val);
-      return std::pair<ForwardIter, ForwardIter>(left, right);
-    }
-  }
-  return std::pair<ForwardIter, ForwardIter>(first, first);
-}
-
-template <class ForwardIter, class Tp, class Compare>
-std::pair<ForwardIter, ForwardIter>
-equal_range(ForwardIter first, ForwardIter last, const Tp& val,
-              Compare comp)
-{
-  typedef detail::iterator_traits<ForwardIter> traits;
-
-  typename traits::difference_type len = boost::detail::distance(first, last);
-  typename traits::difference_type half;
-  ForwardIter middle, left, right;
-
-  while (len > 0) {
-    half = len >> 1;
-    middle = first;
-    std::advance(middle, half);
-    if (comp(*middle, val)) {
-      first = middle;
-      ++first;
-      len = len - half - 1;
-    }
-    else if (comp(val, *middle))
-      len = half;
-    else {
-      left = boost::detail::lower_bound(first, middle, val, comp);
-      std::advance(first, len);
-      right = boost::detail::upper_bound(++middle, first, val, comp);
-      return std::pair<ForwardIter, ForwardIter>(left, right);
-    }
-  }
-  return std::pair<ForwardIter, ForwardIter>(first, first);
-}           
-
-template <class ForwardIter, class Tp>
-bool binary_search(ForwardIter first, ForwardIter last,
-                   const Tp& val) {
-  ForwardIter i = boost::detail::lower_bound(first, last, val);
-  return i != last && !(val < *i);
-}
-
-template <class ForwardIter, class Tp, class Compare>
-bool binary_search(ForwardIter first, ForwardIter last,
-                   const Tp& val,
-                   Compare comp) {
-  ForwardIter i = boost::detail::lower_bound(first, last, val, comp);
-  return i != last && !comp(val, *i);
-}
-
-}} // namespace boost::detail
-
-#endif // BINARY_SEARCH_DWA_122600_H_

include/boost/detail/catch_exceptions.hpp

@@ -1,146 +0,0 @@
-//  boost/catch_exceptions.hpp -----------------------------------------------//
-
-//  Copyright Beman Dawes 1995-2001.  Distributed under 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/test for documentation.
-
-//  Revision History
-//   13 Jun 01 report_exception() made inline. (John Maddock, Jesse Jones)
-//   26 Feb 01 Numerous changes suggested during formal review. (Beman)
-//   25 Jan 01 catch_exceptions.hpp code factored out of cpp_main.cpp.
-//   22 Jan 01 Remove test_tools dependencies to reduce coupling.
-//    5 Nov 00 Initial boost version (Beman Dawes)
-
-#ifndef BOOST_CATCH_EXCEPTIONS_HPP
-#define BOOST_CATCH_EXCEPTIONS_HPP
-
-//  header dependencies are deliberately restricted to the standard library
-//  to reduce coupling to other boost libraries.
-#include <string>             // for string
-#include <new>                // for bad_alloc
-#include <typeinfo>           // for bad_cast, bad_typeid
-#include <exception>          // for exception, bad_exception
-#include <stdexcept>          // for std exception hierarchy
-#include <boost/cstdlib.hpp>  // for exit codes
-# if __GNUC__ != 2 || __GNUC_MINOR__ > 96
-#   include <ostream>         // for ostream
-# else
-#   include <iostream> // workaround GNU missing ostream header
-# endif
-
-# if defined(__BORLANDC__) && (__BORLANDC__ <= 0x0551)
-#   define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT 
-# endif
-
-#if defined(MPW_CPLUS) && (MPW_CPLUS <= 0x890)
-#   define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT 
-    namespace std { class bad_typeid { }; }
-# endif
-
-namespace boost
-{
-
-  namespace detail
-  {
-    //  A separate reporting function was requested during formal review.
-    inline void report_exception( std::ostream & os, 
-                                  const char * name, const char * info )
-      { os << "\n** uncaught exception: " << name << " " << info << std::endl; }
-  }
-
-  //  catch_exceptions  ------------------------------------------------------//
-
-  template< class Generator >  // Generator is function object returning int
-  int catch_exceptions( Generator function_object,
-                        std::ostream & out, std::ostream & err )
-  {
-    int result = 0;               // quiet compiler warnings
-    bool exception_thrown = true; // avoid setting result for each excptn type
-
-#ifndef BOOST_NO_EXCEPTIONS
-    try
-    {
-#endif
-      result = function_object();
-      exception_thrown = false;
-#ifndef BOOST_NO_EXCEPTIONS
-    }
-
-    //  As a result of hard experience with strangely interleaved output
-    //  under some compilers, there is a lot of use of endl in the code below
-    //  where a simple '\n' might appear to do.
-
-    //  The rules for catch & arguments are a bit different from function 
-    //  arguments (ISO 15.3 paragraphs 18 & 19). Apparently const isn't
-    //  required, but it doesn't hurt and some programmers ask for it.
-
-    catch ( const char * ex )
-      { detail::report_exception( out, "", ex ); }
-    catch ( const std::string & ex )
-      { detail::report_exception( out, "", ex.c_str() ); }
-
-    //  std:: exceptions
-    catch ( const std::bad_alloc & ex )
-      { detail::report_exception( out, "std::bad_alloc:", ex.what() ); }
-
-# ifndef BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT
-    catch ( const std::bad_cast & ex )
-      { detail::report_exception( out, "std::bad_cast:", ex.what() ); }
-    catch ( const std::bad_typeid & ex )
-      { detail::report_exception( out, "std::bad_typeid:", ex.what() ); }
-# else
-    catch ( const std::bad_cast & )
-      { detail::report_exception( out, "std::bad_cast", "" ); }
-    catch ( const std::bad_typeid & )
-      { detail::report_exception( out, "std::bad_typeid", "" ); }
-# endif
-
-    catch ( const std::bad_exception & ex )
-      { detail::report_exception( out, "std::bad_exception:", ex.what() ); }
-    catch ( const std::domain_error & ex )
-      { detail::report_exception( out, "std::domain_error:", ex.what() ); }
-    catch ( const std::invalid_argument & ex )
-      { detail::report_exception( out, "std::invalid_argument:", ex.what() ); }
-    catch ( const std::length_error & ex )
-      { detail::report_exception( out, "std::length_error:", ex.what() ); }
-    catch ( const std::out_of_range & ex )
-      { detail::report_exception( out, "std::out_of_range:", ex.what() ); }
-    catch ( const std::range_error & ex )
-      { detail::report_exception( out, "std::range_error:", ex.what() ); }
-    catch ( const std::overflow_error & ex )
-      { detail::report_exception( out, "std::overflow_error:", ex.what() ); }
-    catch ( const std::underflow_error & ex )
-      { detail::report_exception( out, "std::underflow_error:", ex.what() ); }
-    catch ( const std::logic_error & ex )
-      { detail::report_exception( out, "std::logic_error:", ex.what() ); }
-    catch ( const std::runtime_error & ex )
-      { detail::report_exception( out, "std::runtime_error:", ex.what() ); }
-    catch ( const std::exception & ex )
-      { detail::report_exception( out, "std::exception:", ex.what() ); }
-
-    catch ( ... )
-      { detail::report_exception( out, "unknown exception", "" ); }
-#endif // BOOST_NO_EXCEPTIONS
-
-    if ( exception_thrown ) result = boost::exit_exception_failure;
-
-    if ( result != 0 && result != exit_success )
-    {
-      out << std::endl << "**** returning with error code "
-                << result << std::endl;
-      err
-        << "**********  errors detected; see stdout for details  ***********"
-        << std::endl;
-    }
-#if !defined(BOOST_NO_CPP_MAIN_SUCCESS_MESSAGE)
-    else { out << std::flush << "no errors detected" << std::endl; }
-#endif
-    return result;
-  } // catch_exceptions
-
-} // boost
-
-#endif  // BOOST_CATCH_EXCEPTIONS_HPP
-

include/boost/detail/endian.hpp

@@ -1,73 +0,0 @@
-// Copyright 2005 Caleb Epstein
-// Copyright 2006 John Maddock
-// Distributed under the Boost Software License, Version 1.0. (See accompany-
-// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-/*
- * Copyright (c) 1997
- * Silicon Graphics Computer Systems, Inc.
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Silicon Graphics makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- */
-
-/*
- * Copyright notice reproduced from <boost/detail/limits.hpp>, from
- * which this code was originally taken.
- *
- * Modified by Caleb Epstein to use <endian.h> with GNU libc and to
- * defined the BOOST_ENDIAN macro.
- */
-
-#ifndef BOOST_DETAIL_ENDIAN_HPP
-#define BOOST_DETAIL_ENDIAN_HPP
-
-// GNU libc offers the helpful header <endian.h> which defines
-// __BYTE_ORDER
-
-#if defined (__GLIBC__)
-# include <endian.h>
-# if (__BYTE_ORDER == __LITTLE_ENDIAN)
-#  define BOOST_LITTLE_ENDIAN
-# elif (__BYTE_ORDER == __BIG_ENDIAN)
-#  define BOOST_BIG_ENDIAN
-# elif (__BYTE_ORDER == __PDP_ENDIAN)
-#  define BOOST_PDP_ENDIAN
-# else
-#  error Unknown machine endianness detected.
-# endif
-# define BOOST_BYTE_ORDER __BYTE_ORDER
-#elif defined(_BIG_ENDIAN)
-# define BOOST_BIG_ENDIAN
-# define BOOST_BYTE_ORDER 4321
-#elif defined(_LITTLE_ENDIAN)
-# define BOOST_LITTLE_ENDIAN
-# define BOOST_BYTE_ORDER 1234
-#elif defined(__sparc) || defined(__sparc__) \
-   || defined(_POWER) || defined(__powerpc__) \
-   || defined(__ppc__) || defined(__hpux) \
-   || defined(_MIPSEB) || defined(_POWER) \
-   || defined(__s390__)
-# define BOOST_BIG_ENDIAN
-# define BOOST_BYTE_ORDER 4321
-#elif defined(__i386__) || defined(__alpha__) \
-   || defined(__ia64) || defined(__ia64__) \
-   || defined(_M_IX86) || defined(_M_IA64) \
-   || defined(_M_ALPHA) || defined(__amd64) \
-   || defined(__amd64__) || defined(_M_AMD64) \
-   || defined(__x86_64) || defined(__x86_64__) \
-   || defined(_M_X64)
-
-# define BOOST_LITTLE_ENDIAN
-# define BOOST_BYTE_ORDER 1234
-#else
-# error The file boost/detail/endian.hpp needs to be set up for your CPU type.
-#endif
-
-
-#endif

include/boost/detail/has_default_constructor.hpp

@@ -1,29 +0,0 @@
-
-//  (C) Copyright Matthias Troyerk 2006.
-//  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/type_traits for most recent version including documentation.
-
-#ifndef BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED
-#define BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED
-
-#include <boost/type_traits/has_trivial_constructor.hpp>
-
-namespace boost { namespace detail {
-
-/// type trait to check for a default constructor
-///
-/// The default implementation just checks for a trivial constructor.
-/// Using some compiler magic it might be possible to provide a better default
-
-template <class T>
-struct has_default_constructor
- : public has_trivial_constructor<T>
-{};
-
-} } // namespace boost::detail
-
-
-#endif // BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED

include/boost/detail/identifier.hpp

@@ -1,89 +0,0 @@
-//  boost/identifier.hpp  ----------------------------------------------------//
-
-//  Copyright Beman Dawes 2006
-
-//  Distributed under 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 documentation at http://www.boost.org/libs/utility
-
-#ifndef BOOST_IDENTIFIER_HPP
-#define BOOST_IDENTIFIER_HPP
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_base_of.hpp>
-#include <iosfwd>
-
-namespace boost
-{
-  namespace detail
-  {
-    //  class template identifier  ---------------------------------------------//
-
-    //  Always used as a base class so that different instantiations result in
-    //  different class types even if instantiated with the same value type T.
-
-    //  Expected usage is that T is often an integer type, best passed by
-    //  value. There is no reason why T can't be a possibly larger class such as
-    //  std::string, best passed by const reference.
-
-    //  This implementation uses pass by value, based on expected common uses.
-
-    template <typename T, typename D>
-    class identifier
-    {
-    public:
-      typedef T value_type;
-
-      const value_type value() const           { return m_value; }
-      void  assign( value_type v )             { m_value = v; }
-
-      bool operator==( const D & rhs ) const   { return m_value == rhs.m_value; }
-      bool operator!=( const D & rhs ) const   { return m_value != rhs.m_value; }
-      bool operator< ( const D & rhs ) const   { return m_value <  rhs.m_value; }
-      bool operator<=( const D & rhs ) const   { return m_value <= rhs.m_value; }
-      bool operator> ( const D & rhs ) const   { return m_value >  rhs.m_value; }
-      bool operator>=( const D & rhs ) const   { return m_value >= rhs.m_value; }
-
-      typedef void (*unspecified_bool_type)(D); // without the D, unspecified_bool_type 
-      static void unspecified_bool_true(D){}    // conversion allows relational operators
-                                                // between different identifier types
-
-      operator unspecified_bool_type() const   { return m_value == value_type() ? 0 : unspecified_bool_true; }
-      bool operator!() const                   { return m_value == value_type(); }
-
-    // constructors are protected so that class can only be used as a base class
-    protected:
-      identifier()                             {}
-      explicit identifier( value_type v )      : m_value(v) {}
-
-  #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300  // 1300 == VC++ 7.0 bug workaround
-    private:
-  #endif
-      T m_value;
-    };
-
-  //#ifndef BOOST_NO_SFINAE
-
-  //  template <class Ostream, class Id>
-  //    typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, 
-  //      Ostream & >::type operator<<( Ostream & os, const Id & id )
-  //  {
-  //    return os << id.value();
-  //  }
-
-  //  template <class Istream, class Id>
-  //    typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, 
-  //      Istream & >::type operator>>( Istream & is, Id & id )
-  //  {
-  //    typename Id::value_type v;
-  //    is >> v;
-  //    id.value( v );
-  //    return is;
-  //  }
-  //#endif
-
-  } // namespace detail
-} // namespace boost
-
-#endif // BOOST_IDENTIFIER_HPP

include/boost/detail/indirect_traits.hpp

@@ -1,487 +0,0 @@
-// Copyright David Abrahams 2002.
-// Distributed under 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)
-#ifndef INDIRECT_TRAITS_DWA2002131_HPP
-# define INDIRECT_TRAITS_DWA2002131_HPP
-# include <boost/type_traits/is_function.hpp>
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/is_pointer.hpp>
-# include <boost/type_traits/is_class.hpp>
-# include <boost/type_traits/is_const.hpp>
-# include <boost/type_traits/is_volatile.hpp>
-# include <boost/type_traits/is_member_function_pointer.hpp>
-# include <boost/type_traits/is_member_pointer.hpp>
-# include <boost/type_traits/remove_cv.hpp>
-# include <boost/type_traits/remove_reference.hpp>
-# include <boost/type_traits/remove_pointer.hpp>
-
-# include <boost/type_traits/detail/ice_and.hpp>
-# include <boost/detail/workaround.hpp>
-
-# include <boost/mpl/eval_if.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/not.hpp>
-# include <boost/mpl/aux_/lambda_support.hpp>
-
-#  ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#   include <boost/detail/is_function_ref_tester.hpp>
-#  endif 
-
-namespace boost { namespace detail {
-
-namespace indirect_traits {
-
-#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct is_reference_to_const : mpl::false_
-{
-};
-
-template <class T>
-struct is_reference_to_const<T const&> : mpl::true_
-{
-};
-
-#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
-template<class T>
-struct is_reference_to_const<T const volatile&> : mpl::true_
-{
-};
-#   endif 
-
-template <class T>
-struct is_reference_to_function : mpl::false_
-{
-};
-
-template <class T>
-struct is_reference_to_function<T&> : is_function<T>
-{
-};
-
-template <class T>
-struct is_pointer_to_function : mpl::false_
-{
-};
-
-// There's no such thing as a pointer-to-cv-function, so we don't need
-// specializations for those
-template <class T>
-struct is_pointer_to_function<T*> : is_function<T>
-{
-};
-
-template <class T>
-struct is_reference_to_member_function_pointer_impl : mpl::false_
-{
-};
-
-template <class T>
-struct is_reference_to_member_function_pointer_impl<T&>
-    : is_member_function_pointer<typename remove_cv<T>::type>
-{
-};
-
-
-template <class T>
-struct is_reference_to_member_function_pointer
-    : is_reference_to_member_function_pointer_impl<T>
-{
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
-};
-
-template <class T>
-struct is_reference_to_function_pointer_aux
-    : mpl::and_<
-          is_reference<T>
-        , is_pointer_to_function<
-              typename remove_cv<
-                  typename remove_reference<T>::type
-              >::type
-          >
-      >
-{
-    // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
-};
-
-template <class T>
-struct is_reference_to_function_pointer
-    : mpl::if_<
-          is_reference_to_function<T>
-        , mpl::false_
-        , is_reference_to_function_pointer_aux<T>
-     >::type
-{
-};
-
-template <class T>
-struct is_reference_to_non_const
-    : mpl::and_<
-          is_reference<T>
-        , mpl::not_<
-             is_reference_to_const<T>
-          >
-      >
-{
-};
-
-template <class T>
-struct is_reference_to_volatile : mpl::false_
-{
-};
-
-template <class T>
-struct is_reference_to_volatile<T volatile&> : mpl::true_
-{
-};
-
-#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
-template <class T>
-struct is_reference_to_volatile<T const volatile&> : mpl::true_
-{
-};
-#   endif 
-
-
-template <class T>
-struct is_reference_to_pointer : mpl::false_
-{
-};
-
-template <class T>
-struct is_reference_to_pointer<T*&> : mpl::true_
-{
-};
-
-template <class T>
-struct is_reference_to_pointer<T* const&> : mpl::true_
-{
-};
-
-template <class T>
-struct is_reference_to_pointer<T* volatile&> : mpl::true_
-{
-};
-
-template <class T>
-struct is_reference_to_pointer<T* const volatile&> : mpl::true_
-{
-};
-
-template <class T>
-struct is_reference_to_class
-    : mpl::and_<
-          is_reference<T>
-        , is_class<
-              typename remove_cv<
-                  typename remove_reference<T>::type
-              >::type
-          >
-      >
-{
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
-};
-
-template <class T>
-struct is_pointer_to_class
-    : mpl::and_<
-          is_pointer<T>
-        , is_class<
-              typename remove_cv<
-                  typename remove_pointer<T>::type
-              >::type
-          >
-      >
-{
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
-};
-
-#  else
-
-using namespace boost::detail::is_function_ref_tester_;
-
-typedef char (&inner_yes_type)[3];
-typedef char (&inner_no_type)[2];
-typedef char (&outer_no_type)[1];
-
-template <typename V>
-struct is_const_help
-{
-    typedef typename mpl::if_<
-          is_const<V>
-        , inner_yes_type
-        , inner_no_type
-        >::type type;
-};
-
-template <typename V>
-struct is_volatile_help
-{
-    typedef typename mpl::if_<
-          is_volatile<V>
-        , inner_yes_type
-        , inner_no_type
-        >::type type;
-};
-
-template <typename V>
-struct is_pointer_help
-{
-    typedef typename mpl::if_<
-          is_pointer<V>
-        , inner_yes_type
-        , inner_no_type
-        >::type type;
-};
-
-template <typename V>
-struct is_class_help
-{
-    typedef typename mpl::if_<
-          is_class<V>
-        , inner_yes_type
-        , inner_no_type
-        >::type type;
-};
-
-template <class T>
-struct is_reference_to_function_aux
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::boost::type_traits::yes_type));
-    typedef mpl::bool_<value> type;
- };
-
-template <class T>
-struct is_reference_to_function
-    : mpl::if_<is_reference<T>, is_reference_to_function_aux<T>, mpl::bool_<false> >::type
-{
-};
-
-template <class T>
-struct is_pointer_to_function_aux
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
-    typedef mpl::bool_<value> type;
-};
-
-template <class T>
-struct is_pointer_to_function
-    : mpl::if_<is_pointer<T>, is_pointer_to_function_aux<T>, mpl::bool_<false> >::type
-{
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T))
-};
-
-struct false_helper1
-{
-    template <class T>
-    struct apply : mpl::false_
-    {
-    };
-};
-
-template <typename V>
-typename is_const_help<V>::type reference_to_const_helper(V&);    
-outer_no_type
-reference_to_const_helper(...);
-
-struct true_helper1
-{
-    template <class T>
-    struct apply
-    {
-        static T t;
-        BOOST_STATIC_CONSTANT(
-            bool, value
-            = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
-        typedef mpl::bool_<value> type;
-    };
-};
-
-template <bool ref = true>
-struct is_reference_to_const_helper1 : true_helper1
-{
-};
-
-template <>
-struct is_reference_to_const_helper1<false> : false_helper1
-{
-};
-
-
-template <class T>
-struct is_reference_to_const
-    : is_reference_to_const_helper1<is_reference<T>::value>::template apply<T>
-{
-};
-
-
-template <bool ref = true>
-struct is_reference_to_non_const_helper1
-{
-    template <class T>
-    struct apply
-    {
-        static T t;
-        BOOST_STATIC_CONSTANT(
-            bool, value
-            = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
-        
-        typedef mpl::bool_<value> type;
-    };
-};
-
-template <>
-struct is_reference_to_non_const_helper1<false> : false_helper1
-{
-};
-
-
-template <class T>
-struct is_reference_to_non_const
-    : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T>
-{
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T))
-};
-
-
-template <typename V>
-typename is_volatile_help<V>::type reference_to_volatile_helper(V&);    
-outer_no_type
-reference_to_volatile_helper(...);
-
-template <bool ref = true>
-struct is_reference_to_volatile_helper1
-{
-    template <class T>
-    struct apply
-    {
-        static T t;
-        BOOST_STATIC_CONSTANT(
-            bool, value
-            = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
-        typedef mpl::bool_<value> type;
-    };
-};
-
-template <>
-struct is_reference_to_volatile_helper1<false> : false_helper1
-{
-};
-
-
-template <class T>
-struct is_reference_to_volatile
-    : is_reference_to_volatile_helper1<is_reference<T>::value>::template apply<T>
-{
-};
-
-template <typename V>
-typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
-outer_no_type reference_to_pointer_helper(...);
-
-template <class T>
-struct reference_to_pointer_impl
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type))
-        );
-    
-    typedef mpl::bool_<value> type;
-};
-    
-template <class T>
-struct is_reference_to_pointer
-  : mpl::eval_if<is_reference<T>, reference_to_pointer_impl<T>, mpl::false_>::type
-{   
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T))
-};
-
-template <class T>
-struct is_reference_to_function_pointer
-  : mpl::eval_if<is_reference<T>, is_pointer_to_function_aux<T>, mpl::false_>::type
-{
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
-};
-
-
-template <class T>
-struct is_member_function_pointer_help
-    : mpl::if_<is_member_function_pointer<T>, inner_yes_type, inner_no_type>
-{};
-
-template <typename V>
-typename is_member_function_pointer_help<V>::type member_function_pointer_helper(V&);
-outer_no_type member_function_pointer_helper(...);
-
-template <class T>
-struct is_pointer_to_member_function_aux
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type));
-    typedef mpl::bool_<value> type;
-};
-
-template <class T>
-struct is_reference_to_member_function_pointer
-    : mpl::if_<
-        is_reference<T>
-        , is_pointer_to_member_function_aux<T>
-        , mpl::bool_<false>
-     >::type
-{
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
-};
-
-template <typename V>
-typename is_class_help<V>::type reference_to_class_helper(V const volatile&);
-outer_no_type reference_to_class_helper(...);
-
-template <class T>
-struct is_reference_to_class
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = (is_reference<T>::value
-           & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type)))
-        );
-    typedef mpl::bool_<value> type;
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
-};
-
-template <typename V>
-typename is_class_help<V>::type pointer_to_class_helper(V const volatile*);
-outer_no_type pointer_to_class_helper(...);
-
-template <class T>
-struct is_pointer_to_class
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = (is_pointer<T>::value
-           && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type))
-        );
-    typedef mpl::bool_<value> type;
-};
-#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
-
-}
-
-using namespace indirect_traits;
-
-}} // namespace boost::python::detail
-
-#endif // INDIRECT_TRAITS_DWA2002131_HPP

include/boost/detail/interlocked.hpp

@@ -1,125 +0,0 @@
-#ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
-#define BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  boost/detail/interlocked.hpp
-//
-//  Copyright 2005 Peter Dimov
-//
-//  Distributed under 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)
-//
-
-#include <boost/config.hpp>
-
-#if defined( BOOST_USE_WINDOWS_H )
-
-# include <windows.h>
-
-# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER InterlockedCompareExchangePointer
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER InterlockedExchangePointer
-
-#elif defined(_WIN32_WCE)
-
-// under Windows CE we still have old-style Interlocked* functions
-
-extern "C" long __cdecl InterlockedIncrement( long* );
-extern "C" long __cdecl InterlockedDecrement( long* );
-extern "C" long __cdecl InterlockedCompareExchange( long*, long, long );
-extern "C" long __cdecl InterlockedExchange( long*, long );
-extern "C" long __cdecl InterlockedExchangeAdd( long*, long );
-
-# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
-
-#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN )
-
-extern "C" long __cdecl _InterlockedIncrement( long volatile * );
-extern "C" long __cdecl _InterlockedDecrement( long volatile * );
-extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
-extern "C" long __cdecl _InterlockedExchange( long volatile *, long);
-extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long);
-
-# pragma intrinsic( _InterlockedIncrement )
-# pragma intrinsic( _InterlockedDecrement )
-# pragma intrinsic( _InterlockedCompareExchange )
-# pragma intrinsic( _InterlockedExchange )
-# pragma intrinsic( _InterlockedExchangeAdd )
-
-# if defined(_M_IA64) || defined(_M_AMD64)
-
-extern "C" void* __cdecl _InterlockedCompareExchangePointer( void* volatile *, void*, void* );
-extern "C" void* __cdecl _InterlockedExchangePointer( void* volatile *, void* );
-
-#  pragma intrinsic( _InterlockedCompareExchangePointer )
-#  pragma intrinsic( _InterlockedExchangePointer )
-
-#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer
-#  define BOOST_INTERLOCKED_EXCHANGE_POINTER _InterlockedExchangePointer
-
-# else
-
-#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
-    ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
-#  define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
-    ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
-
-# endif
-
-# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
-
-#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
-
-namespace boost
-{
-
-namespace detail
-{
-
-extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement( long volatile * );
-extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement( long volatile * );
-extern "C" __declspec(dllimport) long __stdcall InterlockedCompareExchange( long volatile *, long, long );
-extern "C" __declspec(dllimport) long __stdcall InterlockedExchange( long volatile *, long );
-extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long volatile *, long );
-
-} // namespace detail
-
-} // namespace boost
-
-# define BOOST_INTERLOCKED_INCREMENT ::boost::detail::InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT ::boost::detail::InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd
-
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
-    ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
-    ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
-
-#else
-
-# error "Interlocked intrinsics not available"
-
-#endif
-
-#endif // #ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED

include/boost/detail/is_function_ref_tester.hpp

@@ -1,135 +0,0 @@
-
-// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, 
-// Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000.  
-// Distributed under 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)
-
-#if !defined(BOOST_PP_IS_ITERATING)
-
-///// header body
-
-#ifndef BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
-#define BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
-
-#include "boost/type_traits/detail/yes_no_type.hpp"
-#include "boost/type_traits/config.hpp"
-
-#if defined(BOOST_TT_PREPROCESSING_MODE)
-#   include "boost/preprocessor/iterate.hpp"
-#   include "boost/preprocessor/enum_params.hpp"
-#   include "boost/preprocessor/comma_if.hpp"
-#endif
-
-namespace boost {
-namespace detail {
-namespace is_function_ref_tester_ {
-
-template <class T>
-boost::type_traits::no_type BOOST_TT_DECL is_function_ref_tester(T& ...);
-
-#if !defined(BOOST_TT_PREPROCESSING_MODE)
-// preprocessor-generated part, don't edit by hand!
-
-template <class R>
-boost::type_traits::yes_type is_function_ref_tester(R (&)(), int);
-
-template <class R,class T0 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0), int);
-
-template <class R,class T0,class T1 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1), int);
-
-template <class R,class T0,class T1,class T2 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2), int);
-
-template <class R,class T0,class T1,class T2,class T3 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24), int);
-
-#else
-
-#define BOOST_PP_ITERATION_PARAMS_1 \
-    (3, (0, 25, "boost/type_traits/detail/is_function_ref_tester.hpp"))
-#include BOOST_PP_ITERATE()
-
-#endif // BOOST_TT_PREPROCESSING_MODE
-
-} // namespace detail
-} // namespace python
-} // namespace boost
-
-#endif // BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
-
-///// iteration
-
-#else
-#define i BOOST_PP_FRAME_ITERATION(1)
-
-template <class R BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T) >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(BOOST_PP_ENUM_PARAMS(i,T)), int);
-
-#undef i
-#endif // BOOST_PP_IS_ITERATING

include/boost/detail/is_incrementable.hpp

@@ -1,124 +0,0 @@
-// Copyright David Abrahams 2004. Use, modification and distribution is
-// 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)
-#ifndef IS_INCREMENTABLE_DWA200415_HPP
-# define IS_INCREMENTABLE_DWA200415_HPP
-
-# include <boost/type_traits/detail/template_arity_spec.hpp>
-# include <boost/type_traits/remove_cv.hpp>
-# include <boost/mpl/aux_/lambda_support.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/detail/workaround.hpp>
-
-// Must be the last include
-# include <boost/type_traits/detail/bool_trait_def.hpp>
-
-namespace boost { namespace detail { 
-
-// is_incrementable<T> metafunction
-//
-// Requires: Given x of type T&, if the expression ++x is well-formed
-// it must have complete type; otherwise, it must neither be ambiguous
-// nor violate access.
-
-// This namespace ensures that ADL doesn't mess things up.
-namespace is_incrementable_
-{
-  // a type returned from operator++ when no increment is found in the
-  // type's own namespace
-  struct tag {};
-  
-  // any soaks up implicit conversions and makes the following
-  // operator++ less-preferred than any other such operator that
-  // might be found via ADL.
-  struct any { template <class T> any(T const&); };
-
-  // This is a last-resort operator++ for when none other is found
-# if BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
-  
-}
-
-namespace is_incrementable_2
-{
-  is_incrementable_::tag operator++(is_incrementable_::any const&);
-  is_incrementable_::tag operator++(is_incrementable_::any const&,int);
-}
-using namespace is_incrementable_2;
-
-namespace is_incrementable_
-{
-  
-# else
-  
-  tag operator++(any const&);
-  tag operator++(any const&,int);
-  
-# endif 
-
-# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \
-    || BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-#  define BOOST_comma(a,b) (a)
-# else 
-  // In case an operator++ is found that returns void, we'll use ++x,0
-  tag operator,(tag,int);  
-#  define BOOST_comma(a,b) (a,b)
-# endif 
-  
-  // two check overloads help us identify which operator++ was picked
-  char (& check(tag) )[2];
-  
-  template <class T>
-  char check(T const&);
-  
-
-  template <class T>
-  struct impl
-  {
-      static typename boost::remove_cv<T>::type& x;
-
-      BOOST_STATIC_CONSTANT(
-          bool
-        , value = sizeof(is_incrementable_::check(BOOST_comma(++x,0))) == 1
-      );
-  };
-
-  template <class T>
-  struct postfix_impl
-  {
-      static typename boost::remove_cv<T>::type& x;
-
-      BOOST_STATIC_CONSTANT(
-          bool
-        , value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1
-      );
-  };
-}
-
-# undef BOOST_comma
-
-template<typename T> 
-struct is_incrementable 
-BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::impl<T>::value)
-{ 
-    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::impl<T>::value)
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_incrementable,(T))
-};
-
-template<typename T> 
-struct is_postfix_incrementable 
-BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::impl<T>::value)
-{ 
-    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::postfix_impl<T>::value)
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_postfix_incrementable,(T))
-};
-
-} // namespace detail
-
-BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_incrementable)
-BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_postfix_incrementable)
-
-} // namespace boost
-
-# include <boost/type_traits/detail/bool_trait_undef.hpp>
-
-#endif // IS_INCREMENTABLE_DWA200415_HPP

include/boost/detail/is_xxx.hpp

@@ -1,61 +0,0 @@
-// Copyright David Abrahams 2005. Distributed under 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)
-#ifndef BOOST_DETAIL_IS_XXX_DWA20051011_HPP
-# define BOOST_DETAIL_IS_XXX_DWA20051011_HPP
-
-# include <boost/config.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/preprocessor/enum_params.hpp>
-
-# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/add_reference.hpp>
-
-#  define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs)          \
-template <class X_>                                                     \
-struct is_##name                                                        \
-{                                                                       \
-    typedef char yes;                                                   \
-    typedef char (&no)[2];                                              \
-                                                                        \
-    static typename add_reference<X_>::type dummy;                      \
-                                                                        \
-    struct helpers                                                      \
-    {                                                                   \
-        template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class U) >          \
-        static yes test(                                                \
-           qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, U) >&, int  \
-        );                                                              \
-                                                                        \
-        template <class U>                                              \
-        static no test(U&, ...);                                        \
-    };                                                                  \
-                                                                        \
-    BOOST_STATIC_CONSTANT(                                              \
-        bool, value                                                     \
-        = !is_reference<X_>::value                                      \
-        & (sizeof(helpers::test(dummy, 0)) == sizeof(yes)));            \
-                                                                        \
-    typedef mpl::bool_<value> type;                                     \
-};
-
-# else
-
-#  define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs)  \
-template <class T>                                              \
-struct is_##name : mpl::false_                                  \
-{                                                               \
-};                                                              \
-                                                                \
-template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class T) >          \
-struct is_##name<                                               \
-   qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, T) >        \
->                                                               \
-   : mpl::true_                                                 \
-{                                                               \
-};
-
-# endif
-
-#endif // BOOST_DETAIL_IS_XXX_DWA20051011_HPP

include/boost/detail/iterator.hpp

@@ -1,494 +0,0 @@
-// (C) Copyright David Abrahams 2002.
-// Distributed under 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)
-
-// Boost versions of
-//
-//    std::iterator_traits<>::iterator_category
-//    std::iterator_traits<>::difference_type
-//    std::distance()
-//
-// ...for all compilers and iterators
-//
-// Additionally, if X is a pointer
-//    std::iterator_traits<X>::pointer
-
-// Otherwise, if partial specialization is supported or X is not a pointer
-//    std::iterator_traits<X>::value_type
-//    std::iterator_traits<X>::pointer
-//    std::iterator_traits<X>::reference
-//
-// See http://www.boost.org for most recent version including documentation.
-
-// Revision History
-// 04 Mar 2001 - More attempted fixes for Intel C++ (David Abrahams)
-// 03 Mar 2001 - Put all implementation into namespace
-//               boost::detail::iterator_traits_. Some progress made on fixes
-//               for Intel compiler. (David Abrahams)
-// 02 Mar 2001 - Changed BOOST_MSVC to BOOST_MSVC_STD_ITERATOR in a few
-//               places. (Jeremy Siek)
-// 19 Feb 2001 - Improved workarounds for stock MSVC6; use yes_type and
-//               no_type from type_traits.hpp; stopped trying to remove_cv
-//               before detecting is_pointer, in honor of the new type_traits
-//               semantics. (David Abrahams)
-// 13 Feb 2001 - Make it work with nearly all standard-conforming iterators
-//               under raw VC6. The one category remaining which will fail is
-//               that of iterators derived from std::iterator but not
-//               boost::iterator and which redefine difference_type.
-// 11 Feb 2001 - Clean away code which can never be used (David Abrahams)
-// 09 Feb 2001 - Always have a definition for each traits member, even if it
-//               can't be properly deduced. These will be incomplete types in
-//               some cases (undefined<void>), but it helps suppress MSVC errors
-//               elsewhere (David Abrahams)
-// 07 Feb 2001 - Support for more of the traits members where possible, making
-//               this useful as a replacement for std::iterator_traits<T> when
-//               used as a default template parameter.
-// 06 Feb 2001 - Removed useless #includes of standard library headers
-//               (David Abrahams)
-
-#ifndef ITERATOR_DWA122600_HPP_
-# define ITERATOR_DWA122600_HPP_
-
-# include <boost/config.hpp>
-# include <iterator>
-
-// STLPort 4.0 and betas have a bug when debugging is enabled and there is no
-// partial specialization: instead of an iterator_category typedef, the standard
-// container iterators have _Iterator_category.
-//
-// Also, whether debugging is enabled or not, there is a broken specialization
-// of std::iterator<output_iterator_tag,void,void,void,void> which has no
-// typedefs but iterator_category.
-# if defined(__SGI_STL_PORT)
-
-#  if (__SGI_STL_PORT <= 0x410) && !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && defined(__STL_DEBUG)
-#   define BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-#  endif
-
-#  define BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
-
-# endif // STLPort <= 4.1b4 && no partial specialization
-
-# if !defined(BOOST_NO_STD_ITERATOR_TRAITS)             \
-  && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
-  && !defined(BOOST_MSVC_STD_ITERATOR)
-    
-namespace boost { namespace detail {
-
-// Define a new template so it can be specialized
-template <class Iterator>
-struct iterator_traits
-    : std::iterator_traits<Iterator>
-{};
-using std::distance;
-
-}} // namespace boost::detail
-
-# else
-
-#  if  !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)  \
-    && !defined(BOOST_MSVC_STD_ITERATOR)
-
-// This is the case where everything conforms except BOOST_NO_STD_ITERATOR_TRAITS
-
-namespace boost { namespace detail {
-
-// Rogue Wave Standard Library fools itself into thinking partial
-// specialization is missing on some platforms (e.g. Sun), so fails to
-// supply iterator_traits!
-template <class Iterator>
-struct iterator_traits
-{
-    typedef typename Iterator::value_type value_type;
-    typedef typename Iterator::reference reference;
-    typedef typename Iterator::pointer pointer;
-    typedef typename Iterator::difference_type difference_type;
-    typedef typename Iterator::iterator_category iterator_category;
-};
-
-template <class T>
-struct iterator_traits<T*>
-{
-    typedef T value_type;
-    typedef T& reference;
-    typedef T* pointer;
-    typedef std::ptrdiff_t difference_type;
-    typedef std::random_access_iterator_tag iterator_category;
-};
-
-template <class T>
-struct iterator_traits<T const*>
-{
-    typedef T value_type;
-    typedef T const& reference;
-    typedef T const* pointer;
-    typedef std::ptrdiff_t difference_type;
-    typedef std::random_access_iterator_tag iterator_category;
-};
-
-}} // namespace boost::detail
-
-#  else
-
-# include <boost/type_traits/remove_const.hpp>
-# include <boost/type_traits/detail/yes_no_type.hpp>
-# include <boost/type_traits/is_pointer.hpp>
-
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#  include <boost/type_traits/is_same.hpp>
-#  include <boost/type_traits/remove_pointer.hpp>
-# endif
-# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
-#  include <boost/type_traits/is_base_and_derived.hpp>
-# endif
-
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/has_xxx.hpp>
-# include <cstddef>
-
-// should be the last #include
-# include "boost/type_traits/detail/bool_trait_def.hpp"
-
-namespace boost { namespace detail {
-
-BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(pointer)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category)
-
-// is_mutable_iterator --
-//
-//   A metafunction returning true iff T is a mutable iterator type
-//   with a nested value_type. Will only work portably with iterators
-//   whose operator* returns a reference, but that seems to be OK for
-//   the iterators supplied by Dinkumware. Some input iterators may
-//   compile-time if they arrive here, and if the compiler is strict
-//   about not taking the address of an rvalue.
-
-// This one detects ordinary mutable iterators - the result of
-// operator* is convertible to the value_type.
-template <class T>
-type_traits::yes_type is_mutable_iterator_helper(T const*, BOOST_DEDUCED_TYPENAME T::value_type*);
-
-// Since you can't take the address of an rvalue, the guts of
-// is_mutable_iterator_impl will fail if we use &*t directly.  This
-// makes sure we can still work with non-lvalue iterators.
-template <class T> T* mutable_iterator_lvalue_helper(T& x);
-int mutable_iterator_lvalue_helper(...);
-
-
-// This one detects output iterators such as ostream_iterator which
-// return references to themselves.
-template <class T>
-type_traits::yes_type is_mutable_iterator_helper(T const*, T const*);
-
-type_traits::no_type is_mutable_iterator_helper(...);
-
-template <class T>
-struct is_mutable_iterator_impl
-{
-    static T t;
-    
-    BOOST_STATIC_CONSTANT(
-        bool, value = sizeof(
-            detail::is_mutable_iterator_helper(
-                (T*)0
-              , mutable_iterator_lvalue_helper(*t) // like &*t
-            ))
-        == sizeof(type_traits::yes_type)
-    );
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_mutable_iterator,T,::boost::detail::is_mutable_iterator_impl<T>::value)
-
-
-// is_full_iterator_traits --
-//
-//   A metafunction returning true iff T has all the requisite nested
-//   types to satisfy the requirements for a fully-conforming
-//   iterator_traits implementation.
-template <class T>
-struct is_full_iterator_traits_impl
-{
-    enum { value = 
-           has_value_type<T>::value 
-           & has_reference<T>::value 
-           & has_pointer<T>::value 
-           & has_difference_type<T>::value
-           & has_iterator_category<T>::value
-    };
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_full_iterator_traits,T,::boost::detail::is_full_iterator_traits_impl<T>::value)
-
-
-#   ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-BOOST_MPL_HAS_XXX_TRAIT_DEF(_Iterator_category)
-    
-// is_stlport_40_debug_iterator --
-//
-//   A metafunction returning true iff T has all the requisite nested
-//   types to satisfy the requirements of an STLPort 4.0 debug iterator
-//   iterator_traits implementation.
-template <class T>
-struct is_stlport_40_debug_iterator_impl
-{
-    enum { value = 
-           has_value_type<T>::value 
-           & has_reference<T>::value 
-           & has_pointer<T>::value 
-           & has_difference_type<T>::value
-           & has__Iterator_category<T>::value
-    };
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_stlport_40_debug_iterator,T,::boost::detail::is_stlport_40_debug_iterator_impl<T>::value)
-
-template <class T>
-struct stlport_40_debug_iterator_traits
-{
-    typedef typename T::value_type value_type;
-    typedef typename T::reference reference;
-    typedef typename T::pointer pointer;
-    typedef typename T::difference_type difference_type;
-    typedef typename T::_Iterator_category iterator_category;
-};
-#   endif // BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF 
-
-template <class T> struct pointer_iterator_traits;
-
-#   ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct pointer_iterator_traits<T*>
-{
-    typedef typename remove_const<T>::type value_type;
-    typedef T* pointer;
-    typedef T& reference;
-    typedef std::random_access_iterator_tag iterator_category;
-    typedef std::ptrdiff_t difference_type;
-};
-#   else
-
-// In case of no template partial specialization, and if T is a
-// pointer, iterator_traits<T>::value_type can still be computed.  For
-// some basic types, remove_pointer is manually defined in
-// type_traits/broken_compiler_spec.hpp. For others, do it yourself.
-
-template<class P> class please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee;
-
-template<class P>
-struct pointer_value_type
-  : mpl::if_<
-        is_same<P, typename remove_pointer<P>::type>
-      , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
-      , typename remove_const<
-            typename remove_pointer<P>::type
-        >::type
-    >
-{
-};
-
-
-template<class P>
-struct pointer_reference
-  : mpl::if_<
-        is_same<P, typename remove_pointer<P>::type>
-      , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
-      , typename remove_pointer<P>::type&
-    >
-{
-};
-
-template <class T>
-struct pointer_iterator_traits
-{
-    typedef T pointer;
-    typedef std::random_access_iterator_tag iterator_category;
-    typedef std::ptrdiff_t difference_type;
-
-    typedef typename pointer_value_type<T>::type value_type;
-    typedef typename pointer_reference<T>::type reference;
-};
-
-#   endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-// We'll sort iterator types into one of these classifications, from which we
-// can determine the difference_type, pointer, reference, and value_type
-template <class Iterator>
-struct standard_iterator_traits
-{
-    typedef typename Iterator::difference_type difference_type;
-    typedef typename Iterator::value_type value_type;
-    typedef typename Iterator::pointer pointer;
-    typedef typename Iterator::reference reference;
-    typedef typename Iterator::iterator_category iterator_category;
-};
-
-template <class Iterator>
-struct msvc_stdlib_mutable_traits
-    : std::iterator_traits<Iterator>
-{
-    typedef typename std::iterator_traits<Iterator>::distance_type difference_type;
-    typedef typename std::iterator_traits<Iterator>::value_type* pointer;
-    typedef typename std::iterator_traits<Iterator>::value_type& reference;
-};
-
-template <class Iterator>
-struct msvc_stdlib_const_traits
-    : std::iterator_traits<Iterator>
-{
-    typedef typename std::iterator_traits<Iterator>::distance_type difference_type;
-    typedef const typename std::iterator_traits<Iterator>::value_type* pointer;
-    typedef const typename std::iterator_traits<Iterator>::value_type& reference;
-};
-
-#   ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
-template <class Iterator>
-struct is_bad_output_iterator
-    : is_base_and_derived<
-        std::iterator<std::output_iterator_tag,void,void,void,void>
-        , Iterator>
-{
-};
-
-struct bad_output_iterator_traits
-{
-    typedef void value_type;
-    typedef void difference_type;
-    typedef std::output_iterator_tag iterator_category;
-    typedef void pointer;
-    typedef void reference;
-};
-#   endif
-
-// If we're looking at an MSVC6 (old Dinkumware) ``standard''
-// iterator, this will generate an appropriate traits class. 
-template <class Iterator>
-struct msvc_stdlib_iterator_traits
-    : mpl::if_<
-       is_mutable_iterator<Iterator>
-       , msvc_stdlib_mutable_traits<Iterator>
-       , msvc_stdlib_const_traits<Iterator>
-      >::type
-{};
-
-template <class Iterator>
-struct non_pointer_iterator_traits
-    : mpl::if_<
-        // if the iterator contains all the right nested types...
-        is_full_iterator_traits<Iterator>
-        // Use a standard iterator_traits implementation
-        , standard_iterator_traits<Iterator>
-#   ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-        // Check for STLPort 4.0 broken _Iterator_category type
-        , mpl::if_<
-             is_stlport_40_debug_iterator<Iterator>
-             , stlport_40_debug_iterator_traits<Iterator>
-#   endif
-        // Otherwise, assume it's a Dinkum iterator
-        , msvc_stdlib_iterator_traits<Iterator>
-#   ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-        >::type
-#   endif 
-    >::type
-{
-};
-
-template <class Iterator>
-struct iterator_traits_aux
-    : mpl::if_<
-        is_pointer<Iterator>
-        , pointer_iterator_traits<Iterator>
-        , non_pointer_iterator_traits<Iterator>
-    >::type
-{
-};
-
-template <class Iterator>
-struct iterator_traits
-{
-    // Explicit forwarding from base class needed to keep MSVC6 happy
-    // under some circumstances.
- private:
-#   ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
-    typedef 
-    typename mpl::if_<
-        is_bad_output_iterator<Iterator>
-        , bad_output_iterator_traits
-        , iterator_traits_aux<Iterator>
-    >::type base;
-#   else
-    typedef iterator_traits_aux<Iterator> base;
-#   endif
- public:
-    typedef typename base::value_type value_type;
-    typedef typename base::pointer pointer;
-    typedef typename base::reference reference;
-    typedef typename base::difference_type difference_type;
-    typedef typename base::iterator_category iterator_category;
-};
-
-// This specialization cuts off ETI (Early Template Instantiation) for MSVC.
-template <> struct iterator_traits<int>
-{
-    typedef int value_type;
-    typedef int pointer;
-    typedef int reference;
-    typedef int difference_type;
-    typedef int iterator_category;
-};
-
-}} // namespace boost::detail
-
-#  endif // workarounds
-
-namespace boost { namespace detail {
-
-namespace iterator_traits_
-{
-  template <class Iterator, class Difference>
-  struct distance_select
-  {
-      static Difference execute(Iterator i1, const Iterator i2, ...)
-      {
-          Difference result = 0;
-          while (i1 != i2)
-          {
-              ++i1;
-              ++result;
-          }
-          return result;
-      }
-
-      static Difference execute(Iterator i1, const Iterator i2, std::random_access_iterator_tag*)
-      {
-          return i2 - i1;
-      }
-  };
-} // namespace boost::detail::iterator_traits_
-
-template <class Iterator>
-inline typename iterator_traits<Iterator>::difference_type
-distance(Iterator first, Iterator last)
-{
-    typedef typename iterator_traits<Iterator>::difference_type diff_t;
-    typedef typename ::boost::detail::iterator_traits<Iterator>::iterator_category iterator_category;
-    
-    return iterator_traits_::distance_select<Iterator,diff_t>::execute(
-        first, last, (iterator_category*)0);
-}
-
-}}
-
-# endif
-
-
-# undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-# undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
-
-#endif // ITERATOR_DWA122600_HPP_

include/boost/detail/lightweight_test.hpp

@@ -1,75 +0,0 @@
-#ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
-#define BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  boost/detail/lightweight_test.hpp - lightweight test library
-//
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//
-// Distributed under 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)
-//
-//  BOOST_TEST(expression)
-//  BOOST_ERROR(message)
-//
-//  int boost::report_errors()
-//
-
-#include <boost/current_function.hpp>
-#include <iostream>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline int & test_errors()
-{
-    static int x = 0;
-    return x;
-}
-
-inline void test_failed_impl(char const * expr, char const * file, int line, char const * function)
-{
-    std::cerr << file << "(" << line << "): test '" << expr << "' failed in function '" << function << "'" << std::endl;
-    ++test_errors();
-}
-
-inline void error_impl(char const * msg, char const * file, int line, char const * function)
-{
-    std::cerr << file << "(" << line << "): " << msg << " in function '" << function << "'" << std::endl;
-    ++test_errors();
-}
-
-} // namespace detail
-
-inline int report_errors()
-{
-    int errors = detail::test_errors();
-
-    if(errors == 0)
-    {
-        std::cerr << "No errors detected." << std::endl;
-        return 0;
-    }
-    else
-    {
-        std::cerr << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
-        return 1;
-    }
-}
-
-} // namespace boost
-
-#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
-#define BOOST_ERROR(msg) ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)
-
-#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED

include/boost/detail/named_template_params.hpp

@@ -1,177 +0,0 @@
-// (C) Copyright Jeremy Siek 2001.
-// Distributed under 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)
-
-// Revision History:
-
-// 04 Oct 2001   David Abrahams
-//      Changed name of "bind" to "select" to avoid problems with MSVC.
-
-#ifndef BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP
-#define BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP
-
-#include <boost/type_traits/conversion_traits.hpp>
-#include <boost/type_traits/composite_traits.hpp> // for is_reference
-#if defined(__BORLANDC__)
-#include <boost/type_traits/ice.hpp>
-#endif
-
-namespace boost {
-  namespace detail {
-    
-    struct default_argument { };
-
-    struct dummy_default_gen {
-      template <class Base, class Traits>
-      struct select {
-        typedef default_argument type;
-      };
-    };
-
-   // This class template is a workaround for MSVC.
-   template <class Gen> struct default_generator {
-     typedef detail::dummy_default_gen type;
-   };
-
-    template <class T> struct is_default { 
-      enum { value = false };  
-      typedef type_traits::no_type type;
-    };
-    template <> struct is_default<default_argument> { 
-      enum { value = true }; 
-      typedef type_traits::yes_type type;
-    };
-
-    struct choose_default {
-      template <class Arg, class DefaultGen, class Base, class Traits>
-      struct select {
-        typedef typename default_generator<DefaultGen>::type Gen;
-        typedef typename Gen::template select<Base,Traits>::type type;
-      };
-    };
-    struct choose_arg {
-      template <class Arg, class DefaultGen, class Base, class Traits>
-      struct select {
-        typedef Arg type;
-      };
-    };
-
-#if defined(__BORLANDC__)
-    template <class UseDefault>
-    struct choose_arg_or_default { typedef choose_arg type; };
-    template <>
-    struct choose_arg_or_default<type_traits::yes_type> {
-      typedef choose_default type;
-    };
-#else
-    template <bool UseDefault>
-    struct choose_arg_or_default { typedef choose_arg type; };
-    template <>
-    struct choose_arg_or_default<true> {
-      typedef choose_default type;
-    };
-#endif
-    
-    template <class Arg, class DefaultGen, class Base, class Traits>
-    class resolve_default {
-#if defined(__BORLANDC__)
-      typedef typename choose_arg_or_default<typename is_default<Arg>::type>::type Selector;
-#else
-      // This usually works for Borland, but I'm seeing weird errors in
-      // iterator_adaptor_test.cpp when using this method.
-      enum { is_def = is_default<Arg>::value };
-      typedef typename choose_arg_or_default<is_def>::type Selector;
-#endif
-    public:
-      typedef typename Selector
-        ::template select<Arg, DefaultGen, Base, Traits>::type type;
-    };
-
-    // To differentiate an unnamed parameter from a traits generator
-    // we use is_convertible<X, iter_traits_gen_base>.
-    struct named_template_param_base { };
-
-    template <class X>
-    struct is_named_param_list {
-      enum { value  = is_convertible<X, named_template_param_base>::value };
-    };
-    
-    struct choose_named_params {
-      template <class Prev> struct select { typedef Prev type; };
-    };
-    struct choose_default_arg {
-      template <class Prev> struct select { 
-        typedef detail::default_argument type;
-      };
-    };
-
-    template <bool Named> struct choose_default_dispatch_;
-    template <> struct choose_default_dispatch_<true> {
-      typedef choose_named_params type;
-    };
-    template <> struct choose_default_dispatch_<false> {
-      typedef choose_default_arg type;
-    };
-    // The use of inheritance here is a Solaris Forte 6 workaround.
-    template <bool Named> struct choose_default_dispatch
-      : public choose_default_dispatch_<Named> { };
-
-    template <class PreviousArg>
-    struct choose_default_argument {
-      enum { is_named = is_named_param_list<PreviousArg>::value };
-      typedef typename choose_default_dispatch<is_named>::type Selector;
-      typedef typename Selector::template select<PreviousArg>::type type;
-    };
-
-    // This macro assumes that there is a class named default_##TYPE
-    // defined before the application of the macro.  This class should
-    // have a single member class template named "select" with two
-    // template parameters: the type of the class being created (e.g.,
-    // the iterator_adaptor type when creating iterator adaptors) and
-    // a traits class. The select class should have a single typedef
-    // named "type" that produces the default for TYPE.  See
-    // boost/iterator_adaptors.hpp for an example usage.  Also,
-    // applications of this macro must be placed in namespace
-    // boost::detail.
-
-#define BOOST_NAMED_TEMPLATE_PARAM(TYPE) \
-    struct get_##TYPE##_from_named { \
-      template <class Base, class NamedParams, class Traits> \
-      struct select { \
-          typedef typename NamedParams::traits NamedTraits; \
-          typedef typename NamedTraits::TYPE TYPE; \
-          typedef typename resolve_default<TYPE, \
-            default_##TYPE, Base, NamedTraits>::type type; \
-      }; \
-    }; \
-    struct pass_thru_##TYPE { \
-      template <class Base, class Arg, class Traits> struct select { \
-          typedef typename resolve_default<Arg, \
-            default_##TYPE, Base, Traits>::type type; \
-      };\
-    }; \
-    template <int NamedParam> \
-    struct get_##TYPE##_dispatch { }; \
-    template <> struct get_##TYPE##_dispatch<1> { \
-      typedef get_##TYPE##_from_named type; \
-    }; \
-    template <> struct get_##TYPE##_dispatch<0> { \
-      typedef pass_thru_##TYPE type; \
-    }; \
-    template <class Base, class X, class Traits>  \
-    class get_##TYPE { \
-      enum { is_named = is_named_param_list<X>::value }; \
-      typedef typename get_##TYPE##_dispatch<is_named>::type Selector; \
-    public: \
-      typedef typename Selector::template select<Base, X, Traits>::type type; \
-    }; \
-    template <> struct default_generator<default_##TYPE> { \
-      typedef default_##TYPE type; \
-    }
-
-    
-  } // namespace detail
-} // namespace boost
-
-#endif // BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP

include/boost/detail/no_exceptions_support.hpp

@@ -1,87 +0,0 @@
-#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
-#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
-
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
-#  pragma once
-#endif
-
-//----------------------------------------------------------------------
-// (C) Copyright 2004 Pavel Vozenilek.
-// Use, modification and distribution is 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)
-//
-//
-// This file contains helper macros used when exception support may be
-// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
-//
-// Before picking up these macros you may consider using RAII techniques
-// to deal with exceptions - their syntax can be always the same with 
-// or without exception support enabled.
-//
-
-/* Example of use:
-
-void foo() {
-  BOOST_TRY {
-    ...
-  } BOOST_CATCH(const std::bad_alloc&) {
-      ...
-      BOOST_RETHROW
-  } BOOST_CATCH(const std::exception& e) {
-      ...
-  }
-  BOOST_CATCH_END
-}
-
-With exception support enabled it will expand into:
-
-void foo() {
-  { try {
-    ...
-  } catch (const std::bad_alloc&) {
-      ...
-      throw;
-  } catch (const std::exception& e) {
-      ...
-  }
-  }
-}
-
-With exception support disabled it will expand into:
-
-void foo() {
-  { if(true) {
-    ...
-  } else if (false) {
-      ...
-  } else if (false)  {
-      ...
-  }
-  }
-}
-*/
-//----------------------------------------------------------------------
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#if !(defined BOOST_NO_EXCEPTIONS)
-#    define BOOST_TRY { try
-#    define BOOST_CATCH(x) catch(x)
-#    define BOOST_RETHROW throw;
-#    define BOOST_CATCH_END }
-#else
-#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#        define BOOST_TRY { if ("")
-#        define BOOST_CATCH(x) else if (!"")
-#    else
-#        define BOOST_TRY { if (true)
-#        define BOOST_CATCH(x) else if (false)
-#    endif
-#    define BOOST_RETHROW
-#    define BOOST_CATCH_END }
-#endif
-
-
-#endif 

include/boost/detail/numeric_traits.hpp

@@ -1,191 +0,0 @@
-// (C) Copyright David Abrahams 2001, Howard Hinnant 2001.
-//
-// Distributed under 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)
-//
-// Template class numeric_traits<Number> --
-//
-//    Supplies:
-//
-//      typedef difference_type -- a type used to represent the difference
-//      between any two values of Number.
-//
-//    Support:
-//      1. Not all specializations are supplied
-//
-//      2. Use of specializations that are not supplied will cause a
-//      compile-time error
-//
-//      3. Users are free to specialize numeric_traits for any type.
-//
-//      4. Right now, specializations are only supplied for integer types.
-//
-//      5. On implementations which do not supply compile-time constants in
-//      std::numeric_limits<>, only specializations for built-in integer types
-//      are supplied.
-//
-//      6. Handling of numbers whose range of representation is at least as
-//      great as boost::intmax_t can cause some differences to be
-//      unrepresentable in difference_type:
-//
-//        Number    difference_type
-//        ------    ---------------
-//        signed    Number
-//        unsigned  intmax_t
-//
-// template <class Number> typename numeric_traits<Number>::difference_type
-// numeric_distance(Number x, Number y)
-//    computes (y - x), attempting to avoid overflows.
-//
-
-// See http://www.boost.org for most recent version including documentation.
-
-// Revision History
-// 11 Feb 2001 - Use BOOST_STATIC_CONSTANT (David Abrahams)
-// 11 Feb 2001 - Rolled back ineffective Borland-specific code
-//               (David Abrahams)
-// 10 Feb 2001 - Rolled in supposed Borland fixes from John Maddock, but
-//               not seeing any improvement yet (David Abrahams)
-// 06 Feb 2001 - Factored if_true out into boost/detail/select_type.hpp
-//               (David Abrahams)
-// 23 Jan 2001 - Fixed logic of difference_type selection, which was
-//               completely wack. In the process, added digit_traits<>
-//               to compute the number of digits in intmax_t even when
-//               not supplied by numeric_limits<>. (David Abrahams)
-// 21 Jan 2001 - Created (David Abrahams)
-
-#ifndef BOOST_NUMERIC_TRAITS_HPP_DWA20001901
-# define BOOST_NUMERIC_TRAITS_HPP_DWA20001901
-
-# include <boost/config.hpp>
-# include <boost/cstdint.hpp>
-# include <boost/static_assert.hpp>
-# include <boost/type_traits.hpp>
-# include <boost/detail/select_type.hpp>
-# include <boost/limits.hpp>
-
-namespace boost { namespace detail {
-
-  // Template class is_signed -- determine whether a numeric type is signed
-  // Requires that T is constructable from the literals -1 and 0.  Compile-time
-  // error results if that requirement is not met (and thus signedness is not
-  // likely to have meaning for that type).
-  template <class Number>
-  struct is_signed
-  {
-#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-    BOOST_STATIC_CONSTANT(bool, value = (Number(-1) < Number(0)));
-#else
-    BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<Number>::is_signed);
-#endif
-  };
-
-# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-  // digit_traits - compute the number of digits in a built-in integer
-  // type. Needed for implementations on which numeric_limits is not specialized
-  // for intmax_t (e.g. VC6).
-  template <bool is_specialized> struct digit_traits_select;
-
-  // numeric_limits is specialized; just select that version of digits
-  template <> struct digit_traits_select<true>
-  {
-      template <class T> struct traits
-      {
-          BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits);
-      };
-  };
-
-  // numeric_limits is not specialized; compute digits from sizeof(T)
-  template <> struct digit_traits_select<false>
-  {
-      template <class T> struct traits
-      {
-          BOOST_STATIC_CONSTANT(int, digits = (
-              sizeof(T) * std::numeric_limits<unsigned char>::digits
-              - (is_signed<T>::value ? 1 : 0))
-              );
-      };
-  };
-
-  // here's the "usable" template
-  template <class T> struct digit_traits
-  {
-      typedef digit_traits_select<
-                ::std::numeric_limits<T>::is_specialized> selector;
-      typedef typename selector::template traits<T> traits;
-      BOOST_STATIC_CONSTANT(int, digits = traits::digits);
-  };
-#endif
-
-  // Template class integer_traits<Integer> -- traits of various integer types
-  // This should probably be rolled into boost::integer_traits one day, but I
-  // need it to work without <limits>
-  template <class Integer>
-  struct integer_traits
-  {
-# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-   private:
-      typedef Integer integer_type;
-      typedef std::numeric_limits<integer_type> x;
-#   if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-      // for some reason, MSVC asserts when it shouldn't unless we make these
-      // local definitions
-      BOOST_STATIC_CONSTANT(bool, is_integer = x::is_integer);
-      BOOST_STATIC_CONSTANT(bool, is_specialized = x::is_specialized);
-      
-      BOOST_STATIC_ASSERT(is_integer);
-      BOOST_STATIC_ASSERT(is_specialized);
-#   endif
-   public:
-      typedef typename
-      if_true<(int(x::is_signed)
-              && (!int(x::is_bounded)
-                 // digits is the number of no-sign bits
-                  || (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits)))>::template then<
-        Integer,
-          
-      typename if_true<(int(x::digits) + 1 < digit_traits<signed int>::digits)>::template then<
-        signed int,
-
-      typename if_true<(int(x::digits) + 1 < digit_traits<signed long>::digits)>::template then<
-        signed long,
-
-   // else
-        intmax_t
-      >::type>::type>::type difference_type;
-#else
-      BOOST_STATIC_ASSERT(boost::is_integral<Integer>::value);
-
-      typedef typename
-      if_true<(sizeof(Integer) >= sizeof(intmax_t))>::template then<
-               
-        typename if_true<(is_signed<Integer>::value)>::template then<
-          Integer,
-          intmax_t
-        >::type,
-
-        typename if_true<(sizeof(Integer) < sizeof(std::ptrdiff_t))>::template then<
-          std::ptrdiff_t,
-          intmax_t
-        >::type
-      >::type difference_type;
-# endif
-  };
-
-  // Right now, only supports integers, but should be expanded.
-  template <class Number>
-  struct numeric_traits
-  {
-      typedef typename integer_traits<Number>::difference_type difference_type;
-  };
-
-  template <class Number>
-  typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y)
-  {
-      typedef typename numeric_traits<Number>::difference_type difference_type;
-      return difference_type(y) - difference_type(x);
-  }
-}}
-
-#endif // BOOST_NUMERIC_TRAITS_HPP_DWA20001901

include/boost/detail/quick_allocator.hpp

@@ -1,198 +0,0 @@
-#ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
-#define BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/quick_allocator.hpp
-//
-//  Copyright (c) 2003 David Abrahams
-//  Copyright (c) 2003 Peter Dimov
-//
-// Distributed under 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)
-//
-
-#include <boost/config.hpp>
-
-#include <boost/detail/lightweight_mutex.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-
-#include <new>              // ::operator new, ::operator delete
-#include <cstddef>          // std::size_t
-
-namespace boost
-{
-
-namespace detail
-{
-
-template<unsigned size, unsigned align_> union freeblock
-{
-    typedef typename boost::type_with_alignment<align_>::type aligner_type;
-    aligner_type aligner;
-    char bytes[size];
-    freeblock * next;
-};
-
-template<unsigned size, unsigned align_> struct allocator_impl
-{
-    typedef freeblock<size, align_> block;
-
-    // It may seem odd to use such small pages.
-    //
-    // However, on a typical Windows implementation that uses
-    // the OS allocator, "normal size" pages interact with the
-    // "ordinary" operator new, slowing it down dramatically.
-    //
-    // 512 byte pages are handled by the small object allocator,
-    // and don't interfere with ::new.
-    //
-    // The other alternative is to use much bigger pages (1M.)
-    //
-    // It is surprisingly easy to hit pathological behavior by
-    // varying the page size. g++ 2.96 on Red Hat Linux 7.2,
-    // for example, passionately dislikes 496. 512 seems OK.
-
-#if defined(BOOST_QA_PAGE_SIZE)
-
-    enum { items_per_page = BOOST_QA_PAGE_SIZE / size };
-
-#else
-
-    enum { items_per_page = 512 / size }; // 1048560 / size
-
-#endif
-
-#ifdef BOOST_HAS_THREADS
-
-    static lightweight_mutex & mutex()
-    {
-        static lightweight_mutex m;
-        return m;
-    }
-
-    static lightweight_mutex * mutex_init;
-
-#endif
-
-    static block * free;
-    static block * page;
-    static unsigned last;
-
-    static inline void * alloc()
-    {
-#ifdef BOOST_HAS_THREADS
-        lightweight_mutex::scoped_lock lock( mutex() );
-#endif
-        if(block * x = free)
-        {
-            free = x->next;
-            return x;
-        }
-        else
-        {
-            if(last == items_per_page)
-            {
-                // "Listen to me carefully: there is no memory leak"
-                // -- Scott Meyers, Eff C++ 2nd Ed Item 10
-                page = ::new block[items_per_page];
-                last = 0;
-            }
-
-            return &page[last++];
-        }
-    }
-
-    static inline void * alloc(std::size_t n)
-    {
-        if(n != size) // class-specific new called for a derived object
-        {
-            return ::operator new(n);
-        }
-        else
-        {
-#ifdef BOOST_HAS_THREADS
-            lightweight_mutex::scoped_lock lock( mutex() );
-#endif
-            if(block * x = free)
-            {
-                free = x->next;
-                return x;
-            }
-            else
-            {
-                if(last == items_per_page)
-                {
-                    page = ::new block[items_per_page];
-                    last = 0;
-                }
-
-                return &page[last++];
-            }
-        }
-    }
-
-    static inline void dealloc(void * pv)
-    {
-        if(pv != 0) // 18.4.1.1/13
-        {
-#ifdef BOOST_HAS_THREADS
-            lightweight_mutex::scoped_lock lock( mutex() );
-#endif
-            block * pb = static_cast<block *>(pv);
-            pb->next = free;
-            free = pb;
-        }
-    }
-
-    static inline void dealloc(void * pv, std::size_t n)
-    {
-        if(n != size) // class-specific delete called for a derived object
-        {
-            ::operator delete(pv);
-        }
-        else if(pv != 0) // 18.4.1.1/13
-        {
-#ifdef BOOST_HAS_THREADS
-            lightweight_mutex::scoped_lock lock( mutex() );
-#endif
-            block * pb = static_cast<block *>(pv);
-            pb->next = free;
-            free = pb;
-        }
-    }
-};
-
-#ifdef BOOST_HAS_THREADS
-
-template<unsigned size, unsigned align_>
-  lightweight_mutex * allocator_impl<size, align_>::mutex_init = &allocator_impl<size, align_>::mutex();
-
-#endif
-
-template<unsigned size, unsigned align_>
-  freeblock<size, align_> * allocator_impl<size, align_>::free = 0;
-
-template<unsigned size, unsigned align_>
-  freeblock<size, align_> * allocator_impl<size, align_>::page = 0;
-
-template<unsigned size, unsigned align_>
-  unsigned allocator_impl<size, align_>::last = allocator_impl<size, align_>::items_per_page;
-
-template<class T>
-struct quick_allocator: public allocator_impl< sizeof(T), boost::alignment_of<T>::value >
-{
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED

include/boost/detail/reference_content.hpp

@@ -1,141 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost detail/reference_content.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2003
-// Eric Friedman
-//
-// Distributed under 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)
-
-#ifndef BOOST_DETAIL_REFERENCE_CONTENT_HPP
-#define BOOST_DETAIL_REFERENCE_CONTENT_HPP
-
-#include "boost/config.hpp"
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-#   include "boost/mpl/bool.hpp"
-#   include "boost/type_traits/has_nothrow_copy.hpp"
-#else
-#   include "boost/mpl/if.hpp"
-#   include "boost/type_traits/is_reference.hpp"
-#endif
-
-#include "boost/mpl/void.hpp"
-
-namespace boost {
-
-namespace detail {
-
-///////////////////////////////////////////////////////////////////////////////
-// (detail) class template reference_content
-//
-// Non-Assignable wrapper for references.
-//
-template <typename RefT>
-class reference_content
-{
-private: // representation
-
-    RefT content_;
-
-public: // structors
-
-    ~reference_content()
-    {
-    }
-
-    reference_content(RefT r)
-        : content_( r )
-    {
-    }
-
-    reference_content(const reference_content& operand)
-        : content_( operand.content_ )
-    {
-    }
-
-private: // non-Assignable
-
-    reference_content& operator=(const reference_content&);
-
-public: // queries
-
-    RefT get() const
-    {
-        return content_;
-    }
-
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// (detail) metafunction make_reference_content
-//
-// Wraps with reference_content if specified type is reference.
-//
-
-template <typename T = mpl::void_> struct make_reference_content;
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-template <typename T>
-struct make_reference_content
-{
-    typedef T type;
-};
-
-template <typename T>
-struct make_reference_content< T& >
-{
-    typedef reference_content<T&> type;
-};
-
-#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-template <typename T>
-struct make_reference_content
-    : mpl::if_<
-          is_reference<T>
-        , reference_content<T>
-        , T
-        >
-{
-};
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
-
-template <>
-struct make_reference_content< mpl::void_ >
-{
-    template <typename T>
-    struct apply
-        : make_reference_content<T>
-    {
-    };
-
-    typedef mpl::void_ type;
-};
-
-} // namespace detail
-
-///////////////////////////////////////////////////////////////////////////////
-// reference_content<T&> type traits specializations
-//
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-template <typename T>
-struct has_nothrow_copy<
-      ::boost::detail::reference_content< T& >
-    >
-    : mpl::true_
-{
-};
-
-#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-} // namespace boost
-
-#endif // BOOST_DETAIL_REFERENCE_CONTENT_HPP

include/boost/detail/select_type.hpp

@@ -1,36 +0,0 @@
-// (C) Copyright David Abrahams 2001.
-// Distributed under 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 for most recent version including documentation.
-
-// Revision History
-// 09 Feb 01  Applied John Maddock's Borland patch Moving <true>
-//            specialization to unspecialized template (David Abrahams)
-// 06 Feb 01  Created (David Abrahams)
-
-#ifndef SELECT_TYPE_DWA20010206_HPP
-# define SELECT_TYPE_DWA20010206_HPP
-
-namespace boost { namespace detail {
-
-  // Template class if_true -- select among 2 types based on a bool constant expression
-  // Usage:
-  //   typename if_true<(bool_const_expression)>::template then<true_type, false_type>::type
-
-  // HP aCC cannot deal with missing names for template value parameters
-  template <bool b> struct if_true
-  {
-      template <class T, class F>
-      struct then { typedef T type; };
-  };
-
-  template <>
-  struct if_true<false>
-  {
-      template <class T, class F>
-      struct then { typedef F type; };
-  };
-}}
-#endif // SELECT_TYPE_DWA20010206_HPP

include/boost/detail/templated_streams.hpp

@@ -1,74 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost detail/templated_streams.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2003
-// Eric Friedman
-//
-// Distributed under 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)
-
-#ifndef BOOST_DETAIL_TEMPLATED_STREAMS_HPP
-#define BOOST_DETAIL_TEMPLATED_STREAMS_HPP
-
-#include "boost/config.hpp"
-
-///////////////////////////////////////////////////////////////////////////////
-// (detail) BOOST_TEMPLATED_STREAM_* macros
-//
-// Provides workaround platforms without stream class templates.
-//
-
-#if !defined(BOOST_NO_STD_LOCALE)
-
-#define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) \
-    template < typename E , typename T >
-
-#define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) \
-    template < typename E , typename T , typename A >
-
-#define BOOST_TEMPLATED_STREAM_ARGS(E,T) \
-    typename E , typename T 
-
-#define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) \
-    typename E , typename T , typename A 
-
-#define BOOST_TEMPLATED_STREAM_COMMA        ,
-
-#define BOOST_TEMPLATED_STREAM_ELEM(E)      E
-#define BOOST_TEMPLATED_STREAM_TRAITS(T)    T
-#define BOOST_TEMPLATED_STREAM_ALLOC(A)     A
-
-#define BOOST_TEMPLATED_STREAM(X,E,T) \
-    BOOST_JOIN(std::basic_,X)< E , T >
-
-#define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \
-    BOOST_JOIN(std::basic_,X)< E , T , A >
-
-#else // defined(BOOST_NO_STD_LOCALE)
-
-#define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) /**/
-
-#define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) /**/
-
-#define BOOST_TEMPLATED_STREAM_ARGS(E,T) /**/
-
-#define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) /**/
-
-#define BOOST_TEMPLATED_STREAM_COMMA        /**/
-
-#define BOOST_TEMPLATED_STREAM_ELEM(E)      char
-#define BOOST_TEMPLATED_STREAM_TRAITS(T)    std::char_traits<char>
-#define BOOST_TEMPLATED_STREAM_ALLOC(A)     std::allocator<char>
-
-#define BOOST_TEMPLATED_STREAM(X,E,T) \
-    std::X
-
-#define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \
-    std::X
-
-#endif // BOOST_NO_STD_LOCALE
-
-#endif // BOOST_DETAIL_TEMPLATED_STREAMS_HPP

include/boost/detail/utf8_codecvt_facet.hpp

@@ -1,197 +0,0 @@
-// Copyright <20> 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
-// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
-// Distributed under the Boost Software License, Version 1.0. (See accompany-
-// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_UTF8_CODECVT_FACET_HPP
-#define BOOST_UTF8_CODECVT_FACET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// utf8_codecvt_facet.hpp
-
-// This header defines class utf8_codecvt_facet, derived fro 
-// std::codecvt<wchar_t, char>, which can be used to convert utf8 data in
-// files into wchar_t strings in the application.
-//
-// The header is NOT STANDALONE, and is not to be included by the USER.
-// There are at least two libraries which want to use this functionality, and
-// we want to avoid code duplication. It would be possible to create utf8
-// library, but:
-// - this requires review process first
-// - in the case, when linking the a library which uses utf8 
-//   (say 'program_options'), user should also link to the utf8 library.
-//   This seems inconvenient, and asking a user to link to an unrevieved 
-//   library is strange. 
-// Until the above points are fixed, a library which wants to use utf8 must:
-// - include this header from one of it's headers or sources
-// - include the corresponding .cpp file from one of the sources
-// - before including either file, the library must define
-//   - BOOST_UTF8_BEGIN_NAMESPACE to the namespace declaration that must be used
-//   - BOOST_UTF8_END_NAMESPACE to the code to close the previous namespace
-//   - declaration.
-//   - BOOST_UTF8_DECL -- to the code which must be used for all 'exportable'
-//     symbols.
-//
-// For example, program_options library might contain:
-//    #define BOOST_UTF8_BEGIN_NAMESPACE <backslash character> 
-//             namespace boost { namespace program_options {
-//    #define BOOST_UTF8_END_NAMESPACE }}
-//    #define BOOST_UTF8_DECL BOOST_PROGRAM_OPTIONS_DECL
-//    #include "../../detail/utf8/utf8_codecvt.cpp"
-//
-// Essentially, each library will have its own copy of utf8 code, in
-// different namespaces. 
-
-// Note:(Robert Ramey).  I have made the following alterations in the original
-// code.
-// a) Rendered utf8_codecvt<wchar_t, char>  with using templates
-// b) Move longer functions outside class definition to prevent inlining
-// and make code smaller
-// c) added on a derived class to permit translation to/from current
-// locale to utf8
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-// archives stored as text - note these ar templated on the basic
-// stream templates to accommodate wide (and other?) kind of characters
-//
-// note the fact that on libraries without wide characters, ostream is
-// is not a specialization of basic_ostream which in fact is not defined
-// in such cases.   So we can't use basic_ostream<OStream::char_type> but rather
-// use two template parameters
-//
-// utf8_codecvt_facet
-//   This is an implementation of a std::codecvt facet for translating 
-//   from UTF-8 externally to UCS-4.  Note that this is not tied to
-//   any specific types in order to allow customization on platforms
-//   where wchar_t is not big enough.
-//
-// NOTES:  The current implementation jumps through some unpleasant hoops in
-// order to deal with signed character types.  As a std::codecvt_base::result,
-// it is necessary  for the ExternType to be convertible to unsigned  char.
-// I chose not to tie the extern_type explicitly to char. But if any combination
-// of types other than <wchar_t,char_t> is used, then std::codecvt must be
-// specialized on those types for this to work.
-
-#include <locale>
-// for mbstate_t
-#include <wchar.h>
-// for std::size_t
-#include <cstddef>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-namespace std {
-    #if defined(__LIBCOMO__)
-        using ::mbstate_t;
-    #elif defined(BOOST_DINKUMWARE_STDLIB) && !defined(__BORLANDC__)
-        using ::mbstate_t;
-    #elif defined(__SGI_STL_PORT)
-    #elif defined(BOOST_NO_STDC_NAMESPACE)
-        using ::mbstate_t;
-        using ::codecvt;
-    #endif
-} // namespace std
-
-#if !defined(__MSL_CPP__) && !defined(__LIBCOMO__)
-    #define BOOST_CODECVT_DO_LENGTH_CONST const
-#else
-    #define BOOST_CODECVT_DO_LENGTH_CONST
-#endif
-
-// maximum lenght of a multibyte string
-#define MB_LENGTH_MAX 8
-
-BOOST_UTF8_BEGIN_NAMESPACE
-
-struct BOOST_UTF8_DECL utf8_codecvt_facet :
-    public std::codecvt<wchar_t, char, std::mbstate_t>  
-{
-public:
-    explicit utf8_codecvt_facet(std::size_t no_locale_manage=0)
-        : std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage) 
-    {}
-protected:
-    virtual std::codecvt_base::result do_in(
-        std::mbstate_t& state, 
-        const char * from,
-        const char * from_end, 
-        const char * & from_next,
-        wchar_t * to, 
-        wchar_t * to_end, 
-        wchar_t*& to_next
-    ) const;
-
-    virtual std::codecvt_base::result do_out(
-        std::mbstate_t & state, const wchar_t * from,
-        const wchar_t * from_end, const wchar_t*  & from_next,
-        char * to, char * to_end, char * & to_next
-    ) const;
-
-    bool invalid_continuing_octet(unsigned char octet_1) const {
-        return (octet_1 < 0x80|| 0xbf< octet_1);
-    }
-
-    bool invalid_leading_octet(unsigned char octet_1)   const {
-        return (0x7f < octet_1 && octet_1 < 0xc0) ||
-            (octet_1 > 0xfd);
-    }
-
-    // continuing octets = octets except for the leading octet
-    static unsigned int get_cont_octet_count(unsigned   char lead_octet) {
-        return get_octet_count(lead_octet) - 1;
-    }
-
-    static unsigned int get_octet_count(unsigned char   lead_octet);
-
-    // How many "continuing octets" will be needed for this word
-    // ==   total octets - 1.
-    int get_cont_octet_out_count(wchar_t word) const ;
-
-    virtual bool do_always_noconv() const throw() { return false; }
-
-    // UTF-8 isn't really stateful since we rewind on partial conversions
-    virtual std::codecvt_base::result do_unshift(
-        std::mbstate_t&,
-        char * from,
-        char * /*to*/,
-        char * & next
-    ) const 
-    {
-        next = from;
-        return ok;
-    }
-
-    virtual int do_encoding() const throw() {
-        const int variable_byte_external_encoding=0;
-        return variable_byte_external_encoding;
-    }
-
-    // How many char objects can I process to get <= max_limit
-    // wchar_t objects?
-    virtual int do_length(
-        BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &,
-        const char * from,
-        const char * from_end, 
-        std::size_t max_limit
-#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-        ) const throw();
-#else
-        ) const;
-#endif
-
-    // Largest possible value do_length(state,from,from_end,1) could return.
-    virtual int do_max_length() const throw () {
-        return 6; // largest UTF-8 encoding of a UCS-4 character
-    }
-};
-
-BOOST_UTF8_END_NAMESPACE
-
-#endif // BOOST_UTF8_CODECVT_FACET_HPP

include/boost/indirect_reference.hpp

@@ -1,43 +0,0 @@
-#ifndef INDIRECT_REFERENCE_DWA200415_HPP
-# define INDIRECT_REFERENCE_DWA200415_HPP
-
-//
-// Copyright David Abrahams 2004. Use, modification and distribution is
-// 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)
-//
-// typename indirect_reference<P>::type provides the type of *p.
-//
-// http://www.boost.org/libs/iterator/doc/pointee.html
-//
-
-# include <boost/detail/is_incrementable.hpp>
-# include <boost/iterator/iterator_traits.hpp>
-# include <boost/type_traits/remove_cv.hpp>
-# include <boost/mpl/eval_if.hpp>
-# include <boost/pointee.hpp>
-
-namespace boost { 
-
-namespace detail
-{
-  template <class P>
-  struct smart_ptr_reference
-  {
-      typedef typename boost::pointee<P>::type& type;
-  };
-}
-
-template <class P>
-struct indirect_reference
-  : mpl::eval_if<
-        detail::is_incrementable<P>
-      , iterator_reference<P>
-      , detail::smart_ptr_reference<P>
-    >
-{
-};
-  
-} // namespace boost
-
-#endif // INDIRECT_REFERENCE_DWA200415_HPP

include/boost/non_type.hpp

@@ -1,27 +0,0 @@
-// -------------------------------------
-//
-//           (C) Copyright Gennaro Prota 2003.
-//
-// Distributed under 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)
-//
-// ------------------------------------------------------
-
-#ifndef BOOST_NON_TYPE_HPP_GP_20030417
-#define BOOST_NON_TYPE_HPP_GP_20030417
-
-
-namespace boost {
-
-  // Just a simple "envelope" for non-type template parameters. Useful
-  // to work around some MSVC deficiencies.
-
- template <typename T, T n>
- struct non_type { };
-
-
-}
-
-
-#endif // include guard

include/boost/pending/cstddef.hpp

@@ -1,8 +1,4 @@
 // -*- C++ -*- forwarding header.
-//  (C) Copyright Jeremy Siek 2004 
-//  Distributed under 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)
 
 #ifndef BOOST_CSTDDEF_HPP
 #define BOOST_CSTDDEF_HPP

include/boost/pending/ct_if.hpp

@@ -1,41 +1,99 @@
-// (C) Copyright Jeremy Siek 2000.
-// Distributed under 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)
-
-// This header replaces the implementation of ct_if that preceded the
-// introduction of Boost.MPL with a facade that defers to that reviewed and
-// accepted library.
-
-// Author: Ronald Garcia
-// Date: 20 October, 2006
+// (C) Copyright Jeremy Siek 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.
 
+// The ct_if implementation that avoids partial specialization is
+// based on the IF class by Ulrich W. Eisenecker and Krzysztof
+// Czarnecki.
 
 #ifndef BOOST_CT_IF_HPP
 #define BOOST_CT_IF_HPP
 
+#include <boost/config.hpp>
 
-// A stub implementation in terms of Boost.MPL
-
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/and.hpp>
-// true_type and false_type are used by applications of ct_if
-#include <boost/type_traits/integral_constant.hpp> 
+/*
+  There is a bug in the Borland compiler with regards to using
+  integers to specialize templates. This made it hard to use ct_if in
+  the graph library. Changing from 'ct_if' to 'ct_if_t' fixed the
+  problem.
+*/
 
 namespace boost {
 
+  struct ct_if_error { };
+
+  struct true_type { enum { value = true }; };
+  struct false_type { enum { value = false }; };
+
   template <class A, class B>
-  struct ct_and : boost::mpl::and_<A,B> {};
+  struct ct_and { typedef false_type type; };
+  template <> struct ct_and<true_type,true_type> { typedef true_type type; };
 
-  template <class A>
-  struct ct_not : mpl::not_<A> {};
+  template <class A> struct ct_not { typedef ct_if_error type; };
+  template <> struct ct_not<true_type> { typedef false_type type; };
+  template <> struct ct_not<false_type> { typedef true_type type; };
 
-  template <bool cond, class A, class B>
-  struct ct_if : mpl::if_c<cond,A,B> {};
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+  template <int cond, class A, class B>
+  struct ct_if { typedef ct_if_error type; };
+  template <class A, class B>
+  struct ct_if<1, A, B> { typedef A type; };
+  template <class A, class B>
+  struct ct_if<0, A, B> { typedef B type; };
 
   template <class cond, class A, class B>
-  struct ct_if_t : mpl::if_<cond,A,B> {};
+  struct ct_if_t { typedef ct_if_error type; };
+  template <class A, class B>
+  struct ct_if_t<true_type, A, B> { typedef A type; };
+  template <class A, class B>
+  struct ct_if_t<false_type, A, B> { typedef B type; };
+
+#else
+
+  namespace detail {
+
+    template <int condition, class A, class B> struct IF;
+    template <int condition> struct SlectSelector;
+    struct SelectFirstType;
+    struct SelectSecondType;
+    
+    struct SelectFirstType {
+      template<class A, class B>
+      struct Template {        typedef A type; };
+    };
+    
+    struct SelectSecondType {
+      template<class A, class B>
+      struct Template { typedef B type; };
+    };
+    
+    template<int condition>
+    struct SlectSelector {
+      typedef SelectFirstType type;
+    };
+    
+    template <>
+    struct SlectSelector<0> {
+      typedef SelectSecondType type;
+    };
+
+  } // namespace detail
+    
+  template<int condition, class A, class B>
+  struct ct_if
+  {
+    typedef typename detail::SlectSelector<condition>::type Selector;
+    typedef typename Selector::template Template<A, B>::type type;
+  };
+  
+  template <class cond, class A, class B>
+  struct ct_if_t { 
+    typedef typename ct_if<cond::value, A, B>::type type;
+  };
+
+#endif
 
 } // namespace boost
 

include/boost/pending/integer_log2.hpp

@@ -1,116 +0,0 @@
-// -------------------------------------
-// integer_log2.hpp
-//
-//   Gives the integer part of the logarithm, in base 2, of a
-// given number. Behavior is undefined if the argument is <= 0.
-//
-//
-//       (C) Copyright Gennaro Prota 2003 - 2004.
-//
-// Distributed under 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)
-//
-// ------------------------------------------------------
-//
-// $Id$
-
-
-#ifndef BOOST_INTEGER_LOG2_HPP_GP_20030301
-#define BOOST_INTEGER_LOG2_HPP_GP_20030301
-
-#include <assert.h>
-#ifdef __BORLANDC__
-#include <climits>
-#endif
-#include "boost/limits.hpp"
-#include "boost/config.hpp"
-
-
-namespace boost {
- namespace detail {
-
-  template <typename T>
-  int integer_log2_impl(T x, int n) {
-
-      int result = 0;
-
-      while (x != 1) {
-
-          const T t = x >> n;
-          if (t) {
-              result += n;
-              x = t;
-          }
-          n /= 2;
-
-      }
-
-      return result;
-  }
-
-
-
-  // helper to find the maximum power of two
-  // less than p (more involved than necessary,
-  // to avoid PTS)
-  //
-  template <int p, int n>
-  struct max_pow2_less {
-
-      enum { c = 2*n < p };
-
-      BOOST_STATIC_CONSTANT(int, value =
-          c ? (max_pow2_less< c*p, 2*c*n>::value) : n);
-
-  };
-
-  template <>
-  struct max_pow2_less<0, 0> {
-
-      BOOST_STATIC_CONSTANT(int, value = 0);
-  };
-
-  // this template is here just for Borland :(
-  // we could simply rely on numeric_limits but sometimes
-  // Borland tries to use numeric_limits<const T>, because
-  // of its usual const-related problems in argument deduction
-  // - gps
-  template <typename T>
-  struct width {
-
-#ifdef __BORLANDC__
-      BOOST_STATIC_CONSTANT(int, value = sizeof(T) * CHAR_BIT);
-#else
-      BOOST_STATIC_CONSTANT(int, value = (std::numeric_limits<T>::digits));
-#endif
-
-  };
-
- } // detail
-
-
- // ---------
- // integer_log2
- // ---------------
- //
- template <typename T>
- int integer_log2(T x) {
-
-     assert(x > 0);
-
-     const int n = detail::max_pow2_less<
-                     detail::width<T> :: value, 4
-                   > :: value;
-
-     return detail::integer_log2_impl(x, n);
-
- }
-
-
-
-}
-
-
-
-#endif // include guard

include/boost/type.hpp

@@ -1,18 +0,0 @@
-// (C) Copyright David Abrahams 2001.
-// Distributed under 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)
-
-#ifndef BOOST_TYPE_DWA20010120_HPP
-# define BOOST_TYPE_DWA20010120_HPP
-
-namespace boost {
-
-  // Just a simple "type envelope". Useful in various contexts, mostly to work
-  // around some MSVC deficiencies.
-  template <class T>
-  struct type {};
-
-}
-
-#endif // BOOST_TYPE_DWA20010120_HPP

include/boost/visit_each.hpp

@@ -1,29 +0,0 @@
-// Boost.Signals library
-
-// Copyright Douglas Gregor 2001-2003. Use, modification and
-// distribution is 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)
-
-// For more information, see http://www.boost.org/libs/signals
-
-#ifndef BOOST_VISIT_EACH_HPP
-#define BOOST_VISIT_EACH_HPP
-
-#include <boost/config.hpp>
-
-namespace boost {
-  template<typename Visitor, typename T>
-  inline void visit_each(Visitor& visitor, const T& t, long)
-  {
-    visitor(t);
-  }
-
-  template<typename Visitor, typename T>
-  inline void visit_each(Visitor& visitor, const T& t)
-  {
-    visit_each(visitor, t, 0);
-  }
-}
-
-#endif // BOOST_VISIT_EACH_HPP

utf8_codecvt_facet.cpp

@@ -1,269 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// utf8_codecvt_facet.cpp
-
-// Copyright <20> 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
-// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). 
-// Use, modification and distribution is 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)
-
-// Please see the comments in <boost/detail/utf8_codecvt_facet.hpp> to
-// learn how this file should be used.
-
-#include <boost/detail/utf8_codecvt_facet.hpp>
-
-#include <cstdlib> // for multi-byte converson routines
-#include <cassert>
-
-#include <boost/limits.hpp>
-#include <boost/config.hpp>
-
-// If we don't have wstring, then Unicode support 
-// is not available anyway, so we don't need to even
-// compiler this file. This also fixes the problem
-// with mingw, which can compile this file, but will
-// generate link error when building DLL.
-#ifndef BOOST_NO_STD_WSTRING
-
-BOOST_UTF8_BEGIN_NAMESPACE
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation for wchar_t
-
-// Translate incoming UTF-8 into UCS-4
-std::codecvt_base::result utf8_codecvt_facet::do_in(
-    std::mbstate_t& /*state*/, 
-    const char * from,
-    const char * from_end, 
-    const char * & from_next,
-    wchar_t * to, 
-    wchar_t * to_end, 
-    wchar_t * & to_next
-) const {
-    // Basic algorithm:  The first octet determines how many
-    // octets total make up the UCS-4 character.  The remaining
-    // "continuing octets" all begin with "10". To convert, subtract
-    // the amount that specifies the number of octets from the first
-    // octet.  Subtract 0x80 (1000 0000) from each continuing octet,
-    // then mash the whole lot together.  Note that each continuing
-    // octet only uses 6 bits as unique values, so only shift by
-    // multiples of 6 to combine.
-    while (from != from_end && to != to_end) {
-
-        // Error checking   on the first octet
-        if (invalid_leading_octet(*from)){
-            from_next = from;
-            to_next = to;
-            return std::codecvt_base::error;
-        }
-
-        // The first octet is   adjusted by a value dependent upon 
-        // the number   of "continuing octets" encoding the character
-        const   int cont_octet_count = get_cont_octet_count(*from);
-        const   wchar_t octet1_modifier_table[] =   {
-            0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc
-        };
-
-        // The unsigned char conversion is necessary in case char is
-        // signed   (I learned this the hard way)
-        wchar_t ucs_result = 
-            (unsigned char)(*from++) - octet1_modifier_table[cont_octet_count];
-
-        // Invariants   : 
-        //   1) At the start of the loop,   'i' continuing characters have been
-        //    processed 
-        //   2) *from   points to the next continuing character to be processed.
-        int i   = 0;
-        while(i != cont_octet_count && from != from_end) {
-
-            // Error checking on continuing characters
-            if (invalid_continuing_octet(*from)) {
-                from_next   = from;
-                to_next =   to;
-                return std::codecvt_base::error;
-            }
-
-            ucs_result *= (1 << 6); 
-
-            // each continuing character has an extra (10xxxxxx)b attached to 
-            // it that must be removed.
-            ucs_result += (unsigned char)(*from++) - 0x80;
-            ++i;
-        }
-
-        // If   the buffer ends with an incomplete unicode character...
-        if (from == from_end && i   != cont_octet_count) {
-            // rewind "from" to before the current character translation
-            from_next = from - (i+1); 
-            to_next = to;
-            return std::codecvt_base::partial;
-        }
-        *to++   = ucs_result;
-    }
-    from_next = from;
-    to_next = to;
-
-    // Were we done converting or did we run out of destination space?
-    if(from == from_end) return std::codecvt_base::ok;
-    else return std::codecvt_base::partial;
-}
-
-std::codecvt_base::result utf8_codecvt_facet::do_out(
-    std::mbstate_t& /*state*/, 
-    const wchar_t *   from,
-    const wchar_t * from_end, 
-    const wchar_t * & from_next,
-    char * to, 
-    char * to_end, 
-    char * & to_next
-) const
-{
-    // RG - consider merging this table with the other one
-    const wchar_t octet1_modifier_table[] = {
-        0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc
-    };
-
-    wchar_t max_wchar = (std::numeric_limits<wchar_t>::max)();
-    while (from != from_end && to != to_end) {
-
-        // Check for invalid UCS-4 character
-        if (*from  > max_wchar) {
-            from_next = from;
-            to_next = to;
-            return std::codecvt_base::error;
-        }
-
-        int cont_octet_count = get_cont_octet_out_count(*from);
-
-        // RG  - comment this formula better
-        int shift_exponent = (cont_octet_count) *   6;
-
-        // Process the first character
-        *to++ = octet1_modifier_table[cont_octet_count] +
-            (unsigned char)(*from / (1 << shift_exponent));
-
-        // Process the continuation characters 
-        // Invariants: At   the start of the loop:
-        //   1) 'i' continuing octets   have been generated
-        //   2) '*to'   points to the next location to place an octet
-        //   3) shift_exponent is   6 more than needed for the next octet
-        int i   = 0;
-        while   (i != cont_octet_count && to != to_end) {
-            shift_exponent -= 6;
-            *to++ = 0x80 + ((*from / (1 << shift_exponent)) % (1 << 6));
-            ++i;
-        }
-        // If   we filled up the out buffer before encoding the character
-        if(to   == to_end && i != cont_octet_count) {
-            from_next = from;
-            to_next = to - (i+1);
-            return std::codecvt_base::partial;
-        }
-        *from++;
-    }
-    from_next = from;
-    to_next = to;
-    // Were we done or did we run out of destination space
-    if(from == from_end) return std::codecvt_base::ok;
-    else return std::codecvt_base::partial;
-}
-
-// How many char objects can I process to get <= max_limit
-// wchar_t objects?
-int utf8_codecvt_facet::do_length(
-    BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &,
-    const char * from,
-    const char * from_end, 
-    std::size_t max_limit
-#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-) const throw()
-#else
-) const
-#endif
-{ 
-    // RG - this code is confusing!  I need a better way to express it.
-    // and test cases.
-
-    // Invariants:
-    // 1) last_octet_count has the size of the last measured character
-    // 2) char_count holds the number of characters shown to fit
-    // within the bounds so far (no greater than max_limit)
-    // 3) from_next points to the octet 'last_octet_count' before the
-    // last measured character.  
-    int last_octet_count=0;
-    std::size_t char_count = 0;
-    const char* from_next = from;
-    // Use "<" because the buffer may represent incomplete characters
-    while (from_next+last_octet_count <= from_end && char_count <= max_limit) {
-        from_next += last_octet_count;
-        last_octet_count = (get_octet_count(*from_next));
-        ++char_count;
-    }
-    return from_next-from_end;
-}
-
-unsigned int utf8_codecvt_facet::get_octet_count(
-    unsigned char   lead_octet
-){
-    // if the 0-bit (MSB) is 0, then 1 character
-    if (lead_octet <= 0x7f) return 1;
-
-    // Otherwise the count number of consecutive 1 bits starting at MSB
-//    assert(0xc0 <= lead_octet && lead_octet <= 0xfd);
-
-    if (0xc0 <= lead_octet && lead_octet <= 0xdf) return 2;
-    else if (0xe0 <= lead_octet && lead_octet <= 0xef) return 3;
-    else if (0xf0 <= lead_octet && lead_octet <= 0xf7) return 4;
-    else if (0xf8 <= lead_octet && lead_octet <= 0xfb) return 5;
-    else return 6;
-}
-BOOST_UTF8_END_NAMESPACE
-
-namespace {
-template<std::size_t s>
-int get_cont_octet_out_count_impl(wchar_t word){
-    if (word < 0x80) {
-        return 0;
-    }
-    if (word < 0x800) {
-        return 1;
-    }
-    return 2;
-}
-
-// note the following code will generate on some platforms where
-// wchar_t is defined as UCS2.  The warnings are superfluous as
-// the specialization is never instantitiated with such compilers.
-template<>
-int get_cont_octet_out_count_impl<4>(wchar_t word){
-    if (word < 0x80) {
-        return 0;
-    }
-    if (word < 0x800) {
-        return 1;
-    }
-    if (word < 0x10000) {
-        return 2;
-    }
-    if (word < 0x200000) {
-        return 3;
-    }
-    if (word < 0x4000000) {
-        return 4;
-    }
-    return 5;
-}
-
-} // namespace anonymous
-
-BOOST_UTF8_BEGIN_NAMESPACE
-// How many "continuing octets" will be needed for this word
-// ==   total octets - 1.
-int utf8_codecvt_facet::get_cont_octet_out_count(
-    wchar_t word
-) const {
-    return get_cont_octet_out_count_impl<sizeof(wchar_t)>(word);
-}
-BOOST_UTF8_END_NAMESPACE
-
-#endif