[Boost-commit] svn:boost r66043 - in sandbox/chrono/boost/system: . detail detail/inlined

Subject: [Boost-commit] svn:boost r66043 - in sandbox/chrono/boost/system: . detail detail/inlined
From: vicente.botet_at_[hidden]
Date: 2010-10-17 15:43:31

Author: viboes
Date: 2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
New Revision: 66043
URL: http://svn.boost.org/trac/boost/changeset/66043

Log:
Chrono: Implementation of header only Boost.System
Added:
   sandbox/chrono/boost/system/
   sandbox/chrono/boost/system/api_config.hpp   (contents, props changed)
   sandbox/chrono/boost/system/config.hpp   (contents, props changed)
   sandbox/chrono/boost/system/cygwin_error.hpp   (contents, props changed)
   sandbox/chrono/boost/system/detail/
   sandbox/chrono/boost/system/detail/inlined/
   sandbox/chrono/boost/system/detail/inlined/error_code.hpp   (contents, props changed)
   sandbox/chrono/boost/system/detail/inlined/local_free_on_destruction.hpp   (contents, props changed)
   sandbox/chrono/boost/system/error_code.hpp   (contents, props changed)
   sandbox/chrono/boost/system/linux_error.hpp   (contents, props changed)
   sandbox/chrono/boost/system/system_error.hpp   (contents, props changed)
   sandbox/chrono/boost/system/windows_error.hpp   (contents, props changed)

Added: sandbox/chrono/boost/system/api_config.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/system/api_config.hpp	2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
@@ -0,0 +1,48 @@
+//  boost/system/api_config.hpp  -------------------------------------------------------//
+
+//  Copyright Beman Dawes 2003, 2006, 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/system for documentation.
+
+//--------------------------------------------------------------------------------------//
+
+//  Boost.System calls operating system API functions to implement system error category
+//  functions. Usually there is no question as to which API is to be used.
+//
+//  In the case of MinGW or Cygwin/MinGW, however, both POSIX and Windows API's are
+//  available. Chaos ensues if other code thinks one is in use when Boost.System was
+//  actually built with the other. This header centralizes the API choice and prevents
+//  user definition of API macros, thus elminating the possibility of mismatches and the
+//  need to test configurations with little or no practical value.
+//
+
+//--------------------------------------------------------------------------------------//
+
+#ifndef BOOST_SYSTEM_API_CONFIG_HPP                  
+#define BOOST_SYSTEM_API_CONFIG_HPP
+
+# if defined(BOOST_SYSTEM_POSIX_API) || defined(BOOST_SYSTEM_WINDOWS_API)
+#   error user defined BOOST_SYSTEM_POSIX_API or BOOST_SYSTEM_WINDOWS_API not supported
+# endif
+
+//  BOOST_SYSTEM_POSIX_API or BOOST_SYSTEM_WINDOWS_API specify which API to use
+//    Cygwin/MinGW does not predefine _WIN32.
+//    Standalone MinGW and all other known Windows compilers do predefine _WIN32
+//    Compilers that predefine _WIN32 or __MINGW32__ do so for Windows 64-bit builds too.
+
+# if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32))
+#   define BOOST_SYSTEM_WINDOWS_API
+# else
+#   define BOOST_SYSTEM_POSIX_API 
+# endif
+
+# if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin
+#   define BOOST_WINDOWS_API
+# else
+#   define BOOST_POSIX_API 
+# endif
+                                     
+#endif  // BOOST_SYSTEM_API_CONFIG_HPP 

Added: sandbox/chrono/boost/system/config.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/system/config.hpp	2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
@@ -0,0 +1,61 @@
+//  boost/system/config.hpp  -----------------------------------------------------------//
+
+//  Copyright Beman Dawes 2003, 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 http://www.boost.org/libs/system for documentation.
+
+#ifndef BOOST_SYSTEM_CONFIG_HPP                  
+#define BOOST_SYSTEM_CONFIG_HPP
+
+#include <boost/config.hpp>
+#include <boost/system/api_config.hpp>  // for BOOST_SYSTEM_POSIX_API or BOOST_SYSTEM_WINDOWS_API
+
+#ifdef BOOST_SYSTEM_INLINED
+#define BOOST_SYSTEM_INLINE inline
+#define BOOST_SYSTEM_DECL
+
+#else
+#define BOOST_SYSTEM_INLINE
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+//  enable dynamic or static linking as requested --------------------------------------//
+
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
+# if defined(BOOST_SYSTEM_SOURCE)
+#   define BOOST_SYSTEM_DECL BOOST_SYMBOL_EXPORT
+# else 
+#   define BOOST_SYSTEM_DECL BOOST_SYMBOL_IMPORT
+# endif
+#else
+# define BOOST_SYSTEM_DECL
+#endif
+
+//  enable automatic library variant selection  ----------------------------------------// 
+
+#if !defined(BOOST_SYSTEM_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SYSTEM_NO_LIB)
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_system
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
+#  define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // BOOST_SYSTEM_INLINED
+
+#endif // BOOST_SYSTEM_CONFIG_HPP
+

Added: sandbox/chrono/boost/system/cygwin_error.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/system/cygwin_error.hpp	2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
@@ -0,0 +1,56 @@
+//  boost/system/cygwin_error.hpp  -------------------------------------------//
+
+//  Copyright Beman Dawes 2007
+
+//  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 library home page at http://www.boost.org/libs/system
+
+#ifndef BOOST_CYGWIN_ERROR_HPP
+#define BOOST_CYGWIN_ERROR_HPP
+
+//  This header is effectively empty for compiles on operating systems where
+//  it is not applicable.
+
+# ifdef __CYGWIN__
+
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+  namespace system
+  {
+    //  To construct an error_code after a API error:
+    //
+    //      error_code( errno, system_category() )
+
+    //  User code should use the portable "posix" enums for POSIX errors; this
+    //  allows such code to be portable to non-POSIX systems. For the non-POSIX
+    //  errno values that POSIX-based systems typically provide in addition to 
+    //  POSIX values, use the system specific enums below.
+
+   namespace cygwin_error
+    {
+      enum cygwin_errno
+      {
+        no_net = ENONET,
+        no_package = ENOPKG,
+        no_share = ENOSHARE
+      };
+    }  // namespace cygwin_error
+
+    template<> struct is_error_code_enum<cygwin_error::cygwin_errno>
+      { static const bool value = true; };
+
+    namespace cygwin_error
+    {
+      inline error_code make_error_code( cygwin_errno e )
+        { return error_code( e, system_category() ); }
+    }
+  }
+}
+
+#endif  // __CYGWIN__
+
+#endif  // BOOST_CYGWIN_ERROR_HPP

