Release 1.48.0

[SVN r75495]

include/boost/detail/bitmask.hpp

@@ -0,0 +1,47 @@
+//  boost/detail/bitmask.hpp  ------------------------------------------------//
+
+//  Copyright Beman Dawes 2006
+
+//  Distributed under the Boost Software License, Version 1.0
+//  http://www.boost.org/LICENSE_1_0.txt
+
+//  Usage:  enum foo { a=1, b=2, c=4 };
+//          BOOST_BITMASK( foo );
+//
+//          void f( foo arg );
+//          ...
+//          f( a | c );
+
+#ifndef BOOST_BITMASK_HPP
+#define BOOST_BITMASK_HPP
+
+#include <boost/cstdint.hpp>
+
+#define BOOST_BITMASK(Bitmask)                                            \
+                                                                          \
+  inline Bitmask operator| (Bitmask x , Bitmask y )                       \
+  { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x)     \
+      | static_cast<boost::int_least32_t>(y)); }                          \
+                                                                          \
+  inline Bitmask operator& (Bitmask x , Bitmask y )                       \
+  { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x)     \
+      & static_cast<boost::int_least32_t>(y)); }                          \
+                                                                          \
+  inline Bitmask operator^ (Bitmask x , Bitmask y )                       \
+  { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x)     \
+      ^ static_cast<boost::int_least32_t>(y)); }                          \
+                                                                          \
+  inline Bitmask operator~ (Bitmask x )                                   \
+  { return static_cast<Bitmask>(~static_cast<boost::int_least32_t>(x)); } \
+                                                                          \
+  inline Bitmask & operator&=(Bitmask & x , Bitmask y)                    \
+  { x = x & y ; return x ; }                                              \
+                                                                          \
+  inline Bitmask & operator|=(Bitmask & x , Bitmask y)                    \
+  { x = x | y ; return x ; }                                              \
+                                                                          \
+  inline Bitmask & operator^=(Bitmask & x , Bitmask y)                    \
+  { x = x ^ y ; return x ; }                                              
+
+#endif // BOOST_BITMASK_HPP
+

include/boost/detail/container_fwd.hpp

@@ -1,24 +1,84 @@
 
-// Copyright 2005-2008 Daniel James.
+// Copyright 2005-2011 Daniel James.
 // 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)
 
+// Note: if you change this include guard, you also need to change
+// container_fwd_compile_fail.cpp
 #if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP)
 #define BOOST_DETAIL_CONTAINER_FWD_HPP
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER) && (_MSC_VER >= 1020) && \
+    !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
 # pragma once
 #endif
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
-#if defined(BOOST_DETAIL_NO_CONTAINER_FWD) \
-    || ((defined(__GLIBCPP__) || defined(__GLIBCXX__)) \
-        && (defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL))) \
-    || BOOST_WORKAROUND(__BORLANDC__, > 0x551) \
-    || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x842)) \
-    || (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+// Define BOOST_DETAIL_NO_CONTAINER_FWD if you don't want this header to      //
+// forward declare standard containers.                                       //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD)
+#  if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+     // STLport
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__LIBCOMO__)
+     // Comeau STL:
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+     // Rogue Wave library:
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(_LIBCPP_VERSION)
+     // libc++
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+     // GNU libstdc++ 3
+#    if defined(_GLIBCXX_DEBUG) \
+        || defined(_GLIBCXX_PARALLEL) \
+        || defined(_GLIBCXX_PROFILE)
+#      define BOOST_DETAIL_NO_CONTAINER_FWD
+#    endif
+#  elif defined(__STL_CONFIG_H)
+     // generic SGI STL
+     //
+     // Forward declaration seems to be okay, but it has a couple of odd
+     // implementations.
+#    define BOOST_CONTAINER_FWD_BAD_BITSET
+#    if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
+#      define BOOST_CONTAINER_FWD_BAD_DEQUE
+#     endif
+#  elif defined(__MSL_CPP__)
+     // MSL standard lib:
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__IBMCPP__)
+     // The default VACPP std lib, forward declaration seems to be fine.
+#  elif defined(MSIPL_COMPILE_H)
+     // Modena C++ standard library
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+     // Dinkumware Library (this has to appear after any possible replacement
+     // libraries)
+     //
+     // Works fine.
+#  else
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  endif
+#endif
+
+// BOOST_DETAIL_TEST_* macros are for testing only
+// and shouldn't be relied upon. But you can use
+// BOOST_DETAIL_NO_CONTAINER_FWD to prevent forward
+// declaration of containers.
+
+#if !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
+
+#if defined(BOOST_DETAIL_NO_CONTAINER_FWD) && \
+    !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
 
 #include <deque>
 #include <list>
@@ -33,17 +93,6 @@
 
 #include <cstddef>
 
-#if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) && \
-        defined(__STL_CONFIG_H)
-
-#define BOOST_CONTAINER_FWD_BAD_BITSET
-
-#if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
-#define BOOST_CONTAINER_FWD_BAD_DEQUE
-#endif
-
-#endif
-
 #if defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
 #include <deque>
 #endif
@@ -68,12 +117,12 @@ namespace std
     template <class charT> struct char_traits;
 #endif
 
-    template <class T> class complex;
-}
+    #if BOOST_CLANG
+        template <class T> struct complex;
+    #else
+        template <class T> class complex;
+    #endif
 
-// gcc 3.4 and greater
-namespace std
-{
 #if !defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
     template <class T, class Allocator> class deque;
 #endif
@@ -96,6 +145,9 @@ namespace std
 #pragma warning(pop)
 #endif
 
-#endif
+#endif // BOOST_DETAIL_NO_CONTAINER_FWD &&
+       // !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
+
+#endif // BOOST_DETAIL_TEST_CONFIG_ONLY
 
 #endif

include/boost/detail/endian.hpp

@@ -44,11 +44,13 @@
 # endif
 # define BOOST_BYTE_ORDER __BYTE_ORDER
 #elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) || \
-    defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
+    defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) || \
+    defined(_STLP_BIG_ENDIAN) && !defined(_STLP_LITTLE_ENDIAN)
 # define BOOST_BIG_ENDIAN
 # define BOOST_BYTE_ORDER 4321
 #elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) || \
-    defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
+    defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) || \
+    defined(_STLP_LITTLE_ENDIAN) && !defined(_STLP_BIG_ENDIAN)
 # define BOOST_LITTLE_ENDIAN
 # define BOOST_BYTE_ORDER 1234
 #elif defined(__sparc) || defined(__sparc__) \

include/boost/detail/fenv.hpp