Added: sandbox/chrono/boost/system/detail/inlined/error_code.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/system/detail/inlined/error_code.hpp	2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
@@ -0,0 +1,427 @@
+//  error_code support implementation file  ----------------------------------//
+
+//  Copyright Beman Dawes 2002, 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 library home page at http://www.boost.org/libs/system
+
+//----------------------------------------------------------------------------//
+
+#ifndef BOOST_SYSTEM_DETAIL_INLINED_ERROR_CODE_HPP
+#define BOOST_SYSTEM_DETAIL_INLINED_ERROR_CODE_HPP
+
+#include <boost/config/warning_disable.hpp>
+
+#include <boost/system/config.hpp>
+#ifndef BOOST_SYSTEM_INLINED
+#include <boost/system/error_code.hpp>
+#endif
+#include <boost/cerrno.hpp>
+#include <vector>
+#include <cstdlib>
+#include <cassert>
+
+//using namespace boost::system;
+//using namespace boost::system::errc;
+
+#include <cstring> // for strerror/strerror_r
+
+# if defined( BOOST_SYSTEM_WINDOWS_API )
+#   include <boost/detail/win/system.hpp>
+#   include "local_free_on_destruction.hpp"
+#   ifndef ERROR_INCORRECT_SIZE
+#     define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
+#   endif
+# endif
+
+//----------------------------------------------------------------------------//
+
+namespace boost
+{
+namespace system
+{
+namespace system_detail
+{
+  //  standard error categories  ---------------------------------------------//
+
+  class generic_error_category : public error_category
+  {
+  public:
+    generic_error_category(){}
+    const char *   name() const;
+    std::string    message( int ev ) const;
+  };
+
+  class system_error_category : public error_category
+  {
+  public:
+    system_error_category(){}
+    const char *        name() const;
+    std::string         message( int ev ) const;
+    error_condition     default_error_condition( int ev ) const;
+  };
+
+  //  generic_error_category implementation  ---------------------------------//
+
+  const char * generic_error_category::name() const
+  {
+    return "generic";
+  }
+
+  std::string generic_error_category::message( int ev ) const
+  {
+    static std::string unknown_err( "Unknown error" );
+  // strerror_r is preferred because it is always thread safe,
+  // however, we fallback to strerror in certain cases because:
+  //   -- Windows doesn't provide strerror_r.
+  //   -- HP and Sundo provide strerror_r on newer systems, but there is
+  //      no way to tell if is available at runtime and in any case their
+  //      versions of strerror are thread safe anyhow.
+  //   -- Linux only sometimes provides strerror_r.
+  //   -- Tru64 provides strerror_r only when compiled -pthread.
+  //   -- VMS doesn't provide strerror_r, but on this platform, strerror is
+  //      thread safe.
+  # if defined(BOOST_SYSTEM_WINDOWS_API) || defined(__hpux) || defined(__sun)\
+     || (defined(__linux) && (!defined(__USE_XOPEN2K) || defined(BOOST_SYSTEM_USE_STRERROR)))\
+     || (defined(__osf__) && !defined(_REENTRANT))\
+     || (defined(__vms))\
+     || (defined(__QNXNTO__))
+      const char * c_str = std::strerror( ev );
+      return  c_str
+        ? std::string( c_str )
+        : unknown_err;
+  # else  // use strerror_r
+      char buf[64];
+      char * bp = buf;
+      std::size_t sz = sizeof(buf);
+  #  if defined(__CYGWIN__) || defined(__USE_GNU)
+      // Oddball version of strerror_r
+      const char * c_str = strerror_r( ev, bp, sz );
+      return  c_str
+        ? std::string( c_str )
+        : unknown_err;
+  #  else
+      // POSIX version of strerror_r
+      int result;
+      for (;;)
+      {
+        // strerror_r returns 0 on success, otherwise ERANGE if buffer too small,
+        // invalid_argument if ev not a valid error number
+  #  if defined (__sgi)
+        const char * c_str = strerror( ev );
+        result = 0;
+      return  c_str
+        ? std::string( c_str )
+        : unknown_err;
+  #  else
+        result = strerror_r( ev, bp, sz );
+  #  endif
+        if (result == 0 )
+          break;
+        else
+        {
+  #  if defined(__linux)
+          // Linux strerror_r returns -1 on error, with error number in errno
+          result = errno;
+  #  endif
+          if ( result !=  ERANGE ) break;
+          if ( sz > sizeof(buf) ) std::free( bp );
+          sz *= 2;
+          if ( (bp = static_cast<char*>(std::malloc( sz ))) == 0 )
+            return std::string( "ENOMEM" );
+        }
+      }
+      std::string msg;
+      try
+      {
+        msg = ( ( result == invalid_argument ) ? "Unknown error" : bp );
+      }
+
+#   ifndef BOOST_NO_EXCEPTIONS
+      // See ticket #2098
+      catch(...)
+      {
+        // just eat the exception
+      }
+#   endif
+
+      if ( sz > sizeof(buf) ) std::free( bp );
+      sz = 0;
+      return msg;
+  #  endif   // else POSIX version of strerror_r
+  # endif  // else use strerror_r
+  }
+  //  system_error_category implementation  --------------------------------// 
+
+  const char * system_error_category::name() const
+  {
+    return "system";
+  }
+
+  error_condition system_error_category::default_error_condition( int ev ) const
+  {
+    switch ( ev )
+    {
+    case 0: return make_error_condition( errc::success );
+# if defined(BOOST_SYSTEM_POSIX_API)
+    // POSIX-like O/S -> posix_errno decode table  ---------------------------//
+    case E2BIG: return make_error_condition( errc::argument_list_too_long );
+    case EACCES: return make_error_condition( errc::permission_denied );
+    case EADDRINUSE: return make_error_condition( errc::address_in_use );
+    case EADDRNOTAVAIL: return make_error_condition( errc::address_not_available );
+    case EAFNOSUPPORT: return make_error_condition( errc::address_family_not_supported );
+    case EAGAIN: return make_error_condition( errc::resource_unavailable_try_again );
+#   if EALREADY != EBUSY  //  EALREADY and EBUSY are the same on QNX Neutrino
+    case EALREADY: return make_error_condition( errc::connection_already_in_progress );
+#   endif
+    case EBADF: return make_error_condition( errc::bad_file_descriptor );
+    case EBADMSG: return make_error_condition( errc::bad_message );
+    case EBUSY: return make_error_condition( errc::device_or_resource_busy );
+    case ECANCELED: return make_error_condition( errc::operation_canceled );
+    case ECHILD: return make_error_condition( errc::no_child_process );
+    case ECONNABORTED: return make_error_condition( errc::connection_aborted );
+    case ECONNREFUSED: return make_error_condition( errc::connection_refused );
+    case ECONNRESET: return make_error_condition( errc::connection_reset );
+    case EDEADLK: return make_error_condition( errc::resource_deadlock_would_occur );
+    case EDESTADDRREQ: return make_error_condition( errc::destination_address_required );
+    case EDOM: return make_error_condition( errc::argument_out_of_domain );
+    case EEXIST: return make_error_condition( errc::file_exists );
+    case EFAULT: return make_error_condition( errc::bad_address );
+    case EFBIG: return make_error_condition( errc::file_too_large );
+    case EHOSTUNREACH: return make_error_condition( errc::host_unreachable );
+    case EIDRM: return make_error_condition( errc::identifier_removed );
+    case EILSEQ: return make_error_condition( errc::illegal_byte_sequence );
+    case EINPROGRESS: return make_error_condition( errc::operation_in_progress );
+    case EINTR: return make_error_condition( errc::interrupted );
+    case EINVAL: return make_error_condition( errc::invalid_argument );
+    case EIO: return make_error_condition( errc::io_error );
+    case EISCONN: return make_error_condition( errc::already_connected );
+    case EISDIR: return make_error_condition( errc::is_a_directory );
+    case ELOOP: return make_error_condition( errc::too_many_symbolic_link_levels );
+    case EMFILE: return make_error_condition( errc::too_many_files_open );
+    case EMLINK: return make_error_condition( errc::too_many_links );
+    case EMSGSIZE: return make_error_condition( errc::message_size );
+    case ENAMETOOLONG: return make_error_condition( errc::filename_too_long );
+    case ENETDOWN: return make_error_condition( errc::network_down );
+    case ENETRESET: return make_error_condition( errc::network_reset );
+    case ENETUNREACH: return make_error_condition( errc::network_unreachable );
+    case ENFILE: return make_error_condition( errc::too_many_files_open_in_system );
+    case ENOBUFS: return make_error_condition( errc::no_buffer_space );
+    case ENODATA: return make_error_condition( errc::no_message_available );
+    case ENODEV: return make_error_condition( errc::no_such_device );
+    case ENOENT: return make_error_condition( errc::no_such_file_or_directory );
+    case ENOEXEC: return make_error_condition( errc::executable_format_error );
+    case ENOLCK: return make_error_condition( errc::no_lock_available );
+    case ENOLINK: return make_error_condition( errc::no_link );
+    case ENOMEM: return make_error_condition( errc::not_enough_memory );
+    case ENOMSG: return make_error_condition( errc::no_message );
+    case ENOPROTOOPT: return make_error_condition( errc::no_protocol_option );
+    case ENOSPC: return make_error_condition( errc::no_space_on_device );
+    case ENOSR: return make_error_condition( errc::no_stream_resources );
+    case ENOSTR: return make_error_condition( errc::not_a_stream );
+    case ENOSYS: return make_error_condition( errc::function_not_supported );
+    case ENOTCONN: return make_error_condition( errc::not_connected );
+    case ENOTDIR: return make_error_condition( errc::not_a_directory );
+  # if ENOTEMPTY != EEXIST // AIX treats ENOTEMPTY and EEXIST as the same value
+    case ENOTEMPTY: return make_error_condition( errc::directory_not_empty );
+  # endif // ENOTEMPTY != EEXIST
+  # if ENOTRECOVERABLE != ECONNRESET // the same on some Broadcom chips 
+    case ENOTRECOVERABLE: return make_error_condition( errc::state_not_recoverable ); 
+  # endif // ENOTRECOVERABLE != ECONNRESET 
+    case ENOTSOCK: return make_error_condition( errc::not_a_socket );
+    case ENOTSUP: return make_error_condition( errc::not_supported );
+    case ENOTTY: return make_error_condition( errc::inappropriate_io_control_operation );
+    case ENXIO: return make_error_condition( errc::no_such_device_or_address );
+  # if EOPNOTSUPP != ENOTSUP
+    case EOPNOTSUPP: return make_error_condition( errc::operation_not_supported );
+  # endif // EOPNOTSUPP != ENOTSUP
+    case EOVERFLOW: return make_error_condition( errc::value_too_large );
+  # if EOWNERDEAD != ECONNABORTED // the same on some Broadcom chips 
+    case EOWNERDEAD: return make_error_condition( errc::owner_dead ); 
+  # endif // EOWNERDEAD != ECONNABORTED 
+    case EPERM: return make_error_condition( errc::operation_not_permitted );
+    case EPIPE: return make_error_condition( errc::broken_pipe );
+    case EPROTO: return make_error_condition( errc::protocol_error );
+    case EPROTONOSUPPORT: return make_error_condition( errc::protocol_not_supported );
+    case EPROTOTYPE: return make_error_condition( errc::wrong_protocol_type );
+    case ERANGE: return make_error_condition( errc::result_out_of_range );
+    case EROFS: return make_error_condition( errc::read_only_file_system );
+    case ESPIPE: return make_error_condition( errc::invalid_seek );
+    case ESRCH: return make_error_condition( errc::no_such_process );
+    case ETIME: return make_error_condition( errc::stream_timeout );
+    case ETIMEDOUT: return make_error_condition( errc::timed_out );
+    case ETXTBSY: return make_error_condition( errc::text_file_busy );
+  # if EAGAIN != EWOULDBLOCK
+    case EWOULDBLOCK: return make_error_condition( errc::operation_would_block );
+  # endif // EAGAIN != EWOULDBLOCK
+    case EXDEV: return make_error_condition( errc::cross_device_link );
+  #else
+    // Windows system -> posix_errno decode table  ---------------------------//
+    // see WinError.h comments for descriptions of errors
+    case ERROR_ACCESS_DENIED: return make_error_condition( errc::permission_denied );
+    case ERROR_ALREADY_EXISTS: return make_error_condition( errc::file_exists );
+    case ERROR_BAD_UNIT: return make_error_condition( errc::no_such_device );
+    case ERROR_BUFFER_OVERFLOW: return make_error_condition( errc::filename_too_long );
+    case ERROR_BUSY: return make_error_condition( errc::device_or_resource_busy );
+    case ERROR_BUSY_DRIVE: return make_error_condition( errc::device_or_resource_busy );
+    case ERROR_CANNOT_MAKE: return make_error_condition( errc::permission_denied );
+    case ERROR_CANTOPEN: return make_error_condition( errc::io_error );
+    case ERROR_CANTREAD: return make_error_condition( errc::io_error );
+    case ERROR_CANTWRITE: return make_error_condition( errc::io_error );
+    case ERROR_CURRENT_DIRECTORY: return make_error_condition( errc::permission_denied );
+    case ERROR_DEV_NOT_EXIST: return make_error_condition( errc::no_such_device );
+    case ERROR_DEVICE_IN_USE: return make_error_condition( errc::device_or_resource_busy );
+    case ERROR_DIR_NOT_EMPTY: return make_error_condition( errc::directory_not_empty );
+    case ERROR_DIRECTORY: return make_error_condition( errc::invalid_argument ); // WinError.h: "The directory name is invalid"
+    case ERROR_DISK_FULL: return make_error_condition( errc::no_space_on_device );
+    case ERROR_FILE_EXISTS: return make_error_condition( errc::file_exists );
+    case ERROR_FILE_NOT_FOUND: return make_error_condition( errc::no_such_file_or_directory );
+    case ERROR_HANDLE_DISK_FULL: return make_error_condition( errc::no_space_on_device );
+    case ERROR_INVALID_ACCESS: return make_error_condition( errc::permission_denied );
+    case ERROR_INVALID_DRIVE: return make_error_condition( errc::no_such_device );
+    case ERROR_INVALID_FUNCTION: return make_error_condition( errc::function_not_supported );
+    case ERROR_INVALID_HANDLE: return make_error_condition( errc::invalid_argument );
+    case ERROR_INVALID_NAME: return make_error_condition( errc::invalid_argument );
+    case ERROR_LOCK_VIOLATION: return make_error_condition( errc::no_lock_available );
+    case ERROR_LOCKED: return make_error_condition( errc::no_lock_available );
+    case ERROR_NEGATIVE_SEEK: return make_error_condition( errc::invalid_argument );
+    case ERROR_NOACCESS: return make_error_condition( errc::permission_denied );
+    case ERROR_NOT_ENOUGH_MEMORY: return make_error_condition( errc::not_enough_memory );
+    case ERROR_NOT_READY: return make_error_condition( errc::resource_unavailable_try_again );
+    case ERROR_NOT_SAME_DEVICE: return make_error_condition( errc::cross_device_link );
+    case ERROR_OPEN_FAILED: return make_error_condition( errc::io_error );
+    case ERROR_OPEN_FILES: return make_error_condition( errc::device_or_resource_busy );
+    case ERROR_OPERATION_ABORTED: return make_error_condition( errc::operation_canceled );
+    case ERROR_OUTOFMEMORY: return make_error_condition( errc::not_enough_memory );
+    case ERROR_PATH_NOT_FOUND: return make_error_condition( errc::no_such_file_or_directory );
+    case ERROR_READ_FAULT: return make_error_condition( errc::io_error );
+    case ERROR_RETRY: return make_error_condition( errc::resource_unavailable_try_again );
+    case ERROR_SEEK: return make_error_condition( errc::io_error );
+    case ERROR_SHARING_VIOLATION: return make_error_condition( errc::permission_denied );
+    case ERROR_TOO_MANY_OPEN_FILES: return make_error_condition( errc::too_many_files_open );
+    case ERROR_WRITE_FAULT: return make_error_condition( errc::io_error );
+    case ERROR_WRITE_PROTECT: return make_error_condition( errc::permission_denied );
+    case WSAEACCES: return make_error_condition( errc::permission_denied );
+    case WSAEADDRINUSE: return make_error_condition( errc::address_in_use );
+    case WSAEADDRNOTAVAIL: return make_error_condition( errc::address_not_available );
+    case WSAEAFNOSUPPORT: return make_error_condition( errc::address_family_not_supported );
+    case WSAEALREADY: return make_error_condition( errc::connection_already_in_progress );
+    case WSAEBADF: return make_error_condition( errc::bad_file_descriptor );
+    case WSAECONNABORTED: return make_error_condition( errc::connection_aborted );
+    case WSAECONNREFUSED: return make_error_condition( errc::connection_refused );
+    case WSAECONNRESET: return make_error_condition( errc::connection_reset );
+    case WSAEDESTADDRREQ: return make_error_condition( errc::destination_address_required );
+    case WSAEFAULT: return make_error_condition( errc::bad_address );
+    case WSAEHOSTUNREACH: return make_error_condition( errc::host_unreachable );
+    case WSAEINPROGRESS: return make_error_condition( errc::operation_in_progress );
+    case WSAEINTR: return make_error_condition( errc::interrupted );
+    case WSAEINVAL: return make_error_condition( errc::invalid_argument );
+    case WSAEISCONN: return make_error_condition( errc::already_connected );
+    case WSAEMFILE: return make_error_condition( errc::too_many_files_open );
+    case WSAEMSGSIZE: return make_error_condition( errc::message_size );
+    case WSAENAMETOOLONG: return make_error_condition( errc::filename_too_long );
+    case WSAENETDOWN: return make_error_condition( errc::network_down );
+    case WSAENETRESET: return make_error_condition( errc::network_reset );
+    case WSAENETUNREACH: return make_error_condition( errc::network_unreachable );
+    case WSAENOBUFS: return make_error_condition( errc::no_buffer_space );
+    case WSAENOPROTOOPT: return make_error_condition( errc::no_protocol_option );
+    case WSAENOTCONN: return make_error_condition( errc::not_connected );
+    case WSAENOTSOCK: return make_error_condition( errc::not_a_socket );
+    case WSAEOPNOTSUPP: return make_error_condition( errc::operation_not_supported );
+    case WSAEPROTONOSUPPORT: return make_error_condition( errc::protocol_not_supported );
+    case WSAEPROTOTYPE: return make_error_condition( errc::wrong_protocol_type );
+    case WSAETIMEDOUT: return make_error_condition( errc::timed_out );
+    case WSAEWOULDBLOCK: return make_error_condition( errc::operation_would_block );
+  #endif
+    default: return error_condition( ev, system_category() );
+    }
+  }
+
+# if !defined( BOOST_SYSTEM_WINDOWS_API )
+
+  std::string system_error_category::message( int ev ) const
+  {
+    return generic_category().message( ev );
+  }
+# else
+
+  std::string system_error_category::message( int ev ) const
+  {
+# ifndef BOOST_NO_ANSI_APIS  
+	boost::detail::win32::LPVOID_ lpMsgBuf = 0;
+	boost::detail::win32::DWORD_ retval = boost::detail::win32::FormatMessageA( 
+			boost::detail::win32::FORMAT_MESSAGE_ALLOCATE_BUFFER_ | 
+			boost::detail::win32::FORMAT_MESSAGE_FROM_SYSTEM_ | 
+			boost::detail::win32::FORMAT_MESSAGE_IGNORE_INSERTS_,
+        NULL,
+        ev,
+        boost::detail::win32::MAKELANGID_(boost::detail::win32::LANG_NEUTRAL_, boost::detail::win32::SUBLANG_DEFAULT_), // Default language
+        (boost::detail::win32::LPSTR_) &lpMsgBuf,
+        0,
+        NULL 
+    );
+    detail::local_free_on_destruction lfod(lpMsgBuf);
+    if (retval == 0)
+        return std::string("Unknown error");
+        
+    std::string str( static_cast<boost::detail::win32::LPCSTR_>(lpMsgBuf) );
+# else  // WinCE workaround
+    boost::detail::win32::LPVOID_ lpMsgBuf = 0;
+    boost::detail::win32::DWORD retval = boost::detail::win32::FormatMessageW( 
+    		boost::detail::win32::FORMAT_MESSAGE_ALLOCATE_BUFFER_ | 
+    		boost::detail::win32::FORMAT_MESSAGE_FROM_SYSTEM_ | 
+    		boost::detail::win32::FORMAT_MESSAGE_IGNORE_INSERTS_,
+        NULL,
+        ev,
+        boost::detail::win32::MAKELANGID_(boost::detail::win32::LANG_NEUTRAL_, boost::detail::win32::SUBLANG_DEFAULT_), // Default language
+        (boost::detail::win32::LPWSTR_) &lpMsgBuf,
+        0,
+        NULL 
+    );
+    detail::local_free_on_destruction lfod(lpMsgBuf);
+    if (retval == 0)
+        return std::string("Unknown error");
+    
+    int num_chars = (wcslen( static_cast<LPCWSTR>(lpMsgBuf) ) + 1) * 2;
+    boost::detail::win32::LPSTR_ narrow_buffer = (boost::detail::win32::LPSTR_)_alloca( num_chars );
+    if (boost::detail::win32::WideCharToMultiByte(CP_ACP, 0, static_cast<boost::detail::win32::LPCWSTR_>(lpMsgBuf), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
+        return std::string("Unknown error");
+
+    std::string str( narrow_buffer );
+# endif
+    while ( str.size()
+      && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
+        str.erase( str.size()-1 );
+    if ( str.size() && str[str.size()-1] == '.' ) 
+      { str.erase( str.size()-1 ); }
+    return str;
+  }
+# endif
+
+} 
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    BOOST_SYSTEM_DECL error_code throws; // "throw on error" special error_code;
+                                         //  note that it doesn't matter if this
+                                         //  isn't initialized before use since
+                                         //  the only use is to take its
+                                         //  address for comparison purposes
+# endif
+
+    BOOST_SYSTEM_DECL const error_category & system_category()
+    {
+      static const system_detail::system_error_category  system_category_const;
+      return system_category_const;
+    }
+
+    BOOST_SYSTEM_DECL const error_category & generic_category()
+    {
+      static const system_detail::generic_error_category generic_category_const;
+      return generic_category_const;
+    }
+
+  } // namespace system
+} // namespace boost
+#endif // BOOST_SYSTEM_DETAIL_INLINED_ERROR_CODE_HPP

Added: sandbox/chrono/boost/system/detail/inlined/local_free_on_destruction.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/system/detail/inlined/local_free_on_destruction.hpp	2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
@@ -0,0 +1,40 @@
+//  local_free_on_exit.hpp  ------------------------------------------------------------//
+
+//  Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//  Copyright (c) 2010 Beman Dawes
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  This is derived from boost/asio/detail/local_free_on_block_exit.hpp to avoid
+//  a dependency on asio. Thanks to Chris Kohlhoff for pointing it out.
+
+#ifndef BOOST_SYSTEM_DETAIL_INLINEDLOCAL_FREE_ON_EXIT_HPP
+#define BOOST_SYSTEM_DETAIL_INLINEDLOCAL_FREE_ON_EXIT_HPP
+
+namespace boost {
+namespace system {
+namespace detail {
+
+class local_free_on_destruction
+{
+public:
+  explicit local_free_on_destruction(void* p)
+    : p_(p) {}
+
+  ~local_free_on_destruction()
+  {
+    boost::detail::win32::LocalFree(p_);
+  }
+
+private:
+  void* p_;
+  local_free_on_destruction(const local_free_on_destruction&);  // = deleted
+  local_free_on_destruction& operator=(const local_free_on_destruction&);  // = deleted
+};
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif  // BOOST_SYSTEM_DETAIL_INLINEDLOCAL_FREE_ON_EXIT_HPP

Added: sandbox/chrono/boost/system/error_code.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/system/error_code.hpp	2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
@@ -0,0 +1,523 @@
+//  boost/system/error_code.hpp  ---------------------------------------------//
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+
+//  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 library home page at http://www.boost.org/libs/system
+
+#ifndef BOOST_ERROR_CODE_HPP
+#define BOOST_ERROR_CODE_HPP
+
+#include <boost/system/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/assert.hpp>
+#include <boost/operators.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <ostream>
+#include <string>
+#include <stdexcept>
+#include <functional>
+
+// TODO: undef these macros if not already defined
+#include <boost/cerrno.hpp> 
+
+#if !defined(BOOST_SYSTEM_POSIX_API) && !defined(BOOST_SYSTEM_WINDOWS_API)
+#  error BOOST_SYSTEM_POSIX_API or BOOST_SYSTEM_WINDOWS_API must be defined
+#endif
+
+#include <boost/config/abi_prefix.hpp> // must be the last #include
+
+namespace boost
+{
+  namespace system
+  {
+
+    class error_code;
+    class error_condition;
+
+    //  "Concept" helpers  ---------------------------------------------------//
+
+    template< class T >
+    struct is_error_code_enum { static const bool value = false; };
+
+    template< class T >
+    struct is_error_condition_enum { static const bool value = false; };
+
+    //  generic error_conditions  --------------------------------------------//
+
+    namespace errc
+    {
+      enum errc_t
+      {
+        success = 0,
+        address_family_not_supported = EAFNOSUPPORT,
+        address_in_use = EADDRINUSE,
+        address_not_available = EADDRNOTAVAIL,
+        already_connected = EISCONN,
+        argument_list_too_long = E2BIG,
+        argument_out_of_domain = EDOM,
+        bad_address = EFAULT,
+        bad_file_descriptor = EBADF,
+        bad_message = EBADMSG,
+        broken_pipe = EPIPE,
+        connection_aborted = ECONNABORTED,
+        connection_already_in_progress = EALREADY,
+        connection_refused = ECONNREFUSED,
+        connection_reset = ECONNRESET,
+        cross_device_link = EXDEV,
+        destination_address_required = EDESTADDRREQ,
+        device_or_resource_busy = EBUSY,
+        directory_not_empty = ENOTEMPTY,
+        executable_format_error = ENOEXEC,
+        file_exists = EEXIST,
+        file_too_large = EFBIG,
+        filename_too_long = ENAMETOOLONG,
+        function_not_supported = ENOSYS,
+        host_unreachable = EHOSTUNREACH,
+        identifier_removed = EIDRM,
+        illegal_byte_sequence = EILSEQ,
+        inappropriate_io_control_operation = ENOTTY,
+        interrupted = EINTR,
+        invalid_argument = EINVAL,
+        invalid_seek = ESPIPE,
+        io_error = EIO,
+        is_a_directory = EISDIR,
+        message_size = EMSGSIZE,
+        network_down = ENETDOWN,
+        network_reset = ENETRESET,
+        network_unreachable = ENETUNREACH,
+        no_buffer_space = ENOBUFS,
+        no_child_process = ECHILD,
+        no_link = ENOLINK,
+        no_lock_available = ENOLCK,
+        no_message_available = ENODATA,
+        no_message = ENOMSG,
+        no_protocol_option = ENOPROTOOPT,
+        no_space_on_device = ENOSPC,
+        no_stream_resources = ENOSR,
+        no_such_device_or_address = ENXIO,
+        no_such_device = ENODEV,
+        no_such_file_or_directory = ENOENT,
+        no_such_process = ESRCH,
+        not_a_directory = ENOTDIR,
+        not_a_socket = ENOTSOCK,
+        not_a_stream = ENOSTR,
+        not_connected = ENOTCONN,
+        not_enough_memory = ENOMEM,
+        not_supported = ENOTSUP,
+        operation_canceled = ECANCELED,
+        operation_in_progress = EINPROGRESS,
+        operation_not_permitted = EPERM,
+        operation_not_supported = EOPNOTSUPP,
+        operation_would_block = EWOULDBLOCK,
+        owner_dead = EOWNERDEAD,
+        permission_denied = EACCES,
+        protocol_error = EPROTO,
+        protocol_not_supported = EPROTONOSUPPORT,
+        read_only_file_system = EROFS,
+        resource_deadlock_would_occur = EDEADLK,
+        resource_unavailable_try_again = EAGAIN,
+        result_out_of_range = ERANGE,
+        state_not_recoverable = ENOTRECOVERABLE,
+        stream_timeout = ETIME,
+        text_file_busy = ETXTBSY,
+        timed_out = ETIMEDOUT,
+        too_many_files_open_in_system = ENFILE,
+        too_many_files_open = EMFILE,
+        too_many_links = EMLINK,
+        too_many_symbolic_link_levels = ELOOP,
+        value_too_large = EOVERFLOW,
+        wrong_protocol_type = EPROTOTYPE
+      };
+
+    } // namespace errc
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    namespace posix = errc;
+    namespace posix_error = errc;
+# endif
+
+    template<> struct is_error_condition_enum<errc::errc_t>
+      { static const bool value = true; };
+
+
+    //  ----------------------------------------------------------------------//
+
+    //  Operating system specific interfaces  --------------------------------//
+
+
+    //  The interface is divided into general and system-specific portions to
+    //  meet these requirements:
+    //
+    //  * Code calling an operating system API can create an error_code with
+    //    a single category (system_category), even for POSIX-like operating
+    //    systems that return some POSIX errno values and some native errno
+    //    values. This code should not have to pay the cost of distinguishing
+    //    between categories, since it is not yet known if that is needed.
+    //
+    //  * Users wishing to write system-specific code should be given enums for
+    //    at least the common error cases.
+    //
+    //  * System specific code should fail at compile time if moved to another
+    //    operating system.
+
+    //  The system specific portions of the interface are located in headers
+    //  with names reflecting the operating system. For example,
+    //
+    //       <boost/system/cygwin_error.hpp>
+    //       <boost/system/linux_error.hpp>
+    //       <boost/system/windows_error.hpp>
+    //
+    //  These headers are effectively empty for compiles on operating systems
+    //  where they are not applicable.
+
+    //  ----------------------------------------------------------------------//
+
+    //  class error_category  ------------------------------------------------//
+
+    class error_category : public noncopyable
+    {
+    public:
+      virtual ~error_category(){}
+
+      virtual const char *     name() const = 0;
+      virtual std::string      message( int ev ) const = 0;
+      virtual error_condition  default_error_condition( int ev ) const;
+      virtual bool             equivalent( int code, 
+                                           const error_condition & condition ) const;
+      virtual bool             equivalent( const error_code & code,
+                                           int condition ) const;
+
+      bool operator==(const error_category & rhs) const { return this == &rhs; }
+      bool operator!=(const error_category & rhs) const { return this != &rhs; }
+      bool operator<( const error_category & rhs ) const
+      {
+        return std::less<const error_category*>()( this, &rhs );
+      }
+    };
+
+    //  predefined error categories  -----------------------------------------//
+
+    BOOST_SYSTEM_DECL BOOST_SYSTEM_INLINE const error_category &  system_category();
+    BOOST_SYSTEM_DECL BOOST_SYSTEM_INLINE const error_category &  generic_category();
+
+    //  deprecated synonyms --------------------------------------------------//
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    inline const error_category &  get_system_category() { return system_category(); }
+    inline const error_category &  get_generic_category() { return generic_category(); }
+    inline const error_category &  get_posix_category() { return generic_category(); }
+    static const error_category &  posix_category = generic_category();
+    static const error_category &  errno_ecat     = generic_category();
+    static const error_category &  native_ecat    = system_category();
+# endif
+
+    //  class error_condition  -----------------------------------------------//
+
+    //  error_conditions are portable, error_codes are system or library specific
+
+    class error_condition
+    {
+    public:
+
+      // constructors:
+      error_condition() : m_val(0), m_cat(&generic_category()) {}
+      error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
+
+      template <class ErrorConditionEnum>
+        error_condition(ErrorConditionEnum e,
+          typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0)
+      {
+        *this = make_error_condition(e);
+      }
+
+      // modifiers:
+
+      void assign( int val, const error_category & cat )
+      { 
+        m_val = val;
+        m_cat = &cat;
+      }
+                                             
+      template<typename ErrorConditionEnum>
+        typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type &
+          operator=( ErrorConditionEnum val )
+      { 
+        *this = make_error_condition(val);
+        return *this;
+      }
+
+      void clear()
+      {
+        m_val = 0;
+        m_cat = &generic_category();
+      }
+
+      // observers:
+      int                     value() const    { return m_val; }
+      const error_category &  category() const { return *m_cat; }
+      std::string             message() const  { return m_cat->message(value()); }
+
+      typedef void (*unspecified_bool_type)();
+      static void unspecified_bool_true() {}
+
+      operator unspecified_bool_type() const  // true if error
+      { 
+        return m_val == 0 ? 0 : unspecified_bool_true;
+      }
+
+      bool operator!() const  // true if no error
+      {
+        return m_val == 0;
+      }
+
+      // relationals:
+      //  the more symmetrical non-member syntax allows enum
+      //  conversions work for both rhs and lhs.
+      inline friend bool operator==( const error_condition & lhs,
+                                     const error_condition & rhs )
+      {
+        return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
+      }                  
+
+      inline friend bool operator<( const error_condition & lhs,
+                                    const error_condition & rhs )
+        //  the more symmetrical non-member syntax allows enum
+        //  conversions work for both rhs and lhs.
+      {
+        return lhs.m_cat < rhs.m_cat
+          || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
+      }
+
+    private:
+      int                     m_val;
+      const error_category *  m_cat;
+
+    };
+
+    //  class error_code  ----------------------------------------------------//
+
+    //  We want error_code to be a value type that can be copied without slicing
+    //  and without requiring heap allocation, but we also want it to have
+    //  polymorphic behavior based on the error category. This is achieved by
+    //  abstract base class error_category supplying the polymorphic behavior,
+    //  and error_code containing a pointer to an object of a type derived
+    //  from error_category.
+    class error_code
+    {
+    public:
+
+      // constructors:
+      error_code() : m_val(0), m_cat(&system_category()) {}
+      error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
+
+      template <class ErrorCodeEnum>
+        error_code(ErrorCodeEnum e,
+          typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0)
+      {
+        *this = make_error_code(e);
+      }
+
+      // modifiers:
+      void assign( int val, const error_category & cat )
+      { 
+        m_val = val;
+        m_cat = &cat;
+      }
+                                             
+      template<typename ErrorCodeEnum>
+        typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
+          operator=( ErrorCodeEnum val )
+      { 
+        *this = make_error_code(val);
+        return *this;
+      }
+
+      void clear()
+      {
+        m_val = 0;
+        m_cat = &system_category();
+      }
+
+      // observers:
+      int                     value() const    { return m_val; }
+      const error_category &  category() const { return *m_cat; }
+      error_condition         default_error_condition() const  { return m_cat->default_error_condition(value()); }
+      std::string             message() const  { return m_cat->message(value()); }
+
+      typedef void (*unspecified_bool_type)();
+      static void unspecified_bool_true() {}
+
+      operator unspecified_bool_type() const  // true if error
+      { 
+        return m_val == 0 ? 0 : unspecified_bool_true;
+      }
+
+      bool operator!() const  // true if no error
+      {
+        return m_val == 0;
+      }
+
+      // relationals:
+      inline friend bool operator==( const error_code & lhs,
+                                     const error_code & rhs )
+        //  the more symmetrical non-member syntax allows enum
+        //  conversions work for both rhs and lhs.
+      {
+        return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
+      }
+
+      inline friend bool operator<( const error_code & lhs,
+                                    const error_code & rhs )
+        //  the more symmetrical non-member syntax allows enum
+        //  conversions work for both rhs and lhs.
+      {
+        return lhs.m_cat < rhs.m_cat
+          || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
+      }
+                  
+      private:
+      int                     m_val;
+      const error_category *  m_cat;
+
+    };
+
+    //  predefined error_code object used as "throw on error" tag
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    BOOST_SYSTEM_DECL extern error_code throws;
+# endif
+
+    //  Moving from a "throws" object to a "throws" function without breaking
+    //  existing code is a bit of a problem. The workaround is to place the
+    //  "throws" function in namespace boost rather than namespace boost::system.
+
+  }  // namespace system
+
+  namespace detail { inline system::error_code * throws() { return 0; } }
+    //  Misuse of the error_code object is turned into a noisy failure by
+    //  poisoning the reference. This particular implementation doesn't
+    //  produce warnings or errors from popular compilers, is very efficient
+    //  (as determined by inspecting generated code), and does not suffer
+    //  from order of initialization problems. In practice, it also seems
+    //  cause user function error handling implementation errors to be detected
+    //  very early in the development cycle.
+
+  inline system::error_code & throws()
+    { return *detail::throws(); }
+
+  namespace system
+  {
+    //  non-member functions  ------------------------------------------------//
+
+    inline bool operator!=( const error_code & lhs,
+                            const error_code & rhs )
+    {
+      return !(lhs == rhs);
+    }
+
+    inline bool operator!=( const error_condition & lhs,
+                            const error_condition & rhs )
+    {
+      return !(lhs == rhs);
+    }
+
+    inline bool operator==( const error_code & code,
+                            const error_condition & condition )
+    {
+      return code.category().equivalent( code.value(), condition )
+        || condition.category().equivalent( code, condition.value() );
+    }
+                
+    inline bool operator!=( const error_code & lhs,
+                            const error_condition & rhs )
+    {
+      return !(lhs == rhs);
+    }
+                
+    inline bool operator==( const error_condition & condition,
+                            const error_code & code )
+    {
+      return condition.category().equivalent( code, condition.value() )
+        || code.category().equivalent( code.value(), condition );
+    }
+                
+    inline bool operator!=( const error_condition & lhs,
+                            const error_code & rhs )
+    {
+      return !(lhs == rhs);
+    }
+                  
+    // TODO: both of these may move elsewhere, but the LWG hasn't spoken yet.
+
+    template <class charT, class traits>
+    inline std::basic_ostream<charT,traits>&
+      operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
+    {
+      os << ec.category().name() << ':' << ec.value();
+      return os;
+    }
+
+    inline std::size_t hash_value( const error_code & ec )
+    {
+      return static_cast<std::size_t>(ec.value())
+        + reinterpret_cast<std::size_t>(&ec.category());
+    }
+
+    //  make_* functions for errc::errc_t  -----------------------------//
+
+    namespace errc
+    {
+      //  explicit conversion:
+      inline error_code make_error_code( errc_t e )
+        { return error_code( e, generic_category() ); }
+
+      //  implicit conversion:
+      inline error_condition make_error_condition( errc_t e )
+        { return error_condition( e, generic_category() ); }
+    }
+
+    //  error_category default implementation  -------------------------------//
+
+    inline error_condition error_category::default_error_condition( int ev ) const
+    { 
+      return error_condition( ev, *this );
+    }
+
+    inline bool error_category::equivalent( int code,
+      const error_condition & condition ) const
+    {
+      return default_error_condition( code ) == condition;
+    }
+
+    inline bool error_category::equivalent( const error_code & code,
+      int condition ) const
+    {
+      return *this == code.category() && code.value() == condition;
+    }
+
+  } // namespace system
+} // namespace boost
+
+//#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+//
+# ifdef BOOST_ERROR_CODE_HEADER_ONLY
+#  ifndef BOOST_SYSTEM_INLINED
+#   define BOOST_SYSTEM_INLINED
+#  endif
+//#   include <boost/../libs/system/src/error_code.cpp>
+# endif
+
+#ifndef BOOST_SYSTEM_INLINED
+#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+#else
+#include <boost/system/detail/inlined/error_code.hpp> 
+#endif
+
+
+#endif // BOOST_ERROR_CODE_HPP
+
+

Added: sandbox/chrono/boost/system/linux_error.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/system/linux_error.hpp	2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
@@ -0,0 +1,110 @@
+//  boost/system/linux_error.hpp  -------------------------------------------//
+
+//  Copyright Beman Dawes 2007
+
+//  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 library home page at http://www.boost.org/libs/system
+
+#ifndef BOOST_LINUX_ERROR_HPP
+#define BOOST_LINUX_ERROR_HPP
+
+//  This header is effectively empty for compiles on operating systems where
+//  it is not applicable.
+
+#if defined(linux) || defined(__linux) || defined(__linux__)
+
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+  namespace system
+  {
+    //  To construct an error_code after a API error:
+    //
+    //      error_code( errno, system_category() )
+
+    //  User code should use the portable "posix" enums for POSIX errors; this
+    //  allows such code to be portable to non-POSIX systems. For the non-POSIX
+    //  errno values that POSIX-based systems typically provide in addition to 
+    //  POSIX values, use the system specific enums below.
+
+    namespace linux_error
+    {
+      enum linux_errno
+      {
+        advertise_error = EADV,
+        bad_exchange = EBADE,
+        bad_file_number = EBADFD,
+        bad_font_format = EBFONT,
+        bad_request_code = EBADRQC,
+        bad_request_descriptor = EBADR,
+        bad_slot = EBADSLT,
+        channel_range = ECHRNG,
+        communication_error = ECOMM,
+        dot_dot_error = EDOTDOT,
+        exchange_full = EXFULL,
+        host_down = EHOSTDOWN,
+        is_named_file_type= EISNAM,
+        key_expired = EKEYEXPIRED,
+        key_rejected = EKEYREJECTED,
+        key_revoked = EKEYREVOKED,
+        level2_halt= EL2HLT,
+        level2_no_syncronized= EL2NSYNC,
+        level3_halt = EL3HLT,
+        level3_reset = EL3RST,
+        link_range = ELNRNG,
+        medium_type = EMEDIUMTYPE,
+        no_anode= ENOANO,
+        no_block_device = ENOTBLK,
+        no_csi = ENOCSI,
+        no_key = ENOKEY,
+        no_medium = ENOMEDIUM,
+        no_network = ENONET,
+        no_package = ENOPKG,
+        not_avail = ENAVAIL,
+        not_named_file_type= ENOTNAM,
+        not_recoverable = ENOTRECOVERABLE,
+        not_unique = ENOTUNIQ,
+        owner_dead = EOWNERDEAD,
+        protocol_no_supported = EPFNOSUPPORT,
+        remote_address_changed = EREMCHG,
+        remote_io_error = EREMOTEIO,
+        remote_object = EREMOTE,
+        restart_needed = ERESTART,
+        shared_library_access = ELIBACC,
+        shared_library_bad = ELIBBAD,
+        shared_library_execute = ELIBEXEC,
+        shared_library_max_ = ELIBMAX,
+        shared_library_section= ELIBSCN,
+        shutdown = ESHUTDOWN,
+        socket_type_not_supported = ESOCKTNOSUPPORT,
+        srmount_error = ESRMNT,
+        stream_pipe_error = ESTRPIPE,
+        too_many_references = ETOOMANYREFS,
+        too_many_users = EUSERS,
+        unattached = EUNATCH,
+        unclean = EUCLEAN
+      };
+    }  // namespace linux_error
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    namespace Linux = linux_error;
+# endif
+
+    template<> struct is_error_code_enum<linux_error::linux_errno>
+      { static const bool value = true; };
+
+    namespace linux_error
+    {
+      inline error_code make_error_code( linux_errno e )
+        { return error_code( e, system_category() ); }
+    }
+
+  }  // namespace system
+}  // namespace boost 
+
+#endif  // Linux
+
+#endif  // BOOST_LINUX_ERROR_HPP

Added: sandbox/chrono/boost/system/system_error.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/system/system_error.hpp	2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
@@ -0,0 +1,80 @@
+//  Boost system_error.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)
+
+#ifndef BOOST_SYSTEM_ERROR_HPP
+#define BOOST_SYSTEM_ERROR_HPP
+
+#include <string>
+#include <stdexcept>
+#include <cassert>
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+  namespace system
+  {
+    //  class system_error  ------------------------------------------------------------//
+
+    class BOOST_SYMBOL_VISIBLE system_error : public std::runtime_error
+    // BOOST_SYMBOL_VISIBLE is needed by GCC to ensure system_error thrown from a shared
+    // library can be caught. See svn.boost.org/trac/boost/ticket/3697 
+    {
+    public:
+      system_error( error_code ec )
+          : std::runtime_error(""), m_error_code(ec) {}
+
+      system_error( error_code ec, const std::string & what_arg )
+          : std::runtime_error(what_arg), m_error_code(ec) {}
+
+      system_error( error_code ec, const char* what_arg )
+          : std::runtime_error(what_arg), m_error_code(ec) {}
+
+      system_error( int ev, const error_category & ecat )
+          : std::runtime_error(""), m_error_code(ev,ecat) {}
+
+      system_error( int ev, const error_category & ecat,
+        const std::string & what_arg )
+          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
+
+      system_error( int ev, const error_category & ecat,
+        const char * what_arg )
+          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
+
+      virtual ~system_error() throw() {}
+
+      const error_code &  code() const throw() { return m_error_code; }
+      const char *        what() const throw();
+
+    private:
+      error_code           m_error_code;
+      mutable std::string  m_what;
+    };
+
+    //  implementation  ------------------------------------------------------//
+
+    inline const char * system_error::what() const throw()
+    // see http://www.boost.org/more/error_handling.html for lazy build rationale
+    {
+      if ( m_what.empty() )
+      {
+        try
+        {
+          m_what = this->std::runtime_error::what();
+          if ( !m_what.empty() ) m_what += ": ";
+          m_what += m_error_code.message();
+        }
+        catch (...) { return std::runtime_error::what(); }
+      }
+      return m_what.c_str();
+    }
+
+  } // namespace system
+} // namespace boost
+
+#endif // BOOST_SYSTEM_ERROR_HPP
+
+

Added: sandbox/chrono/boost/system/windows_error.hpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/boost/system/windows_error.hpp	2010-10-17 15:43:29 EDT (Sun, 17 Oct 2010)
@@ -0,0 +1,118 @@
+//  boost/system/windows_error.hpp  ------------------------------------------//
+
+//  Copyright Beman Dawes 2007
+
+//  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 library home page at http://www.boost.org/libs/system
+
+#ifndef BOOST_WINDOWS_ERROR_HPP
+#define BOOST_WINDOWS_ERROR_HPP
+
+//  This header is effectively empty for compiles on operating systems where
+//  it is not applicable.
+
+#include <boost/system/config.hpp>
+
+#ifdef BOOST_SYSTEM_WINDOWS_API
+
+#include <boost/system/error_code.hpp>
+#include <winerror.h>
+
+namespace boost
+{
+  namespace system
+  {
+
+    //  Microsoft Windows  ---------------------------------------------------//
+
+    //  To construct an error_code after a API error:
+    //
+    //      error_code( ::GetLastError(), system_category() )
+
+    namespace windows_error
+    {
+      enum windows_error_code
+      {
+        success = 0,
+        // These names and values are based on Windows winerror.h
+        invalid_function = ERROR_INVALID_FUNCTION,
+        file_not_found = ERROR_FILE_NOT_FOUND,
+        path_not_found = ERROR_PATH_NOT_FOUND,
+        too_many_open_files = ERROR_TOO_MANY_OPEN_FILES,
+        access_denied = ERROR_ACCESS_DENIED,
+        invalid_handle = ERROR_INVALID_HANDLE,
+        arena_trashed = ERROR_ARENA_TRASHED,
+        not_enough_memory = ERROR_NOT_ENOUGH_MEMORY,
+        invalid_block = ERROR_INVALID_BLOCK,
+        bad_environment = ERROR_BAD_ENVIRONMENT,
+        bad_format = ERROR_BAD_FORMAT,
+        invalid_access = ERROR_INVALID_ACCESS,
+        outofmemory = ERROR_OUTOFMEMORY,
+        invalid_drive = ERROR_INVALID_DRIVE,
+        current_directory = ERROR_CURRENT_DIRECTORY,
+        not_same_device = ERROR_NOT_SAME_DEVICE,
+        no_more_files = ERROR_NO_MORE_FILES,
+        write_protect = ERROR_WRITE_PROTECT,
+        bad_unit = ERROR_BAD_UNIT,
+        not_ready = ERROR_NOT_READY,
+        bad_command = ERROR_BAD_COMMAND,
+        crc = ERROR_CRC,
+        bad_length = ERROR_BAD_LENGTH,
+        seek = ERROR_SEEK,
+        not_dos_disk = ERROR_NOT_DOS_DISK,
+        sector_not_found = ERROR_SECTOR_NOT_FOUND,
+        out_of_paper = ERROR_OUT_OF_PAPER,
+        write_fault = ERROR_WRITE_FAULT,
+        read_fault = ERROR_READ_FAULT,
+        gen_failure = ERROR_GEN_FAILURE,
+        sharing_violation = ERROR_SHARING_VIOLATION,
+        lock_violation = ERROR_LOCK_VIOLATION,
+        wrong_disk = ERROR_WRONG_DISK,
+        sharing_buffer_exceeded = ERROR_SHARING_BUFFER_EXCEEDED,
+        handle_eof = ERROR_HANDLE_EOF,
+        handle_disk_full= ERROR_HANDLE_DISK_FULL,
+        rem_not_list = ERROR_REM_NOT_LIST,
+        dup_name = ERROR_DUP_NAME,
+        bad_net_path = ERROR_BAD_NETPATH,
+        network_busy = ERROR_NETWORK_BUSY,
+        // ...
+        file_exists = ERROR_FILE_EXISTS,
+        cannot_make = ERROR_CANNOT_MAKE,
+        // ...
+        broken_pipe = ERROR_BROKEN_PIPE,
+        open_failed = ERROR_OPEN_FAILED,
+        buffer_overflow = ERROR_BUFFER_OVERFLOW,
+        disk_full= ERROR_DISK_FULL,
+        // ...
+        lock_failed = ERROR_LOCK_FAILED,
+        busy = ERROR_BUSY,
+        cancel_violation = ERROR_CANCEL_VIOLATION,
+        already_exists = ERROR_ALREADY_EXISTS
+        // ...
+
+        // TODO: add more Windows errors
+      };
+
+    }  // namespace windows
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    namespace windows = windows_error;
+# endif
+
+    template<> struct is_error_code_enum<windows_error::windows_error_code>
+      { static const bool value = true; };
+
+    namespace windows_error
+    {
+      inline error_code make_error_code( windows_error_code e )
+        { return error_code( e, system_category() ); }
+    }
+
+  }  // namespace system
+}  // namespace boost
+
+#endif  // BOOST_SYSTEM_WINDOWS_API
+
+#endif  // BOOST_WINDOWS_ERROR_HPP