@@ -0,0 +1,73 @@
+/*=============================================================================
+    Copyright (c) 2010      Bryce Lelbach
+
+    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_NO_FENV_H)
+  #error This platform does not have a floating point environment
+#endif
+
+#if !defined(BOOST_DETAIL_FENV_HPP)
+#define BOOST_DETAIL_FENV_HPP
+
+/* If we're using clang + glibc, we have to get hacky. 
+ * See http://llvm.org/bugs/show_bug.cgi?id=6907 */
+#if defined(__clang__)       &&                       \
+    defined(__GNU_LIBRARY__) && /* up to version 5 */ \
+    defined(__GLIBC__)          /* version 6 + */
+  #define _FENV_H
+
+  #include <features.h>
+  #include <bits/fenv.h>
+
+  extern "C" {
+    extern int fegetexceptflag (fexcept_t*, int) __THROW;
+    extern int fesetexceptflag (__const fexcept_t*, int) __THROW;
+    extern int feclearexcept (int) __THROW;
+    extern int feraiseexcept (int) __THROW;
+    extern int fetestexcept (int) __THROW;
+    extern int fegetround (void) __THROW;
+    extern int fesetround (int) __THROW;
+    extern int fegetenv (fenv_t*) __THROW;
+    extern int fesetenv (__const fenv_t*) __THROW;
+    extern int feupdateenv (__const fenv_t*) __THROW;
+    extern int feholdexcept (fenv_t*) __THROW;
+
+    #ifdef __USE_GNU
+      extern int feenableexcept (int) __THROW;
+      extern int fedisableexcept (int) __THROW;
+      extern int fegetexcept (void) __THROW;
+    #endif
+  }
+
+  namespace std { namespace tr1 {
+    using ::fenv_t;
+    using ::fexcept_t;
+    using ::fegetexceptflag;
+    using ::fesetexceptflag;
+    using ::feclearexcept;
+    using ::feraiseexcept;
+    using ::fetestexcept;
+    using ::fegetround;
+    using ::fesetround;
+    using ::fegetenv;
+    using ::fesetenv;
+    using ::feupdateenv;
+    using ::feholdexcept;
+  } }
+
+#else /* if we're not using GNU's C stdlib, fenv.h should work with clang */
+  #if defined(__SUNPRO_CC) /* lol suncc */
+    #include <stdio.h>
+  #endif
+  
+  #include <fenv.h>
+
+#endif
+
+#endif /* BOOST_DETAIL_FENV_HPP */
+ 

include/boost/detail/interlocked.hpp

@@ -106,21 +106,28 @@ extern "C" void* __cdecl _InterlockedExchangePointer( void* volatile *, void* );
 
 #elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
 
+#if defined(__MINGW64__)
+#define BOOST_INTERLOCKED_IMPORT
+#else
+#define BOOST_INTERLOCKED_IMPORT __declspec(dllimport)
+#endif
+
+
 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 );
+extern "C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedIncrement( long volatile * );
+extern "C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedDecrement( long volatile * );
+extern "C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedCompareExchange( long volatile *, long, long );
+extern "C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchange( long volatile *, long );
+extern "C"BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchangeAdd( long volatile *, long );
 
 # if defined(_M_IA64) || defined(_M_AMD64)
-extern "C" __declspec(dllimport) void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* );
-extern "C" __declspec(dllimport) void* __stdcall InterlockedExchangePointer( void* volatile *, void* );
+extern "C"BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* );
+extern "C"BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer( void* volatile *, void* );
 # endif
 
 } // namespace detail

include/boost/detail/is_incrementable.hpp

@@ -70,10 +70,10 @@ namespace is_incrementable_
 # endif 
 
   // two check overloads help us identify which operator++ was picked
-  char (& check(tag) )[2];
+  char (& check_(tag) )[2];
   
   template <class T>
-  char check(T const&);
+  char check_(T const&);
   
 
   template <class T>
@@ -83,7 +83,7 @@ namespace is_incrementable_
 
       BOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check(BOOST_comma(++x,0))) == 1
+        , value = sizeof(is_incrementable_::check_(BOOST_comma(++x,0))) == 1
       );
   };
 
@@ -94,7 +94,7 @@ namespace is_incrementable_
 
       BOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1
+        , value = sizeof(is_incrementable_::check_(BOOST_comma(x++,0))) == 1
       );
   };
 

include/boost/detail/is_sorted.hpp

@@ -0,0 +1,56 @@
+/*==============================================================================
+    Copyright (c) 2010-2011 Bryce Lelbach
+
+    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_SORTED_HPP
+#define BOOST_DETAIL_SORTED_HPP
+
+#include <boost/detail/iterator.hpp>
+
+#include <functional>
+
+namespace boost {
+namespace detail {
+
+template<class Iterator, class Comp>
+inline Iterator is_sorted_until (Iterator first, Iterator last, Comp c) {
+  if (first == last)
+    return last;
+
+  Iterator it = first; ++it;
+
+  for (; it != last; first = it, ++it)
+    if (c(*it, *first))
+      return it;
+
+  return it;
+}
+
+template<class Iterator>
+inline Iterator is_sorted_until (Iterator first, Iterator last) {
+  typedef typename boost::detail::iterator_traits<Iterator>::value_type
+    value_type;
+
+  typedef std::less<value_type> c; 
+
+  return ::boost::detail::is_sorted_until(first, last, c()); 
+}
+
+template<class Iterator, class Comp>
+inline bool is_sorted (Iterator first, Iterator last, Comp c) {
+  return ::boost::detail::is_sorted_until(first, last, c) == last;
+} 
+
+template<class Iterator>
+inline bool is_sorted (Iterator first, Iterator last) {
+  return ::boost::detail::is_sorted_until(first, last) == last;
+} 
+
+} // detail
+} // boost
+
+#endif // BOOST_DETAIL_SORTED_HPP
+

include/boost/detail/lightweight_main.hpp

@@ -0,0 +1,36 @@
+//  boost/detail/lightweight_main.hpp  -------------------------------------------------//
+
+//  Copyright Beman Dawes 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <iostream>
+#include <exception>
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                exception reporting main() that calls cpp_main()                      //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+int cpp_main(int argc, char* argv[]);
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    return cpp_main(argc, argv);
+  }
+
+  catch (const std::exception& ex)
+  {
+    std::cout
+    << "\nERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR\n"
+    << "\n****************************** std::exception *****************************\n"
+    << ex.what()
+    << "\n***************************************************************************\n"
+    << std::endl;
+  }
+  return 1;
+}

include/boost/detail/lightweight_test.hpp

@@ -11,6 +11,7 @@
 //  boost/detail/lightweight_test.hpp - lightweight test library
 //
 //  Copyright (c) 2002, 2009 Peter Dimov
+//  Copyright (2) Beman Dawes 2010, 2011
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -23,8 +24,15 @@
 //  int boost::report_errors()
 //
 
-#include <boost/current_function.hpp>
 #include <iostream>
+#include <boost/current_function.hpp>
+#include <boost/assert.hpp>
+
+//  IDE's like Visual Studio perform better if output goes to std::cout or
+//  some other stream, so allow user to configure output stream:
+#ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM
+# define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr
+#endif
 
 namespace boost
 {
@@ -32,52 +40,95 @@ namespace boost
 namespace detail
 {
 
+struct report_errors_reminder
+{
+  bool called_report_errors_function;
+  report_errors_reminder() : called_report_errors_function(false) {}
+ ~report_errors_reminder()
+  {
+    BOOST_ASSERT(called_report_errors_function);  // verify report_errors() was called  
+  }
+};
+
+inline report_errors_reminder& report_errors_remind()
+{
+  static report_errors_reminder r;
+  return r;
+}
+
 inline int & test_errors()
 {
     static int x = 0;
+    report_errors_remind();
     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;
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << 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;
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << file << "(" << line << "): " << msg << " in function '"
+      << function << "'" << std::endl;
     ++test_errors();
 }
 
-template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2, char const * file, int line, char const * function, T const & t, U const & u )
+template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
 {
     if( t == u )
     {
     }
     else
     {
-        std::cerr << file << "(" << line << "): test '" << expr1 << " == " << expr2
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
             << "' failed in function '" << function << "': "
             << "'" << t << "' != '" << u << "'" << std::endl;
         ++test_errors();
     }
 }
 
+template<class T, class U> inline void test_ne_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t != u )
+    {
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " != " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' == '" << u << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
 } // namespace detail
 
 inline int report_errors()
 {
+    detail::report_errors_remind().called_report_errors_function = true;
+
     int errors = detail::test_errors();
 
     if( errors == 0 )
     {
-        std::cerr << "No errors detected." << std::endl;
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+          << "No errors detected." << std::endl;
         return 0;
     }
     else
     {
-        std::cerr << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+          << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
         return 1;
     }
 }
@@ -87,5 +138,6 @@ inline int report_errors()
 #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)
 #define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
 
 #endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED

include/boost/detail/win/GetCurrentProcess.hpp

@@ -0,0 +1,25 @@
+//  GetCurrentProcess.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETCURRENTPROCESS_HPP
+#define BOOST_DETAIL_WIN_GETCURRENTPROCESS_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetCurrentProcess;
+#else
+    extern "C" __declspec(dllimport) HANDLE_ WINAPI GetCurrentProcess();
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/GetCurrentThread.hpp

@@ -0,0 +1,34 @@
+//  GetCurrentThread.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETCURRENTTHREAD_HPP
+#define BOOST_DETAIL_WIN_GETCURRENTTHREAD_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( UNDER_CE )
+// Windows CE define GetCurrentThread as an inline function in kfuncs.h
+inline HANDLE_ GetCurrentThread() 
+{
+  return ::GetCurrentThread();
+}
+#else
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetCurrentThread;
+#else
+    extern "C" __declspec(dllimport) HANDLE_ WINAPI GetCurrentThread();
+#endif
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/GetLastError.hpp

@@ -0,0 +1,27 @@
+//  GetLastError.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETLASTERROR_HPP
+#define BOOST_DETAIL_WIN_GETLASTERROR_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetLastError;
+#else
+    extern "C" __declspec(dllimport) DWORD_ WINAPI
+        GetLastError();
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/GetProcessTimes.hpp

@@ -0,0 +1,35 @@
+//  GetProcessTimes.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETPROCESSTIMES_HPP
+#define BOOST_DETAIL_WIN_GETPROCESSTIMES_HPP
+
+#include <boost/detail/win/time.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if !defined(UNDER_CE)  // Windows CE does not define GetProcessTimes
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetProcessTimes;
+#else
+    extern "C" __declspec(dllimport) BOOL_ WINAPI
+        GetProcessTimes(
+            HANDLE_ hProcess,
+            LPFILETIME_ lpCreationTime,
+            LPFILETIME_ lpExitTime,
+            LPFILETIME_ lpKernelTime,
+            LPFILETIME_ lpUserTime
+        );
+#endif
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_GETPROCESSTIMES_HPP

include/boost/detail/win/GetThreadTimes.hpp

@@ -0,0 +1,33 @@
+//  GetThreadTimes.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETTHREADTIMES_HPP
+#define BOOST_DETAIL_WIN_GETTHREADTIMES_HPP
+
+#include <boost/detail/win/time.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetThreadTimes;
+#else
+    extern "C" __declspec(dllimport) BOOL_ WINAPI
+        GetThreadTimes(
+            HANDLE_ hThread,
+            LPFILETIME_ lpCreationTime,
+            LPFILETIME_ lpExitTime,
+            LPFILETIME_ lpKernelTime,
+            LPFILETIME_ lpUserTime
+        );
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_GETTHREADTIMES_HPP

include/boost/detail/win/LocalFree.hpp

@@ -0,0 +1,29 @@
+//  LocalFree.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_LOCALFREE_HPP
+#define BOOST_DETAIL_WIN_LOCALFREE_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef HANDLE_ HLOCAL_;
+
+    using ::LocalFree;
+#else
+    extern "C" typedef HANDLE_ HLOCAL_;
+    extern "C" __declspec(dllimport) HLOCAL_ WINAPI 
+        LocalFree(HLOCAL_ hMem);
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_LOCALFREE_HPP

include/boost/detail/win/basic_types.hpp

@@ -0,0 +1,111 @@
+//  basic_types.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_BASIC_TYPES_HPP
+#define BOOST_DETAIL_WIN_BASIC_TYPES_HPP
+#include <boost/config.hpp>
+#include <cstdarg>
+#include <boost/cstdint.hpp>
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) ||  defined(__CYGWIN__)
+# include <WinError.h>
+// @FIXME Which condition must be tested
+# ifdef UNDER_CE
+#  ifndef WINAPI
+#   ifndef _WIN32_WCE_EMULATION
+#    define WINAPI  __cdecl     // Note this doesn't match the desktop definition
+#   else
+#    define WINAPI  __stdcall
+#   endif
+#  endif
+# else
+#  ifndef WINAPI
+#    define WINAPI  __stdcall
+#  endif
+# endif
+#else
+# error "Win32 functions not available"
+#endif
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef ::BOOL BOOL_;
+    typedef ::WORD WORD_;
+    typedef ::DWORD DWORD_;
+    typedef ::HANDLE HANDLE_;
+    typedef ::LONG LONG_;
+    typedef ::LONGLONG LONGLONG_;
+    typedef ::ULONG_PTR ULONG_PTR_;
+    typedef ::LARGE_INTEGER LARGE_INTEGER_;
+    typedef ::PLARGE_INTEGER PLARGE_INTEGER_;
+    typedef ::PVOID PVOID_;
+    typedef ::LPVOID LPVOID_;
+    typedef ::CHAR CHAR_;
+    typedef ::LPSTR LPSTR_;
+    typedef ::LPCSTR LPCSTR_;
+    typedef ::WCHAR WCHAR_;
+    typedef ::LPWSTR LPWSTR_;
+    typedef ::LPCWSTR LPCWSTR_;
+#else
+extern "C" {
+    typedef int BOOL_;
+    typedef unsigned short WORD_;
+    typedef unsigned long DWORD_;
+    typedef void* HANDLE_;
+
+    typedef long LONG_;
+
+// @FIXME Which condition must be tested
+//~ #if !defined(_M_IX86)
+//~ #if defined(BOOST_NO_INT64_T)
+    //~ typedef double LONGLONG_;
+//~ #else
+    //~ typedef __int64 LONGLONG_;
+//~ #endif
+//~ #else
+    //~ typedef double LONGLONG_;
+//~ #endif
+    typedef boost::int64_t LONGLONG_;
+
+// @FIXME Which condition must be tested
+# ifdef _WIN64
+#if defined(__CYGWIN__)
+    typedef unsigned long ULONG_PTR_;
+#else
+    typedef unsigned __int64 ULONG_PTR_;
+#endif
+# else
+    typedef unsigned long ULONG_PTR_;
+# endif
+
+    typedef struct _LARGE_INTEGER {
+        LONGLONG_ QuadPart;
+    } LARGE_INTEGER_;
+    typedef LARGE_INTEGER_ *PLARGE_INTEGER_;
+
+    typedef void *PVOID_;
+    typedef void *LPVOID_;
+    typedef const void *LPCVOID_;
+
+    typedef char CHAR_;
+    typedef CHAR_ *LPSTR_;
+    typedef const CHAR_ *LPCSTR_;
+
+    typedef wchar_t WCHAR_;
+    typedef WCHAR_ *LPWSTR_;
+    typedef const WCHAR_ *LPCWSTR_;
+
+}
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/directory_management.hpp

@@ -0,0 +1,43 @@
+//  directory_management.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_DIRECTORY_MANAGEMENT_HPP
+#define BOOST_DETAIL_WIN_DIRECTORY_MANAGEMENT_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/security.hpp>
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::CreateDirectory;
+    using ::CreateDirectoryA;
+    using ::GetTempPathA;
+    using ::RemoveDirectoryA;
+#else
+extern "C" { 
+    __declspec(dllimport) int __stdcall 
+        CreateDirectory(LPCTSTR_, LPSECURITY_ATTRIBUTES_*);
+    __declspec(dllimport) int __stdcall 
+        CreateDirectoryA(LPCTSTR_, interprocess_security_attributes*);
+    __declspec(dllimport) int __stdcall 
+        GetTempPathA(unsigned long length, char *buffer);
+    __declspec(dllimport) int __stdcall 
+        RemoveDirectoryA(LPCTSTR_);
+    
+}    
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_THREAD_HPP

include/boost/detail/win/dll.hpp

@@ -0,0 +1,52 @@
+//  dll.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_DLL_HPP
+#define BOOST_DETAIL_WIN_DLL_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/security.hpp>
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::LoadLibrary;
+    using ::FreeLibrary;
+    using ::GetProcAddress;
+    using ::GetModuleHandleA;
+#else
+extern "C" { 
+    __declspec(dllimport) HMODULE_ __stdcall 
+        LoadLibrary(
+            LPCTSTR_ lpFileName
+    );
+    __declspec(dllimport) BOOL_ __stdcall 
+        FreeLibrary(
+            HMODULE_ hModule
+    );
+    __declspec(dllimport) FARPROC_ __stdcall 
+        GetProcAddress(
+            HMODULE_ hModule,
+            LPCSTR_ lpProcName
+    );
+    __declspec(dllimport) FARPROC_ __stdcall 
+        GetModuleHandleA(
+            LPCSTR_ lpProcName
+    );
+    
+}    
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_THREAD_HPP

include/boost/detail/win/error_handling.hpp

@@ -0,0 +1,88 @@
+//  error_handling.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_ERROR_HANDLING_HPP
+#define BOOST_DETAIL_WIN_ERROR_HANDLING_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/GetCurrentThread.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::FormatMessageA;
+    using ::FormatMessageW;
+
+    const int FORMAT_MESSAGE_ALLOCATE_BUFFER_= FORMAT_MESSAGE_ALLOCATE_BUFFER;
+    const int FORMAT_MESSAGE_IGNORE_INSERTS_=  FORMAT_MESSAGE_IGNORE_INSERTS;
+    const int FORMAT_MESSAGE_FROM_STRING_=     FORMAT_MESSAGE_FROM_STRING;
+    const int FORMAT_MESSAGE_FROM_HMODULE_=    FORMAT_MESSAGE_FROM_HMODULE;
+    const int FORMAT_MESSAGE_FROM_SYSTEM_=     FORMAT_MESSAGE_FROM_SYSTEM;
+    const int FORMAT_MESSAGE_ARGUMENT_ARRAY_=  FORMAT_MESSAGE_ARGUMENT_ARRAY;
+    const int FORMAT_MESSAGE_MAX_WIDTH_MASK_=  FORMAT_MESSAGE_MAX_WIDTH_MASK;
+
+    const char LANG_NEUTRAL_=                  LANG_NEUTRAL;
+    const char LANG_INVARIANT_=                LANG_INVARIANT;
+
+    const char SUBLANG_DEFAULT_=               SUBLANG_DEFAULT;    // user default
+    inline WORD_ MAKELANGID_(WORD_ p, WORD_ s) {
+        return MAKELANGID(p,s);
+    }
+#else
+extern "C" {
+    //                using ::FormatMessageA;
+    __declspec(dllimport)
+    DWORD_
+    WINAPI
+    FormatMessageA(
+        DWORD_ dwFlags,
+        LPCVOID_ lpSource,
+        DWORD_ dwMessageId,
+        DWORD_ dwLanguageId,
+        LPSTR_ lpBuffer,
+        DWORD_ nSize,
+        va_list *Arguments
+        );
+
+    //                using ::FormatMessageW;
+    __declspec(dllimport)
+    DWORD_
+    WINAPI
+    FormatMessageW(
+        DWORD_ dwFlags,
+        LPCVOID_ lpSource,
+        DWORD_ dwMessageId,
+        DWORD_ dwLanguageId,
+        LPWSTR_ lpBuffer,
+        DWORD_ nSize,
+        va_list *Arguments
+        );
+
+    const int FORMAT_MESSAGE_ALLOCATE_BUFFER_= 0x00000100;
+    const int FORMAT_MESSAGE_IGNORE_INSERTS_=  0x00000200;
+    const int FORMAT_MESSAGE_FROM_STRING_=     0x00000400;
+    const int FORMAT_MESSAGE_FROM_HMODULE_=    0x00000800;
+    const int FORMAT_MESSAGE_FROM_SYSTEM_=     0x00001000;
+    const int FORMAT_MESSAGE_ARGUMENT_ARRAY_=  0x00002000;
+    const int FORMAT_MESSAGE_MAX_WIDTH_MASK_=  0x000000FF;
+
+    const char LANG_NEUTRAL_=                  0x00;
+    const char LANG_INVARIANT_=                0x7f;
+
+    const char SUBLANG_DEFAULT_=               0x01;    // user default
+    inline WORD_ MAKELANGID_(WORD_ p, WORD_ s) {
+        return ((((WORD_  )(s)) << 10) | (WORD_  )(p));
+    }
+
+}
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_ERROR_HANDLING_HPP

include/boost/detail/win/file_management.hpp

@@ -0,0 +1,126 @@
+//  thread.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_FILE_MANAGEMENT_HPP
+#define BOOST_DETAIL_WIN_FILE_MANAGEMENT_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/security.hpp>
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::CreateFileA;
+    using ::DeleteFileA;
+    using ::FindFirstFileA;
+    using ::FindNextFileA;
+    using ::FindClose;
+    using ::GetFileSizeEx;
+    using ::MoveFileExA;
+    using ::SetFileValidData;
+#else
+extern "C" {
+    typedef struct _OVERLAPPED {
+      ULONG_PTR Internal;
+      ULONG_PTR InternalHigh;
+      union {
+        struct {
+          DWORD Offset;
+          DWORD OffsetHigh;
+        } ;
+        PVOID  Pointer;
+      } ;
+      HANDLE    hEvent;
+    } OVERLAPPED, *LPOVERLAPPED;
+
+    
+    __declspec(dllimport) void * __stdcall 
+        CreateFileA (const char *, unsigned long, unsigned long, struct SECURITY_ATTRIBUTES_*, unsigned long, unsigned long, void *);
+    __declspec(dllimport) int __stdcall    
+        DeleteFileA (const char *);
+    __declspec(dllimport) void *__stdcall 
+        FindFirstFileA(const char *lpFileName, win32_find_data_t *lpFindFileData);
+    __declspec(dllimport) int   __stdcall 
+        FindNextFileA(void *hFindFile, win32_find_data_t *lpFindFileData);
+    __declspec(dllimport) int   __stdcall 
+        FindClose(void *hFindFile);
+    __declspec(dllimport) BOOL __stdcall 
+        GetFileSizeEx(
+            HANDLE_ hFile,
+            PLARGE_INTEGER_ lpFileSize
+    );
+    __declspec(dllimport) int __stdcall    
+        MoveFileExA (const char *, const char *, unsigned long);
+    __declspec(dllimport) BOOL_ __stdcall 
+        SetFileValidData(
+            HANDLE_ hFile,
+            LONGLONG_ ValidDataLength
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        SetEndOfFile(
+            HANDLE_ hFile
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        SetFilePointerEx(
+            HANDLE_ hFile,
+            LARGE_INTEGER_ liDistanceToMove,
+            PLARGE_INTEGER_ lpNewFilePointer,
+            DWORD_ dwMoveMethod
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        LockFile(
+            HANDLE_ hFile,
+            DWORD_ dwFileOffsetLow,
+            DWORD_ dwFileOffsetHigh,
+            DWORD_ nNumberOfBytesToLockLow,
+            DWORD_ nNumberOfBytesToLockHigh
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        UnlockFile(
+            HANDLE_ hFile,
+            DWORD_ dwFileOffsetLow,
+            DWORD_ dwFileOffsetHigh,
+            DWORD_ nNumberOfBytesToUnlockLow,
+            DWORD_ nNumberOfBytesToUnlockHigh
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        LockFileEx(
+            HANDLE_ hFile,
+            DWORD_ dwFlags,
+            DWORD_ dwReserved,
+            DWORD_ nNumberOfBytesToLockLow,
+            DWORD_ nNumberOfBytesToLockHigh,
+            LPOVERLAPPED_ lpOverlapped
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        UnlockFileEx(
+            HANDLE_ hFile,
+            DWORD_ dwReserved,
+            DWORD_ nNumberOfBytesToUnlockLow,
+            DWORD_ nNumberOfBytesToUnlockHigh,
+            LPOVERLAPPED_ lpOverlapped
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        WriteFile(
+            HANDLE_ hFile,
+            LPCVOID_ lpBuffer,
+            DWORD_ nNumberOfBytesToWrite,
+            LPDWORD_ lpNumberOfBytesWritten,
+            LPOVERLAPPED_ lpOverlapped
+    );
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_THREAD_HPP

include/boost/detail/win/handles.hpp

@@ -0,0 +1,37 @@
+//  memory.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_HANDLES_HPP
+#define BOOST_DETAIL_WIN_HANDLES_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::CloseHandle;
+    using ::DuplicateHandle;
+#else
+extern "C" { 
+    __declspec(dllimport) int __stdcall 
+        CloseHandle(void*);
+    __declspec(dllimport) int __stdcall 
+        DuplicateHandle(void*,void*,void*,void**,unsigned long,int,unsigned long);
+}
+
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_HANDLES_HPP

include/boost/detail/win/memory.hpp

@@ -0,0 +1,59 @@
+//  memory.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_MEMORY_HPP
+#define BOOST_DETAIL_WIN_MEMORY_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/security.hpp>
+#include <boost/detail/win/LocalFree.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::CreateFileMappingA;
+    using ::FlushViewOfFile;
+    using ::GetProcessHeap;
+    using ::HeapAlloc;
+    using ::HeapFree;
+    using ::MapViewOfFileEx;
+    using ::OpenFileMappingA;
+    using ::UnmapViewOfFile;
+#else
+# ifdef HeapAlloc
+# undef HeapAlloc
+# endif
+extern "C" {
+    __declspec(dllimport) void * __stdcall 
+        CreateFileMappingA (void *, SECURITY_ATTRIBUTES_*, unsigned long, unsigned long, unsigned long, const char *);
+    __declspec(dllimport) int __stdcall 
+        FlushViewOfFile (void *, std::size_t);
+    __declspec(dllimport) HANDLE_ __stdcall 
+        GetProcessHeap();
+    __declspec(dllimport) void* __stdcall 
+        HeapAlloc(HANDLE_,DWORD_,SIZE_T_);
+    __declspec(dllimport) BOOL_ __stdcall 
+        HeapFree(HANDLE_,DWORD_,LPVOID_);
+    __declspec(dllimport) void * __stdcall 
+        MapViewOfFileEx (void *, unsigned long, unsigned long, unsigned long, std::size_t, void*);
+    __declspec(dllimport) void * __stdcall 
+        OpenFileMappingA (unsigned long, int, const char *);
+    __declspec(dllimport) int __stdcall 
+        UnmapViewOfFile(void *);
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP

include/boost/detail/win/process.hpp

@@ -0,0 +1,33 @@
+//  process.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_PROCESS_HPP
+#define BOOST_DETAIL_WIN_PROCESS_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/GetCurrentProcess.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetCurrentProcessId;
+#else
+# ifndef UNDER_CE
+extern "C" { 
+    __declspec(dllimport) unsigned long __stdcall 
+        GetCurrentProcessId(void);
+}    
+# else
+    using ::GetCurrentProcessId;
+# endif
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_PROCESS_HPP

include/boost/detail/win/security.hpp

@@ -0,0 +1,62 @@
+//  security.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_SECURITY_HPP
+#define BOOST_DETAIL_WIN_SECURITY_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+typedef ::SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES_;
+typedef ::PSECURITY_ATTRIBUTES PSECURITY_ATTRIBUTES_;
+typedef ::LPSECURITY_ATTRIBUTES LPSECURITY_ATTRIBUTES_;
+    
+#else
+extern "C" { 
+    struct SECURITY_DESCRIPTOR_;
+    typedef SECURITY_DESCRIPTOR_* PSECURITY_DESCRIPTOR_;
+    typedef struct _ACL {
+      BYTE_ AclRevision;
+      BYTE_ Sbz1;
+      WORD_ AclSize;
+      WORD_ AceCount;
+      WORD_ Sbz2;
+    } ACL_, *PACL_;
+
+    typedef struct _SECURITY_ATTRIBUTES {
+      DWORD_  nLength;
+      LPVOID_ lpSecurityDescriptor;
+      BOOL_   bInheritHandle;
+    } SECURITY_ATTRIBUTES_, *PSECURITY_ATTRIBUTES_, *LPSECURITY_ATTRIBUTES_;
+
+    __declspec(dllimport) BOOL_ __stdcall 
+        InitializeSecurityDescriptor(
+            PSECURITY_DESCRIPTOR_ pSecurityDescriptor,
+            DWORD_ dwRevision
+    );
+    __declspec(dllimport) BOOL_ __stdcall 
+        SetSecurityDescriptorDacl(
+            PSECURITY_DESCRIPTOR_ pSecurityDescriptor,
+            BOOL_ bDaclPresent,
+            PACL_ pDacl,
+            BOOL_ bDaclDefaulted
+    );
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_SECURITY_HPP

include/boost/detail/win/synchronization.hpp

@@ -0,0 +1,125 @@
+//  synchronizaion.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP
+#define BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef ::CRITICAL_SECTION CRITICAL_SECTION_;
+    typedef ::PAPCFUNC PAPCFUNC_;
+
+    using ::InitializeCriticalSection;
+    using ::EnterCriticalSection;
+    using ::TryEnterCriticalSection;
+    using ::LeaveCriticalSection;
+    using ::DeleteCriticalSection;
+    
+# ifdef BOOST_NO_ANSI_APIS
+    using ::CreateMutexW;
+    using ::CreateEventW;
+    using ::OpenEventW;
+    using ::CreateSemaphoreW;
+# else
+    using ::CreateMutexA;
+    using ::CreateEventA;
+    using ::OpenEventA;
+    using ::CreateSemaphoreA;
+# endif
+    using ::ReleaseMutex;
+    using ::ReleaseSemaphore;
+    using ::SetEvent;
+    using ::ResetEvent;
+    using ::WaitForMultipleObjects;
+    using ::WaitForSingleObject;
+            using ::QueueUserAPC;
+#else
+extern "C" {
+    struct CRITICAL_SECTION_
+    {
+        struct critical_section_debug * DebugInfo;
+        long LockCount;
+        long RecursionCount;
+        void * OwningThread;
+        void * LockSemaphore;
+    #if defined(_WIN64)
+        unsigned __int64 SpinCount;
+    #else
+        unsigned long SpinCount;
+    #endif
+    };
+
+     __declspec(dllimport) void __stdcall 
+        InitializeCriticalSection(CRITICAL_SECTION_ *);
+    __declspec(dllimport) void __stdcall 
+        EnterCriticalSection(CRITICAL_SECTION_ *);
+    __declspec(dllimport) bool __stdcall 
+        TryEnterCriticalSection(CRITICAL_SECTION_ *);
+    __declspec(dllimport) void __stdcall 
+        LeaveCriticalSection(CRITICAL_SECTION_ *);
+    __declspec(dllimport) void __stdcall 
+        DeleteCriticalSection(CRITICAL_SECTION_ *);
+    
+    struct _SECURITY_ATTRIBUTES;
+# ifdef BOOST_NO_ANSI_APIS
+    __declspec(dllimport) void* __stdcall 
+        CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
+    __declspec(dllimport) void* __stdcall 
+        CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
+    __declspec(dllimport) void* __stdcall 
+        CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
+    __declspec(dllimport) void* __stdcall 
+        OpenEventW(unsigned long,int,wchar_t const*);
+# else
+    __declspec(dllimport) void* __stdcall 
+        CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*);
+    __declspec(dllimport) void* __stdcall 
+        CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*);
+    __declspec(dllimport) void* __stdcall 
+        CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*);
+    __declspec(dllimport) void* __stdcall 
+        OpenEventA(unsigned long,int,char const*);
+# endif
+    __declspec(dllimport) int __stdcall 
+        ReleaseMutex(void*);
+    __declspec(dllimport) unsigned long __stdcall 
+        WaitForSingleObject(void*,unsigned long);
+    __declspec(dllimport) unsigned long __stdcall 
+        WaitForMultipleObjects(unsigned long nCount,
+                void* const * lpHandles,
+                int bWaitAll,
+                unsigned long dwMilliseconds);
+    __declspec(dllimport) int __stdcall 
+        ReleaseSemaphore(void*,long,long*);
+    typedef void (__stdcall *PAPCFUNC8)(ulong_ptr);
+    __declspec(dllimport) unsigned long __stdcall 
+        QueueUserAPC(PAPCFUNC8,void*,ulong_ptr);
+# ifndef UNDER_CE
+    __declspec(dllimport) int __stdcall 
+        SetEvent(void*);
+    __declspec(dllimport) int __stdcall 
+        ResetEvent(void*);
+# else
+    using ::SetEvent;
+    using ::ResetEvent;
+# endif
+}    
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP

include/boost/detail/win/system.hpp

@@ -0,0 +1,50 @@
+//  system.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_SYSTEM_HPP
+#define BOOST_DETAIL_WIN_SYSTEM_HPP
+#include <boost/config.hpp>
+#include <cstdarg>
+
+#include <boost/detail/win/basic_types.hpp>
+extern "C" __declspec(dllimport) void __stdcall GetSystemInfo (struct system_info *);
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef ::SYSTEM_INFO SYSTEM_INFO_;
+#else
+extern "C" {
+    typedef struct _SYSTEM_INFO {
+      union {
+        DWORD_  dwOemId;
+        struct {
+          WORD_ wProcessorArchitecture;
+          WORD_ wReserved;
+        } dummy;
+      } ;
+      DWORD_     dwPageSize;
+      LPVOID_    lpMinimumApplicationAddress;
+      LPVOID_    lpMaximumApplicationAddress;
+      DWORD_PTR_ dwActiveProcessorMask;
+      DWORD_     dwNumberOfProcessors;
+      DWORD_     dwProcessorType;
+      DWORD_     dwAllocationGranularity;
+      WORD_      wProcessorLevel;
+      WORD_      wProcessorRevision;
+    } SYSTEM_INFO_;
+
+    __declspec(dllimport) void __stdcall 
+        GetSystemInfo (struct system_info *);
+}    
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/thread.hpp

@@ -0,0 +1,45 @@
+//  thread.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_THREAD_HPP
+#define BOOST_DETAIL_WIN_THREAD_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/GetCurrentThread.hpp>
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetCurrentThreadId;
+    using ::SleepEx;
+    using ::Sleep;
+#else
+extern "C" { 
+# ifndef UNDER_CE
+    __declspec(dllimport) unsigned long __stdcall 
+        GetCurrentThreadId(void);
+    __declspec(dllimport) unsigned long __stdcall 
+        SleepEx(unsigned long,int);
+    __declspec(dllimport) void __stdcall 
+        Sleep(unsigned long);
+#else
+    using ::GetCurrentThreadId;
+    using ::SleepEx;
+    using ::Sleep;
+#endif    
+}    
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_THREAD_HPP

include/boost/detail/win/time.hpp

@@ -0,0 +1,72 @@
+//  time.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_TIME_HPP
+#define BOOST_DETAIL_WIN_TIME_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef FILETIME FILETIME_;
+    typedef PFILETIME PFILETIME_;
+    typedef LPFILETIME LPFILETIME_;
+
+    typedef SYSTEMTIME SYSTEMTIME_;
+    typedef SYSTEMTIME* PSYSTEMTIME_;
+
+    #ifndef UNDER_CE  // Windows CE does not define GetSystemTimeAsFileTime
+    using ::GetSystemTimeAsFileTime;
+    #endif
+    using ::FileTimeToLocalFileTime;
+    using ::GetSystemTime;
+    using ::SystemTimeToFileTime;
+    using ::GetTickCount;
+
+#else
+extern "C" {
+    typedef struct _FILETIME {
+        DWORD_ dwLowDateTime;
+        DWORD_ dwHighDateTime;
+    } FILETIME_, *PFILETIME_, *LPFILETIME_;
+
+    typedef struct _SYSTEMTIME {
+      WORD_ wYear;
+      WORD_ wMonth;
+      WORD_ wDayOfWeek;
+      WORD_ wDay;
+      WORD_ wHour;
+      WORD_ wMinute;
+      WORD_ wSecond;
+      WORD_ wMilliseconds;
+    } SYSTEMTIME_, *PSYSTEMTIME_;
+
+    #ifndef UNDER_CE  // Windows CE does not define GetSystemTimeAsFileTime
+    __declspec(dllimport) void WINAPI
+        GetSystemTimeAsFileTime(FILETIME_* lpFileTime);
+    #endif
+    __declspec(dllimport) int WINAPI
+        FileTimeToLocalFileTime(const FILETIME_* lpFileTime, 
+                FILETIME_* lpLocalFileTime);
+    __declspec(dllimport) void WINAPI
+        GetSystemTime(SYSTEMTIME_* lpSystemTime);
+    __declspec(dllimport) int WINAPI
+        SystemTimeToFileTime(const SYSTEMTIME_* lpSystemTime, 
+                FILETIME_* lpFileTime);
+    __declspec(dllimport) unsigned long __stdcall 
+        GetTickCount();
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/timers.hpp

@@ -0,0 +1,41 @@
+//  timers.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_TIMERS_HPP
+#define BOOST_DETAIL_WIN_TIMERS_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::QueryPerformanceCounter;
+    using ::QueryPerformanceFrequency;
+#else
+extern "C" { 
+    __declspec(dllimport) BOOL_ WINAPI
+        QueryPerformanceCounter(
+            LARGE_INTEGER_ *lpPerformanceCount
+        );
+
+    __declspec(dllimport) BOOL_ WINAPI
+        QueryPerformanceFrequency(
+            LARGE_INTEGER_ *lpFrequency
+        );
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_TIMERS_HPP

test/Jamfile

@@ -0,0 +1,23 @@
+################################################################*# Jam #*#######
+#   Copyright (C) 2010 Bryce Lelbach
+#
+#   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)
+################################################################################
+
+build-project container_fwd ;
+
+project detail/test 
+  : requirements
+    <toolset>clang:<cxxflags>-Wno-unused
+    <toolset>clang:<cxxflags>-Wno-tautological-compare
+    <toolset>clang:<cxxflags>-ftemplate-depth-300
+    <toolset>gcc:<cxxflags>-ftemplate-depth-300
+    <toolset>darwin:<cxxflags>-ftemplate-depth-300
+  ;
+
+for tests in [ glob *.cpp ] {
+  run $(tests) : : : : $(tests:B) ;
+}
+
+

test/container_fwd/Jamfile

@@ -0,0 +1,28 @@
+
+# Copyright 2011 Daniel James.
+# 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)
+
+import testing ;
+
+project detail/test/container_fwd
+  : requirements
+        <warnings>all
+        <toolset>intel:<warnings>on
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
+        <warnings-as-errors>on
+  ;
+
+run container_no_fwd_test.cpp ;
+run container_fwd_test.cpp : : : : container_fwd ;
+run container_fwd_test.cpp : :
+    : <define>_STLP_DEBUG <define>_GLIBCXX_DEBUG
+    : container_fwd_debug ;
+
+compile-fail correctly_disable_fail.cpp
+    : <warnings-as-errors>off
+    : correctly_disable ;
+compile-fail correctly_disable_fail.cpp
+    : <warnings-as-errors>off <define>_STLP_DEBUG <define>_GLIBCXX_DEBUG
+    : correctly_disable_debug ;

test/container_fwd/container_fwd_test.cpp

@@ -0,0 +1,112 @@
+
+// Copyright 2005-2009 Daniel James.
+// 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/functional/detail/container_fwd.hpp>
+
+#if BOOST_WORKAROUND(__GNUC__, < 3) && \
+    !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+template <class charT, class Allocator>
+static void test(
+    std::basic_string<charT, std::string_char_traits<charT>, Allocator> const&)
+{
+}
+#else
+template <class charT, class Allocator>
+static void test(
+    std::basic_string<charT, std::char_traits<charT>, Allocator> const&)
+{
+}
+#endif
+    
+template <class T, class Allocator>
+static void test(std::deque<T, Allocator> const&)
+{
+}
+
+template <class T, class Allocator>
+static void test(std::list<T, Allocator> const&)
+{
+}
+
+template <class T, class Allocator>
+static void test(std::vector<T, Allocator> const&)
+{
+}
+
+template <class Key, class T, class Compare, class Allocator>
+static void test(std::map<Key, T, Compare, Allocator> const&)
+{
+}
+
+template <class Key, class T, class Compare, class Allocator>
+static void test(std::multimap<Key, T, Compare, Allocator> const&)
+{
+}
+
+template <class Key, class Compare, class Allocator>
+static void test(std::set<Key, Compare, Allocator> const&)
+{
+}
+
+template <class Key, class Compare, class Allocator>
+static void test(std::multiset<Key, Compare, Allocator> const&)
+{
+}
+
+template <std::size_t N>
+static void test(std::bitset<N> const&)
+{
+}
+
+template <class T>
+static void test(std::complex<T> const&)
+{
+}
+
+template <class X, class Y>
+static void test(std::pair<X, Y> const&)
+{
+}
+
+#include <deque>
+#include <list>
+#include <vector>
+#include <map>
+#include <set>
+#include <bitset>
+#include <string>
+#include <complex>
+#include <utility>
+
+int main()
+{
+    std::deque<int> x1;
+    std::list<std::string> x2;
+    std::vector<float> x3;
+    std::vector<bool> x4;
+    std::map<int, int> x5;
+    std::multimap<float, int*> x6;
+    std::set<std::string> x7;
+    std::multiset<std::vector<int> > x8;
+    std::bitset<10> x9;
+    std::string x10;
+    std::complex<double> x11;
+    std::pair<std::list<int>, char***> x12;
+
+    test(x1);
+    test(x2);
+    test(x3);
+    test(x4);
+    test(x5);
+    test(x6);
+    test(x7);
+    test(x8);
+    test(x9);
+    test(x10);
+    test(x11);
+    test(x12);
+
+    return 0;
+}

test/container_fwd/container_no_fwd_test.cpp

@@ -0,0 +1,14 @@
+
+// Copyright 2010 Daniel James.
+// 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)
+
+#define BOOST_DETAIL_NO_CONTAINER_FWD
+
+#include <boost/detail/container_fwd.hpp>
+
+int main()
+{
+    std::set<int> x;
+    std::vector<std::string> y;
+}

test/container_fwd/correctly_disable_fail.cpp

@@ -0,0 +1,43 @@
+
+// Copyright 2011 Daniel James.
+// 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 tests if container forwarding is correctly disabled. If it isn't
+// disabled it causes a compile error (which causes the test to pass).
+// If it is disabled it tries container forwarding. If it doesn't work
+// then there will be a compile error, indicating that it is correctly
+// disabled. But if there isn't a compile error that indicates that
+// container forwarding might work.
+//
+// Since this test only tries std::vector, it might get it wrong but I didn't
+// want it to fail because of some incompatibility with a trickier class.
+
+#define BOOST_DETAIL_TEST_CONFIG_ONLY
+#include <boost/detail/container_fwd.hpp>
+
+#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD)
+#error "Failing in order to pass test"
+#else
+#define BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD
+
+#undef BOOST_DETAIL_CONTAINER_FWD_HPP
+#undef BOOST_DETAIL_TEST_CONFIG_ONLY
+
+#include <boost/detail/container_fwd.hpp>
+
+template <class T, class Allocator>
+void test(std::vector<T, Allocator> const&)
+{
+}
+
+#include <vector>
+
+int main ()
+{
+    std::vector<int> x;
+    test(x);
+}
+
+#endif
+

test/is_sorted_test.cpp

@@ -0,0 +1,130 @@
+/*==============================================================================
+    Copyright (c) 2010-2011 Bryce Lelbach
+
+    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 <ios>
+#include <boost/config.hpp>
+#include <boost/array.hpp>
+#include <boost/detail/is_sorted.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+template<class T>
+struct tracking_less: std::binary_function <T, T, bool> {
+  typedef bool result_type;
+
+  #if defined(__PATHSCALE__)
+  tracking_less (void) { }
+  ~tracking_less (void) { }
+  #endif
+
+  bool operator() (T const& x, T const& y) const {
+    std::cout << x << " < " << y << " == " << (x < y) << "\n"; 
+    return x < y;
+  }
+};
+
+template<class T>
+struct tracking_less_equal: std::binary_function <T, T, bool> {
+  typedef bool result_type;
+
+  #if defined(__PATHSCALE__)
+  tracking_less_equal (void) { }
+  ~tracking_less_equal (void) { }
+  #endif
+
+  bool operator() (T const& x, T const& y) const {
+    std::cout << x << " <= " << y << " == " << (x <= y) << "\n"; 
+    return x <= y;
+  }
+};
+
+template<class T>
+struct tracking_greater: std::binary_function <T, T, bool> {
+  typedef bool result_type;
+
+  #if defined(__PATHSCALE__)
+  tracking_greater (void) { }
+  ~tracking_greater (void) { }
+  #endif
+
+  bool operator() (T const& x, T const& y) const {
+    std::cout << x << " > " << y << " == " << (x > y) << "\n"; 
+    return x > y;
+  }
+};
+
+template<class T>
+struct tracking_greater_equal: std::binary_function <T, T, bool> {
+  typedef bool result_type;
+
+  #if defined(__PATHSCALE__)
+  tracking_greater_equal (void) { }
+  ~tracking_greater_equal (void) { }
+  #endif
+
+  bool operator() (T const& x, T const& y) const {
+    std::cout << x << " >= " << y << " == " << (x >= y) << "\n"; 
+    return x >= y;
+  }
+};
+
+
+int main (void) {
+  #define IS_SORTED ::boost::detail::is_sorted
+  #define IS_SORTED_UNTIL ::boost::detail::is_sorted_until
+  using boost::array;
+  using boost::report_errors;
+
+  std::cout << std::boolalpha;
+
+  array<int, 10> a = { { 0, 1, 2,  3,  4, 5, 6,  7,  8,   9  } };
+  array<int, 10> b = { { 0, 1, 1,  2,  5, 8, 13, 34, 55,  89 } };
+  array<int, 10> c = { { 0, 1, -1, 2, -3, 5, -8, 13, -21, 34 } };
+
+  tracking_less<int> lt;
+  tracking_less_equal<int> lte;
+  tracking_greater<int> gt;
+  tracking_greater_equal<int> gte;
+
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end()),          a.end());
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end(), lt),      a.end());
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end(), lte),     a.end());
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(a.rbegin(), a.rend(), gt),   *a.rend());
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(a.rbegin(), a.rend(), gte),  *a.rend());
+  
+  BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end()),        true);
+  BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end(), lt),    true);
+  BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end(), lte),   true);
+  BOOST_TEST_EQ(IS_SORTED(a.rbegin(), a.rend(), gt),  true);
+  BOOST_TEST_EQ(IS_SORTED(a.rbegin(), a.rend(), gte), true);
+
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end()),          b.end());
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end(), lt),      b.end());
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end(), lte),     &b[2]);
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(b.rbegin(), b.rend(), gt),   *b.rend());
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(b.rbegin(), b.rend(), gte),  b[2]);
+  
+  BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end()),        true); 
+  BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end(), lt),    true); 
+  BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end(), lte),   false); 
+  BOOST_TEST_EQ(IS_SORTED(b.rbegin(), b.rend(), gt),  true);
+  BOOST_TEST_EQ(IS_SORTED(b.rbegin(), b.rend(), gte), false); 
+
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end()),          &c[2]);
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end(), lt),      &c[2]);
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end(), lte),     &c[2]);
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(c.rbegin(), c.rend(), gt),   c[7]);
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(c.rbegin(), c.rend(), gte),  c[7]);
+  
+  BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end()),        false);
+  BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end(), lt),    false);
+  BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end(), lte),   false);
+  BOOST_TEST_EQ(IS_SORTED(c.rbegin(), c.rend(), gt),  false);
+  BOOST_TEST_EQ(IS_SORTED(c.rbegin(), c.rend(), gte), false);
+
+  return report_errors();
+}
+