early-access version 3088

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/chrono.hpp

@@ -0,0 +1,46 @@
+//  chrono.cpp  --------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2008
+//  Copyright Vicente J. Botet Escriba 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_CHRONO_DETAIL_INLINED_CHRONO_HPP
+#define BOOST_CHRONO_DETAIL_INLINED_CHRONO_HPP
+
+#include <boost/version.hpp>
+#include <boost/chrono/chrono.hpp>
+#if defined BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING
+#include <boost/system/system_error.hpp>
+#endif
+#include <boost/throw_exception.hpp>
+#include <boost/chrono/detail/system.hpp>
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                     Platform-specific Implementations                      //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+//----------------------------------------------------------------------------//
+//                                Windows                                     //
+//----------------------------------------------------------------------------//
+#if defined(BOOST_CHRONO_WINDOWS_API)
+#include <boost/chrono/detail/inlined/win/chrono.hpp>
+
+//----------------------------------------------------------------------------//
+//                                 Mac                                        //
+//----------------------------------------------------------------------------//
+#elif defined(BOOST_CHRONO_MAC_API)
+#include <boost/chrono/detail/inlined/mac/chrono.hpp>
+
+//----------------------------------------------------------------------------//
+//                                POSIX                                     //
+//----------------------------------------------------------------------------//
+#elif defined(BOOST_CHRONO_POSIX_API)
+#include <boost/chrono/detail/inlined/posix/chrono.hpp>
+
+#endif  // POSIX
+
+#endif

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/mac/chrono.hpp

@@ -0,0 +1,242 @@
+//  mac/chrono.cpp  --------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2008
+//  Copyright 2009-2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+//----------------------------------------------------------------------------//
+//                                 Mac                                        //
+//----------------------------------------------------------------------------//
+
+#include <sys/time.h> //for gettimeofday and timeval
+#include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
+#include <boost/assert.hpp>
+
+namespace boost
+{
+namespace chrono
+{
+
+// system_clock
+
+// gettimeofday is the most precise "system time" available on this platform.
+// It returns the number of microseconds since New Years 1970 in a struct called timeval
+// which has a field for seconds and a field for microseconds.
+//    Fill in the timeval and then convert that to the time_point
+system_clock::time_point
+system_clock::now() BOOST_NOEXCEPT
+{
+    timeval tv;
+    gettimeofday(&tv, 0);
+    return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+system_clock::time_point
+system_clock::now(system::error_code & ec)
+{
+    timeval tv;
+    gettimeofday(&tv, 0);
+    if (!::boost::chrono::is_throws(ec))
+    {
+        ec.clear();
+    }
+    return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
+}
+#endif
+// Take advantage of the fact that on this platform time_t is nothing but
+//    an integral count of seconds since New Years 1970 (same epoch as timeval).
+//    Just get the duration out of the time_point and truncate it to seconds.
+time_t
+system_clock::to_time_t(const time_point& t) BOOST_NOEXCEPT
+{
+    return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
+}
+
+// Just turn the time_t into a count of seconds and construct a time_point with it.
+system_clock::time_point
+system_clock::from_time_t(time_t t) BOOST_NOEXCEPT
+{
+    return system_clock::time_point(seconds(t));
+}
+
+namespace chrono_detail
+{
+
+// steady_clock
+
+// Note, in this implementation steady_clock and high_resolution_clock
+//   are the same clock.  They are both based on mach_absolute_time().
+//   mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of
+//   nanoseconds since the computer booted up.  MachInfo.numer and MachInfo.denom
+//   are run time constants supplied by the OS.  This clock has no relationship
+//   to the Gregorian calendar.  It's main use is as a high resolution timer.
+
+// MachInfo.numer / MachInfo.denom is often 1 on the latest equipment.  Specialize
+//   for that case as an optimization.
+BOOST_CHRONO_STATIC
+steady_clock::rep
+steady_simplified()
+{
+    return mach_absolute_time();
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+BOOST_CHRONO_STATIC
+steady_clock::rep
+steady_simplified_ec(system::error_code & ec)
+{
+    if (!::boost::chrono::is_throws(ec))
+    {
+        ec.clear();
+    }
+    return mach_absolute_time();
+}
+#endif
+
+BOOST_CHRONO_STATIC
+double
+compute_steady_factor(kern_return_t& err)
+{
+    mach_timebase_info_data_t MachInfo;
+    err = mach_timebase_info(&MachInfo);
+    if ( err != 0  ) {
+        return 0;
+    }
+    return static_cast<double>(MachInfo.numer) / MachInfo.denom;
+}
+
+BOOST_CHRONO_STATIC
+steady_clock::rep
+steady_full()
+{
+    kern_return_t err;
+    const double factor = chrono_detail::compute_steady_factor(err);
+    if (err != 0)
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+    }
+    return static_cast<steady_clock::rep>(mach_absolute_time() * factor);
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+BOOST_CHRONO_STATIC
+steady_clock::rep
+steady_full_ec(system::error_code & ec)
+{
+    kern_return_t err;
+    const double factor = chrono_detail::compute_steady_factor(err);
+    if (err != 0)
+    {
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            err,
+                            ::boost::system::system_category(),
+                            "chrono::steady_clock" ));
+        }
+        else
+        {
+            ec.assign( errno, ::boost::system::system_category() );
+            return steady_clock::rep();
+        }
+    }
+    if (!::boost::chrono::is_throws(ec))
+    {
+        ec.clear();
+    }
+    return static_cast<steady_clock::rep>(mach_absolute_time() * factor);
+}
+#endif
+
+typedef steady_clock::rep (*FP)();
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+typedef steady_clock::rep (*FP_ec)(system::error_code &);
+#endif
+
+BOOST_CHRONO_STATIC
+FP
+init_steady_clock(kern_return_t & err)
+{
+    mach_timebase_info_data_t MachInfo;
+    err = mach_timebase_info(&MachInfo);
+    if ( err != 0  )
+    {
+        return 0;
+    }
+
+    if (MachInfo.numer == MachInfo.denom)
+    {
+        return &chrono_detail::steady_simplified;
+    }
+    return &chrono_detail::steady_full;
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+BOOST_CHRONO_STATIC
+FP_ec
+init_steady_clock_ec(kern_return_t & err)
+{
+    mach_timebase_info_data_t MachInfo;
+    err = mach_timebase_info(&MachInfo);
+    if ( err != 0  )
+    {
+        return 0;
+    }
+
+    if (MachInfo.numer == MachInfo.denom)
+    {
+        return &chrono_detail::steady_simplified_ec;
+    }
+    return &chrono_detail::steady_full_ec;
+}
+#endif
+}
+
+steady_clock::time_point
+steady_clock::now() BOOST_NOEXCEPT
+{
+    kern_return_t err;
+    chrono_detail::FP fp = chrono_detail::init_steady_clock(err);
+    if ( err != 0  )
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+    }
+    return time_point(duration(fp()));
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+steady_clock::time_point
+steady_clock::now(system::error_code & ec)
+{
+    kern_return_t err;
+    chrono_detail::FP_ec fp = chrono_detail::init_steady_clock_ec(err);
+    if ( err != 0  )
+    {
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            err,
+                            ::boost::system::system_category(),
+                            "chrono::steady_clock" ));
+        }
+        else
+        {
+            ec.assign( err, ::boost::system::system_category() );
+            return time_point();
+        }
+    }
+    if (!::boost::chrono::is_throws(ec))
+    {
+        ec.clear();
+    }
+    return time_point(duration(fp(ec)));
+}
+#endif
+}  // namespace chrono
+}  // namespace boost

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp

@@ -0,0 +1,356 @@
+//  boost process_cpu_clocks.cpp  -----------------------------------------------------------//
+
+//  Copyright Beman Dawes 1994, 2006, 2008
+//  Copyright Vicente J. Botet Escriba 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/process_cpu_clocks.hpp>
+#include <boost/assert.hpp>
+
+#include <sys/time.h> //for gettimeofday and timeval
+#include <sys/times.h> //for times
+# include <unistd.h>
+
+namespace boost
+{
+  namespace chrono
+  {
+    namespace chrono_detail
+    {
+
+      inline long tick_factor() // multiplier to convert ticks
+      //  to nanoseconds; -1 if unknown
+      {
+        long factor = 0;
+        if (!factor)
+        {
+          if ((factor = ::sysconf(_SC_CLK_TCK)) <= 0)
+            factor = -1;
+          else
+          {
+            BOOST_ASSERT(factor <= 1000000000l); // doesn't handle large ticks
+            factor = 1000000000l / factor; // compute factor
+            if (!factor)
+              factor = -1;
+          }
+        }
+        return factor;
+      }
+    }
+
+
+    process_real_cpu_clock::time_point process_real_cpu_clock::now() BOOST_NOEXCEPT
+    {
+#if 1
+      tms tm;
+      clock_t c = ::times(&tm);
+      if (c == clock_t(-1)) // error
+      {
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          return time_point(nanoseconds(c * factor));
+        } else
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        }
+      }
+      return time_point();
+#else
+      clock_t c = ::clock();
+      if (c == clock_t(-1)) // error
+      {
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          return time_point(nanoseconds(c * factor));
+        } else
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        }
+      }
+      return time_point();
+#endif
+    }
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+    process_real_cpu_clock::time_point process_real_cpu_clock::now(system::error_code & ec)
+    {
+
+#if 1
+      tms tm;
+      clock_t c = ::times(&tm);
+      if (c == clock_t(-1)) // error
+      {
+        if (::boost::chrono::is_throws(ec))
+        {
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
+        } else
+        {
+          ec.assign(errno, ::boost::system::system_category());
+          return time_point();
+        }
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          if (!::boost::chrono::is_throws(ec))
+          {
+            ec.clear();
+          }
+          return time_point(nanoseconds(c * factor));
+        } else
+        {
+          if (::boost::chrono::is_throws(ec))
+          {
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
+          } else
+          {
+            ec.assign(errno, ::boost::system::system_category());
+            return time_point();
+          }
+        }
+      }
+#else
+      clock_t c = ::clock();
+      if (c == clock_t(-1)) // error
+      {
+        if (::boost::chrono::is_throws(ec))
+        {
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
+        } else
+        {
+          ec.assign(errno, ::boost::system::system_category());
+          return time_point();
+        }
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          if (!::boost::chrono::is_throws(ec))
+          {
+            ec.clear();
+          }
+          return time_point(nanoseconds(c * factor));
+        } else
+        {
+          if (::boost::chrono::is_throws(ec))
+          {
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
+          } else
+          {
+            ec.assign(errno, ::boost::system::system_category());
+            return time_point();
+          }
+        }
+      }
+#endif
+
+    }
+#endif
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+    process_user_cpu_clock::time_point process_user_cpu_clock::now(system::error_code & ec)
+    {
+      tms tm;
+      clock_t c = ::times(&tm);
+      if (c == clock_t(-1)) // error
+      {
+        if (::boost::chrono::is_throws(ec))
+        {
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
+        } else
+        {
+          ec.assign(errno, ::boost::system::system_category());
+          return time_point();
+        }
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          if (!::boost::chrono::is_throws(ec))
+          {
+            ec.clear();
+          }
+          return time_point(nanoseconds((tm.tms_utime + tm.tms_cutime) * factor));
+        } else
+        {
+          if (::boost::chrono::is_throws(ec))
+          {
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
+          } else
+          {
+            ec.assign(errno, ::boost::system::system_category());
+            return time_point();
+          }
+        }
+      }
+    }
+#endif
+
+    process_user_cpu_clock::time_point process_user_cpu_clock::now() BOOST_NOEXCEPT
+    {
+      tms tm;
+      clock_t c = ::times(&tm);
+      if (c == clock_t(-1)) // error
+      {
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          return time_point(nanoseconds((tm.tms_utime + tm.tms_cutime)
+              * factor));
+        } else
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        }
+      }
+      return time_point();
+    }
+    process_system_cpu_clock::time_point process_system_cpu_clock::now() BOOST_NOEXCEPT
+    {
+      tms tm;
+      clock_t c = ::times(&tm);
+      if (c == clock_t(-1)) // error
+      {
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          return time_point(nanoseconds((tm.tms_stime + tm.tms_cstime)
+              * factor));
+        } else
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        }
+      }
+      return time_point();
+    }
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+    process_system_cpu_clock::time_point process_system_cpu_clock::now(system::error_code & ec)
+    {
+      tms tm;
+      clock_t c = ::times(&tm);
+      if (c == clock_t(-1)) // error
+      {
+        if (::boost::chrono::is_throws(ec))
+        {
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
+        } else
+        {
+          ec.assign(errno, ::boost::system::system_category());
+          return time_point();
+        }
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          if (!::boost::chrono::is_throws(ec))
+          {
+            ec.clear();
+          }
+          return time_point(nanoseconds((tm.tms_stime + tm.tms_cstime) * factor));
+        } else
+        {
+          if (::boost::chrono::is_throws(ec))
+          {
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
+          } else
+          {
+            ec.assign(errno, ::boost::system::system_category());
+            return time_point();
+          }
+        }
+      }
+    }
+#endif
+
+    process_cpu_clock::time_point process_cpu_clock::now() BOOST_NOEXCEPT
+    {
+      tms tm;
+      clock_t c = ::times(&tm);
+      if (c == clock_t(-1)) // error
+      {
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          time_point::rep
+              r(c * factor, (tm.tms_utime + tm.tms_cutime) * factor, (tm.tms_stime
+                  + tm.tms_cstime) * factor);
+          return time_point(duration(r));
+        } else
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        }
+      }
+      return time_point();
+    }
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+    process_cpu_clock::time_point process_cpu_clock::now(system::error_code & ec)
+    {
+
+      tms tm;
+      clock_t c = ::times(&tm);
+      if (c == clock_t(-1)) // error
+      {
+        if (::boost::chrono::is_throws(ec))
+        {
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
+        } else
+        {
+          ec.assign(errno, ::boost::system::system_category());
+          return time_point();
+        }
+      } else
+      {
+        long factor = chrono_detail::tick_factor();
+        if (factor != -1)
+        {
+          time_point::rep
+              r(c * factor, (tm.tms_utime + tm.tms_cutime) * factor, (tm.tms_stime
+                  + tm.tms_cstime) * factor);
+          return time_point(duration(r));
+        } else
+        {
+          if (::boost::chrono::is_throws(ec))
+          {
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
+          } else
+          {
+            ec.assign(errno, ::boost::system::system_category());
+            return time_point();
+          }
+        }
+      }
+
+    }
+#endif
+
+  }
+}

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/mac/thread_clock.hpp

@@ -0,0 +1,92 @@
+//  boost thread_clock.cpp  -----------------------------------------------------------//
+
+//  Copyright Beman Dawes 1994, 2006, 2008
+//  Copyright Vicente J. Botet Escriba 2009-2011
+//  Copyright Christopher Brown 2013
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/thread_clock.hpp>
+#include <cassert>
+#include <boost/assert.hpp>
+
+# include <pthread.h>
+# include <mach/thread_act.h>
+
+namespace boost { namespace chrono {
+
+    thread_clock::time_point thread_clock::now( ) BOOST_NOEXCEPT
+    {
+        // get the thread port (borrowing pthread's reference)
+        mach_port_t port = pthread_mach_thread_np(pthread_self());
+
+        // get the thread info
+        thread_basic_info_data_t info;
+        mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
+        if ( thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count) != KERN_SUCCESS )
+        {
+            BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+            return time_point();
+        }
+
+        // convert to nanoseconds
+        duration user = duration(
+                static_cast<thread_clock::rep>( info.user_time.seconds ) * 1000000000
+                        + static_cast<thread_clock::rep>(info.user_time.microseconds ) * 1000);
+
+        duration system = duration(
+                static_cast<thread_clock::rep>( info.system_time.seconds ) * 1000000000
+                        + static_cast<thread_clock::rep>( info.system_time.microseconds ) * 1000);
+
+        return time_point( user + system );
+    }
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+    thread_clock::time_point thread_clock::now( system::error_code & ec )
+    {
+        // get the thread port (borrowing pthread's reference)
+        mach_port_t port = pthread_mach_thread_np(pthread_self());
+
+        // get the thread info
+        thread_basic_info_data_t info;
+        mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
+        if ( thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count) != KERN_SUCCESS )
+        {
+            if (::boost::chrono::is_throws(ec))
+            {
+                boost::throw_exception(
+                        system::system_error(
+                                EINVAL,
+                                ::boost::system::system_category(),
+                                "chrono::thread_clock" ));
+            }
+            else
+            {
+                ec.assign( errno, ::boost::system::system_category() );
+                return time_point();
+            }
+        }
+        if (!::boost::chrono::is_throws(ec))
+        {
+            ec.clear();
+        }
+
+        // convert to nanoseconds
+        duration user = duration(
+                static_cast<thread_clock::rep>( info.user_time.seconds ) * 1000000000
+                        + static_cast<thread_clock::rep>(info.user_time.microseconds ) * 1000);
+
+        duration system = duration(
+                static_cast<thread_clock::rep>( info.system_time.seconds ) * 1000000000
+                        + static_cast<thread_clock::rep>( info.system_time.microseconds ) * 1000);
+
+        return time_point( user + system );
+    }
+#endif
+} }

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/posix/chrono.hpp

@@ -0,0 +1,141 @@
+//  posix/chrono.cpp  --------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2008
+//  Copyright Vicente J. Botet Escriba 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//----------------------------------------------------------------------------//
+//                                POSIX                                     //
+//----------------------------------------------------------------------------//
+
+#include <time.h>  // for clock_gettime
+#include <boost/assert.hpp>
+#include <boost/predef/os.h>
+
+namespace boost
+{
+namespace chrono
+{
+
+  system_clock::time_point system_clock::now() BOOST_NOEXCEPT
+  {
+    timespec ts;
+    if ( ::clock_gettime( CLOCK_REALTIME, &ts ) )
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+    }
+
+    return time_point(duration(
+      static_cast<system_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
+  }
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+  system_clock::time_point system_clock::now(system::error_code & ec)
+  {
+    timespec ts;
+    if ( ::clock_gettime( CLOCK_REALTIME, &ts ) )
+    {
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            errno,
+                            ::boost::system::system_category(),
+                            "chrono::system_clock" ));
+        }
+        else
+        {
+            ec.assign( errno, ::boost::system::system_category() );
+            return time_point();
+        }
+    }
+
+    if (!::boost::chrono::is_throws(ec))
+    {
+        ec.clear();
+    }
+    return time_point(duration(
+      static_cast<system_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
+  }
+#endif
+
+  std::time_t system_clock::to_time_t(const system_clock::time_point& t) BOOST_NOEXCEPT
+  {
+      return static_cast<std::time_t>( t.time_since_epoch().count() / 1000000000 );
+  }
+
+  system_clock::time_point system_clock::from_time_t(std::time_t t) BOOST_NOEXCEPT
+  {
+      return time_point(duration(static_cast<system_clock::rep>(t) * 1000000000));
+  }
+
+#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
+
+  steady_clock::time_point steady_clock::now() BOOST_NOEXCEPT
+  {
+    timespec ts;
+#if BOOST_OS_CYGWIN
+    // lack of thread safety in high resolution timer initialization
+    // can lead to a timespec of zero without an error; was reported
+    // to the cygwin mailing list and can be removed once fixed
+    do
+    {
+#endif
+      if ( ::clock_gettime( CLOCK_MONOTONIC, &ts ) )
+      {
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      }
+#if BOOST_OS_CYGWIN
+    } while (ts.tv_sec == 0 && ts.tv_nsec == 0);
+#endif
+    return time_point(duration(
+      static_cast<steady_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
+  }
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+  steady_clock::time_point steady_clock::now(system::error_code & ec)
+  {
+    timespec ts;
+#if BOOST_OS_CYGWIN
+    // lack of thread safety in high resolution timer initialization
+    // can lead to a timespec of zero without an error; was reported
+    // to the cygwin mailing list and can be removed once fixed
+    do
+    {
+#endif
+      if ( ::clock_gettime( CLOCK_MONOTONIC, &ts ) )
+      {
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            errno,
+                            ::boost::system::system_category(),
+                            "chrono::steady_clock" ));
+        }
+        else
+        {
+            ec.assign( errno, ::boost::system::system_category() );
+            return time_point();
+        }
+      }
+#if BOOST_OS_CYGWIN
+    } while (ts.tv_sec == 0 && ts.tv_nsec == 0);
+#endif
+
+    if (!::boost::chrono::is_throws(ec))
+    {
+        ec.clear();
+    }
+    return time_point(duration(
+      static_cast<steady_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
+  }
+#endif
+#endif
+
+}  // namespace chrono
+}  // namespace boost
+
+

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp

@@ -0,0 +1,354 @@
+//  boost process_cpu_clocks.cpp  -----------------------------------------------------------//
+
+//  Copyright Beman Dawes 1994, 2006, 2008
+//  Copyright Vicente J. Botet Escriba 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/process_cpu_clocks.hpp>
+#include <boost/assert.hpp>
+
+#include <sys/times.h>
+#include <unistd.h>
+#include <time.h>  // for clock_gettime
+
+
+namespace boost { namespace chrono {
+namespace chrono_detail
+{
+  inline nanoseconds::rep tick_factor()        // multiplier to convert ticks
+                            //  to nanoseconds; -1 if unknown
+  {
+    long factor = 0;
+    if ( !factor )
+    {
+      if ( (factor = ::sysconf( _SC_CLK_TCK )) <= 0 )
+        factor = -1;
+      else
+      {
+        BOOST_ASSERT( factor <= 1000000000l ); // doesn't handle large ticks
+        factor = 1000000000l / factor;  // compute factor
+        if ( !factor ) factor = -1;
+      }
+    }
+    return factor;
+  }
+}
+
+process_real_cpu_clock::time_point process_real_cpu_clock::now() BOOST_NOEXCEPT
+{
+    tms tm;
+    clock_t c = ::times( &tm );
+    if ( c == clock_t(-1) ) // error
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+    }
+    else
+    {
+        if ( chrono_detail::tick_factor() != -1 )
+        {
+            return time_point(
+                    nanoseconds(c*chrono_detail::tick_factor()));
+        }
+        else
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        }
+    }
+    return time_point();
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+process_real_cpu_clock::time_point process_real_cpu_clock::now(
+        system::error_code & ec)
+{
+
+    tms tm;
+    clock_t c = ::times( &tm );
+    if ( c == clock_t(-1) ) // error
+    {
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            errno,
+                            ::boost::system::system_category(),
+                            "chrono::process_real_cpu_clock" ));
+        }
+        else
+        {
+            ec.assign( errno, ::boost::system::system_category() );
+            return time_point();
+        }
+    }
+    else
+    {
+        if ( chrono_detail::tick_factor() != -1 )
+        {
+            if (!::boost::chrono::is_throws(ec))
+            {
+                ec.clear();
+            }
+            return time_point(
+                nanoseconds(c*chrono_detail::tick_factor()));
+        }
+        else
+        {
+            if (::boost::chrono::is_throws(ec))
+            {
+                boost::throw_exception(
+                        system::system_error(
+                                errno,
+                                ::boost::system::system_category(),
+                                "chrono::process_real_cpu_clock" ));
+            }
+            else
+            {
+                ec.assign( errno, ::boost::system::system_category() );
+                return time_point();
+            }
+        }
+    }
+}
+#endif
+
+process_user_cpu_clock::time_point process_user_cpu_clock::now() BOOST_NOEXCEPT
+{
+    tms tm;
+    clock_t c = ::times( &tm );
+    if ( c == clock_t(-1) ) // error
+    {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+    }
+    else
+    {
+        if ( chrono_detail::tick_factor() != -1 )
+        {
+            return time_point(
+                nanoseconds((tm.tms_utime + tm.tms_cutime)*chrono_detail::tick_factor()));
+        }
+        else
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        }
+    }
+    return time_point();
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+process_user_cpu_clock::time_point process_user_cpu_clock::now(
+        system::error_code & ec)
+{
+    tms tm;
+    clock_t c = ::times( &tm );
+    if ( c == clock_t(-1) ) // error
+    {
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            errno,
+                            ::boost::system::system_category(),
+                            "chrono::process_user_cpu_clock" ));
+        }
+        else
+        {
+            ec.assign( errno, ::boost::system::system_category() );
+            return time_point();
+        }
+    }
+    else
+    {
+        if ( chrono_detail::tick_factor() != -1 )
+        {
+            if (!::boost::chrono::is_throws(ec))
+            {
+                ec.clear();
+            }
+            return time_point(
+                nanoseconds((tm.tms_utime + tm.tms_cutime)*chrono_detail::tick_factor()));
+        }
+        else
+        {
+            if (::boost::chrono::is_throws(ec))
+            {
+                boost::throw_exception(
+                        system::system_error(
+                                errno,
+                                ::boost::system::system_category(),
+                                "chrono::process_user_cpu_clock" ));
+            }
+            else
+            {
+                ec.assign( errno, ::boost::system::system_category() );
+                return time_point();
+            }
+        }
+    }
+}
+#endif
+
+process_system_cpu_clock::time_point process_system_cpu_clock::now() BOOST_NOEXCEPT
+{
+    tms tm;
+    clock_t c = ::times( &tm );
+    if ( c == clock_t(-1) ) // error
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      return time_point();
+    }
+    else
+    {
+        if ( chrono_detail::tick_factor() != -1 )
+        {
+            return time_point(
+                nanoseconds((tm.tms_stime + tm.tms_cstime)*chrono_detail::tick_factor()));
+        }
+        else
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+          return time_point();
+        }
+    }
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+process_system_cpu_clock::time_point process_system_cpu_clock::now(
+        system::error_code & ec)
+{
+    tms tm;
+    clock_t c = ::times( &tm );
+    if ( c == clock_t(-1) ) // error
+    {
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            errno,
+                            ::boost::system::system_category(),
+                            "chrono::process_system_cpu_clock" ));
+        }
+        else
+        {
+            ec.assign( errno, ::boost::system::system_category() );
+            return time_point();
+        }
+    }
+    else
+    {
+        if ( chrono_detail::tick_factor() != -1 )
+        {
+            if (!::boost::chrono::is_throws(ec))
+            {
+                ec.clear();
+            }
+            return time_point(
+                nanoseconds((tm.tms_stime + tm.tms_cstime)*chrono_detail::tick_factor()));
+        }
+        else
+        {
+            if (::boost::chrono::is_throws(ec))
+            {
+                boost::throw_exception(
+                        system::system_error(
+                                errno,
+                                ::boost::system::system_category(),
+                                "chrono::process_system_cpu_clock" ));
+            }
+            else
+            {
+                ec.assign( errno, ::boost::system::system_category() );
+                return time_point();
+            }
+        }
+    }
+}
+#endif
+
+process_cpu_clock::time_point process_cpu_clock::now() BOOST_NOEXCEPT
+{
+    tms tm;
+    clock_t c = ::times( &tm );
+    if ( c == clock_t(-1) ) // error
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+    }
+    else
+    {
+        nanoseconds::rep factor = chrono_detail::tick_factor();
+        if ( factor != -1 )
+        {
+            time_point::rep r(
+                    c*factor,
+                    (tm.tms_utime + tm.tms_cutime)*factor,
+                    (tm.tms_stime + tm.tms_cstime)*factor);
+            return time_point(duration(r));
+        }
+        else
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        }
+    }
+    return time_point();
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+process_cpu_clock::time_point process_cpu_clock::now(
+        system::error_code & ec )
+{
+    tms tm;
+    clock_t c = ::times( &tm );
+    if ( c == clock_t(-1) ) // error
+    {
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            errno,
+                            ::boost::system::system_category(),
+                            "chrono::process_clock" ));
+        }
+        else
+        {
+            ec.assign( errno, ::boost::system::system_category() );
+            return time_point();
+        }
+    }
+    else
+    {
+        if ( chrono_detail::tick_factor() != -1 )
+        {
+            time_point::rep r(
+                c*chrono_detail::tick_factor(),
+                (tm.tms_utime + tm.tms_cutime)*chrono_detail::tick_factor(),
+                (tm.tms_stime + tm.tms_cstime)*chrono_detail::tick_factor());
+            return time_point(duration(r));
+        }
+        else
+        {
+            if (::boost::chrono::is_throws(ec))
+            {
+                boost::throw_exception(
+                        system::system_error(
+                                errno,
+                                ::boost::system::system_category(),
+                                "chrono::process_clock" ));
+            }
+            else
+            {
+                ec.assign( errno, ::boost::system::system_category() );
+                return time_point();
+            }
+        }
+    }
+
+}
+#endif
+
+} }

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/posix/thread_clock.hpp

@@ -0,0 +1,92 @@
+//  boost thread_clock.cpp  -----------------------------------------------------------//
+
+//  Copyright Beman Dawes 1994, 2006, 2008
+//  Copyright Vicente J. Botet Escriba 2009-2011
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/thread_clock.hpp>
+#include <cassert>
+#include <boost/assert.hpp>
+
+#if !defined(__VXWORKS__)
+# include <sys/times.h>
+#endif
+# include <pthread.h>
+# include <unistd.h>
+
+namespace boost { namespace chrono {
+
+    thread_clock::time_point thread_clock::now( ) BOOST_NOEXCEPT
+    {
+      struct timespec ts;
+#if defined CLOCK_THREAD_CPUTIME_ID
+        // get the timespec associated to the thread clock
+        if ( ::clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts ) )
+#else
+        // get the current thread
+        pthread_t pth=pthread_self();
+        // get the clock_id associated to the current thread
+        clockid_t clock_id;
+        pthread_getcpuclockid(pth, &clock_id);
+        // get the timespec associated to the thread clock
+        if ( ::clock_gettime( clock_id, &ts ) )
+#endif
+        {
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        }
+
+        // transform to nanoseconds
+        return time_point(duration(
+            static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
+
+    }
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+    thread_clock::time_point thread_clock::now( system::error_code & ec )
+    {
+      struct timespec ts;
+#if defined CLOCK_THREAD_CPUTIME_ID
+        // get the timespec associated to the thread clock
+        if ( ::clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts ) )
+#else
+        // get the current thread
+        pthread_t pth=pthread_self();
+        // get the clock_id associated to the current thread
+        clockid_t clock_id;
+        pthread_getcpuclockid(pth, &clock_id);
+        // get the timespec associated to the thread clock
+        if ( ::clock_gettime( clock_id, &ts ) )
+#endif
+        {
+            if (::boost::chrono::is_throws(ec))
+            {
+                boost::throw_exception(
+                        system::system_error(
+                                errno,
+                                ::boost::system::system_category(),
+                                "chrono::thread_clock" ));
+            }
+            else
+            {
+                ec.assign( errno, ::boost::system::system_category() );
+                return time_point();
+            }
+        }
+        if (!::boost::chrono::is_throws(ec))
+        {
+            ec.clear();
+        }
+        // transform to nanoseconds
+        return time_point(duration(
+            static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
+
+    }
+#endif
+} }

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/process_cpu_clocks.hpp

@@ -0,0 +1,46 @@
+//  boost process_cpu_clocks.cpp  -----------------------------------------------------------//
+
+//  Copyright 2009-2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+#ifndef BOOST_CHRONO_DETAIL_INLINED_PROCESS_CPU_CLOCKS_HPP
+#define BOOST_CHRONO_DETAIL_INLINED_PROCESS_CPU_CLOCKS_HPP
+
+
+#include <boost/chrono/config.hpp>
+#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
+
+#include <boost/version.hpp>
+#include <boost/chrono/process_cpu_clocks.hpp>
+#include <boost/throw_exception.hpp>
+#if defined BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING
+#include <boost/system/system_error.hpp>
+#endif
+//----------------------------------------------------------------------------//
+//                                Windows                                     //
+//----------------------------------------------------------------------------//
+#if defined(BOOST_CHRONO_WINDOWS_API)
+#include <boost/chrono/detail/inlined/win/process_cpu_clocks.hpp>
+
+//----------------------------------------------------------------------------//
+//                                 Mac                                        //
+//----------------------------------------------------------------------------//
+#elif defined(BOOST_CHRONO_MAC_API)
+#include <boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp>
+
+//----------------------------------------------------------------------------//
+//                                POSIX                                     //
+//----------------------------------------------------------------------------//
+#elif defined(BOOST_CHRONO_POSIX_API)
+#include <boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp>
+
+#endif  // POSIX
+
+#endif
+
+#endif

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/thread_clock.hpp

@@ -0,0 +1,46 @@
+//  boost thread_clock.cpp  -----------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+#ifndef BOOST_CHRONO_DETAIL_INLINED_THREAD_CLOCK_HPP
+#define BOOST_CHRONO_DETAIL_INLINED_THREAD_CLOCK_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/version.hpp>
+#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
+#include <boost/chrono/thread_clock.hpp>
+#include <boost/throw_exception.hpp>
+#if defined BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING
+#include <boost/system/system_error.hpp>
+#endif
+#include <boost/throw_exception.hpp>
+#include <boost/chrono/detail/system.hpp>
+
+//----------------------------------------------------------------------------//
+//                                Windows                                     //
+//----------------------------------------------------------------------------//
+#if defined(BOOST_CHRONO_WINDOWS_API)
+#include <boost/chrono/detail/inlined/win/thread_clock.hpp>
+
+//----------------------------------------------------------------------------//
+//                                 Mac                                        //
+//----------------------------------------------------------------------------//
+#elif defined(BOOST_CHRONO_MAC_API)
+#include <boost/chrono/detail/inlined/mac/thread_clock.hpp>
+
+//----------------------------------------------------------------------------//
+//                                POSIX                                     //
+//----------------------------------------------------------------------------//
+#elif defined(BOOST_CHRONO_POSIX_API)
+#include <boost/chrono/detail/inlined/posix/thread_clock.hpp>
+
+#endif  // POSIX
+
+#endif
+#endif

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/win/chrono.hpp

@@ -0,0 +1,151 @@
+//  win/chrono.cpp  --------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2008
+//  Copyright 2009-2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//----------------------------------------------------------------------------//
+//                                Windows                                     //
+//----------------------------------------------------------------------------//
+#ifndef BOOST_CHRONO_DETAIL_INLINED_WIN_CHRONO_HPP
+#define BOOST_CHRONO_DETAIL_INLINED_WIN_CHRONO_HPP
+
+#include <boost/winapi/time.hpp>
+#include <boost/winapi/timers.hpp>
+#include <boost/winapi/get_last_error.hpp>
+#include <boost/winapi/error_codes.hpp>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+namespace chrono
+{
+namespace chrono_detail
+{
+
+  BOOST_CHRONO_INLINE double get_nanosecs_per_tic() BOOST_NOEXCEPT
+  {
+      boost::winapi::LARGE_INTEGER_ freq;
+      if ( !boost::winapi::QueryPerformanceFrequency( &freq ) )
+          return 0.0L;
+      return double(1000000000.0L / freq.QuadPart);
+  }
+
+}
+
+  steady_clock::time_point steady_clock::now() BOOST_NOEXCEPT
+  {
+    double nanosecs_per_tic = chrono_detail::get_nanosecs_per_tic();
+
+    boost::winapi::LARGE_INTEGER_ pcount;
+    if ( nanosecs_per_tic <= 0.0L )
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - get_nanosecs_per_tic Internal Error");
+      return steady_clock::time_point();
+    }
+    unsigned times=0;
+    while ( ! boost::winapi::QueryPerformanceCounter( &pcount ) )
+    {
+      if ( ++times > 3 )
+      {
+        BOOST_ASSERT(0 && "Boost::Chrono - QueryPerformanceCounter Internal Error");
+        return steady_clock::time_point();
+      }
+    }
+
+    return steady_clock::time_point(steady_clock::duration(
+      static_cast<steady_clock::rep>((nanosecs_per_tic) * pcount.QuadPart)));
+  }
+
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+  steady_clock::time_point steady_clock::now( system::error_code & ec )
+  {
+    double nanosecs_per_tic = chrono_detail::get_nanosecs_per_tic();
+
+    boost::winapi::LARGE_INTEGER_ pcount;
+    if ( (nanosecs_per_tic <= 0.0L)
+            || (!boost::winapi::QueryPerformanceCounter( &pcount )) )
+    {
+        boost::winapi::DWORD_ cause =
+            ((nanosecs_per_tic <= 0.0L)
+                    ? boost::winapi::ERROR_NOT_SUPPORTED_
+                    : boost::winapi::GetLastError());
+        if (::boost::chrono::is_throws(ec)) {
+            boost::throw_exception(
+                    system::system_error(
+                            cause,
+                            ::boost::system::system_category(),
+                            "chrono::steady_clock" ));
+        }
+        else
+        {
+            ec.assign( cause, ::boost::system::system_category() );
+            return steady_clock::time_point(duration(0));
+        }
+    }
+
+    if (!::boost::chrono::is_throws(ec))
+    {
+        ec.clear();
+    }
+    return time_point(duration(
+      static_cast<steady_clock::rep>(nanosecs_per_tic * pcount.QuadPart)));
+  }
+#endif
+
+  BOOST_CHRONO_INLINE
+  system_clock::time_point system_clock::now() BOOST_NOEXCEPT
+  {
+    boost::winapi::FILETIME_ ft;
+    boost::winapi::GetSystemTimeAsFileTime( &ft );  // never fails
+    return system_clock::time_point(
+      system_clock::duration(
+        ((static_cast<__int64>( ft.dwHighDateTime ) << 32) | ft.dwLowDateTime)
+       - 116444736000000000LL
+       //- (134775LL*864000000000LL)
+      )
+    );
+  }
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+  BOOST_CHRONO_INLINE
+  system_clock::time_point system_clock::now( system::error_code & ec )
+  {
+    boost::winapi::FILETIME_ ft;
+    boost::winapi::GetSystemTimeAsFileTime( &ft );  // never fails
+    if (!::boost::chrono::is_throws(ec))
+    {
+        ec.clear();
+    }
+    return system_clock::time_point(
+      system_clock::duration(
+       ((static_cast<__int64>( ft.dwHighDateTime ) << 32) | ft.dwLowDateTime)
+       - 116444736000000000LL
+       //- (134775LL*864000000000LL)
+       ));
+  }
+#endif
+
+  BOOST_CHRONO_INLINE
+  std::time_t system_clock::to_time_t(const system_clock::time_point& t) BOOST_NOEXCEPT
+  {
+      __int64 temp = t.time_since_epoch().count();
+      temp /= 10000000;
+      return static_cast<std::time_t>( temp );
+  }
+
+  BOOST_CHRONO_INLINE
+  system_clock::time_point system_clock::from_time_t(std::time_t t) BOOST_NOEXCEPT
+  {
+      __int64 temp = t;
+      temp *= 10000000;
+      return time_point(duration(temp));
+  }
+
+}  // namespace chrono
+}  // namespace boost
+
+#endif

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp

@@ -0,0 +1,281 @@
+//  boost process_timer.cpp  -----------------------------------------------------------//
+
+//  Copyright Beman Dawes 1994, 2006, 2008
+//  Copyright 2009-2010 Vicente J. Botet Escriba
+//  Copyright (c) Microsoft Corporation 2014
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+#ifndef BOOST_CHRONO_DETAIL_INLINED_WIN_PROCESS_CLOCK_HPP
+#define BOOST_CHRONO_DETAIL_INLINED_WIN_PROCESS_CLOCK_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/process_cpu_clocks.hpp>
+#include <cassert>
+#include <time.h>
+#include <boost/assert.hpp>
+
+#include <boost/winapi/get_last_error.hpp>
+#include <boost/winapi/get_current_process.hpp>
+#if BOOST_PLAT_WINDOWS_DESKTOP
+#include <boost/winapi/get_process_times.hpp>
+#endif
+
+namespace boost
+{
+namespace chrono
+{
+
+process_real_cpu_clock::time_point process_real_cpu_clock::now() BOOST_NOEXCEPT
+{
+    clock_t c = ::clock();
+    if ( c == clock_t(-1) ) // error
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+    }
+    typedef ratio_divide<giga, ratio<CLOCKS_PER_SEC> >::type R;
+    return time_point(
+      duration(static_cast<rep>(c)*R::num/R::den)
+    );
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+process_real_cpu_clock::time_point process_real_cpu_clock::now(
+        system::error_code & ec)
+{
+    clock_t c = ::clock();
+    if ( c == clock_t(-1) ) // error
+    {
+            boost::throw_exception(
+                    system::system_error(
+                            errno,
+                            ::boost::system::system_category(),
+                            "chrono::process_real_cpu_clock" ));
+    }
+    if (!::boost::chrono::is_throws(ec))
+    {
+      ec.clear();
+    }
+    typedef ratio_divide<giga, ratio<CLOCKS_PER_SEC> >::type R;
+    return time_point(
+      duration(static_cast<rep>(c)*R::num/R::den)
+    );
+}
+#endif
+
+#if BOOST_PLAT_WINDOWS_DESKTOP
+process_user_cpu_clock::time_point process_user_cpu_clock::now() BOOST_NOEXCEPT
+{
+
+    //  note that Windows uses 100 nanosecond ticks for FILETIME
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
+
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
+            &system_time, &user_time ) )
+    {
+        return time_point(duration(
+                ((static_cast<process_user_cpu_clock::rep>(user_time.dwHighDateTime) << 32)
+                  | user_time.dwLowDateTime) * 100
+                ));
+    }
+    else
+    {
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+        return time_point();
+    }
+
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+process_user_cpu_clock::time_point process_user_cpu_clock::now(
+        system::error_code & ec)
+{
+
+    //  note that Windows uses 100 nanosecond ticks for FILETIME
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
+
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
+            &system_time, &user_time ) )
+    {
+        if (!::boost::chrono::is_throws(ec))
+        {
+            ec.clear();
+        }
+        return time_point(duration(
+                ((static_cast<process_user_cpu_clock::rep>(user_time.dwHighDateTime) << 32)
+                  | user_time.dwLowDateTime) * 100
+                ));
+    }
+    else
+    {
+        boost::winapi::DWORD_ cause = boost::winapi::GetLastError();
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            cause,
+                            ::boost::system::system_category(),
+                            "chrono::process_user_cpu_clock" ));
+        }
+        else
+        {
+            ec.assign( cause, ::boost::system::system_category() );
+            return time_point();
+        }
+    }
+
+}
+#endif
+
+process_system_cpu_clock::time_point process_system_cpu_clock::now() BOOST_NOEXCEPT
+{
+
+    //  note that Windows uses 100 nanosecond ticks for FILETIME
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
+
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
+            &system_time, &user_time ) )
+    {
+        return time_point(duration(
+                ((static_cast<process_system_cpu_clock::rep>(system_time.dwHighDateTime) << 32)
+                                    | system_time.dwLowDateTime) * 100
+                ));
+    }
+    else
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      return time_point();
+    }
+
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+process_system_cpu_clock::time_point process_system_cpu_clock::now(
+        system::error_code & ec)
+{
+
+    //  note that Windows uses 100 nanosecond ticks for FILETIME
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
+
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
+            &system_time, &user_time ) )
+    {
+        if (!::boost::chrono::is_throws(ec))
+        {
+            ec.clear();
+        }
+        return time_point(duration(
+                ((static_cast<process_system_cpu_clock::rep>(system_time.dwHighDateTime) << 32)
+                                    | system_time.dwLowDateTime) * 100
+                ));
+    }
+    else
+    {
+        boost::winapi::DWORD_ cause = boost::winapi::GetLastError();
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            cause,
+                            ::boost::system::system_category(),
+                            "chrono::process_system_cpu_clock" ));
+        }
+        else
+        {
+            ec.assign( cause, ::boost::system::system_category() );
+            return time_point();
+        }
+    }
+
+}
+#endif
+
+process_cpu_clock::time_point process_cpu_clock::now()  BOOST_NOEXCEPT
+{
+
+    //  note that Windows uses 100 nanosecond ticks for FILETIME
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
+
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
+            &system_time, &user_time ) )
+    {
+        time_point::rep r(process_real_cpu_clock::now().time_since_epoch().count()
+                            ,
+                ((static_cast<process_user_cpu_clock::rep>(user_time.dwHighDateTime) << 32)
+                        | user_time.dwLowDateTime
+                ) * 100,
+                ((static_cast<process_system_cpu_clock::rep>(system_time.dwHighDateTime) << 32)
+                        | system_time.dwLowDateTime
+                ) * 100
+        );
+        return time_point(duration(r));
+    }
+    else
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      return time_point();
+    }
+
+}
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+process_cpu_clock::time_point process_cpu_clock::now(
+        system::error_code & ec )
+{
+
+    //  note that Windows uses 100 nanosecond ticks for FILETIME
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
+
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
+            &system_time, &user_time ) )
+    {
+        if (!::boost::chrono::is_throws(ec))
+        {
+            ec.clear();
+        }
+        time_point::rep r(process_real_cpu_clock::now().time_since_epoch().count()
+                            ,
+                ((static_cast<process_user_cpu_clock::rep>(user_time.dwHighDateTime) << 32)
+                        | user_time.dwLowDateTime
+                ) * 100,
+                ((static_cast<process_system_cpu_clock::rep>(system_time.dwHighDateTime) << 32)
+                        | system_time.dwLowDateTime
+                ) * 100
+        );
+        return time_point(duration(r));
+    }
+    else
+    {
+        boost::winapi::DWORD_ cause = boost::winapi::GetLastError();
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            cause,
+                            ::boost::system::system_category(),
+                            "chrono::process_cpu_clock" ));
+        }
+        else
+        {
+            ec.assign( cause, ::boost::system::system_category() );
+            return time_point();
+        }
+    }
+
+}
+#endif
+#endif
+} // namespace chrono
+} // namespace boost
+
+#endif

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/inlined/win/thread_clock.hpp

@@ -0,0 +1,103 @@
+//  boost thread_clock.cpp  -----------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+#ifndef BOOST_CHRONO_DETAIL_INLINED_WIN_THREAD_CLOCK_HPP
+#define BOOST_CHRONO_DETAIL_INLINED_WIN_THREAD_CLOCK_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/thread_clock.hpp>
+#include <cassert>
+#include <boost/assert.hpp>
+
+#include <boost/winapi/get_last_error.hpp>
+#include <boost/winapi/get_current_thread.hpp>
+#include <boost/winapi/get_thread_times.hpp>
+
+namespace boost
+{
+namespace chrono
+{
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+thread_clock::time_point thread_clock::now( system::error_code & ec )
+{
+    //  note that Windows uses 100 nanosecond ticks for FILETIME
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
+
+    if ( boost::winapi::GetThreadTimes(
+            boost::winapi::GetCurrentThread (), &creation, &exit,
+            &system_time, &user_time ) )
+    {
+        duration user = duration(
+                ((static_cast<duration::rep>(user_time.dwHighDateTime) << 32)
+                        | user_time.dwLowDateTime) * 100 );
+
+        duration system = duration(
+                ((static_cast<duration::rep>(system_time.dwHighDateTime) << 32)
+                        | system_time.dwLowDateTime) * 100 );
+
+        if (!::boost::chrono::is_throws(ec))
+        {
+            ec.clear();
+        }
+        return time_point(system+user);
+
+    }
+    else
+    {
+        if (::boost::chrono::is_throws(ec))
+        {
+            boost::throw_exception(
+                    system::system_error(
+                            boost::winapi::GetLastError(),
+                            ::boost::system::system_category(),
+                            "chrono::thread_clock" ));
+        }
+        else
+        {
+            ec.assign( boost::winapi::GetLastError(), ::boost::system::system_category() );
+            return thread_clock::time_point(duration(0));
+        }
+    }
+}
+#endif
+
+thread_clock::time_point thread_clock::now() BOOST_NOEXCEPT
+{
+
+    //  note that Windows uses 100 nanosecond ticks for FILETIME
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
+
+    if ( boost::winapi::GetThreadTimes(
+            boost::winapi::GetCurrentThread (), &creation, &exit,
+            &system_time, &user_time ) )
+    {
+        duration user   = duration(
+                ((static_cast<duration::rep>(user_time.dwHighDateTime) << 32)
+                        | user_time.dwLowDateTime) * 100 );
+
+        duration system = duration(
+                ((static_cast<duration::rep>(system_time.dwHighDateTime) << 32)
+                        | system_time.dwLowDateTime) * 100 );
+
+        return time_point(system+user);
+    }
+    else
+    {
+      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
+      return time_point();
+    }
+
+}
+
+} // namespace chrono
+} // namespace boost
+
+#endif

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/is_evenly_divisible_by.hpp

@@ -0,0 +1,31 @@
+//  is_evenly_divisible_by.hpp  --------------------------------------------------------------//
+
+//  Copyright 2009-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_CHRONO_DETAIL_IS_EVENLY_DIVISIBLE_BY_HPP
+#define BOOST_CHRONO_DETAIL_IS_EVENLY_DIVISIBLE_BY_HPP
+
+#include <boost/chrono/config.hpp>
+
+#include <boost/mpl/logical.hpp>
+#include <boost/ratio/detail/overflow_helpers.hpp>
+
+namespace boost {
+namespace chrono {
+namespace chrono_detail {
+
+//  template <class R1, class R2>
+//  struct is_evenly_divisible_by : public boost::mpl::bool_ < ratio_divide<R1, R2>::type::den == 1 >
+//  {};
+  template <class R1, class R2>
+  struct is_evenly_divisible_by : public boost::ratio_detail::is_evenly_divisible_by<R1, R2>
+  {};
+
+} // namespace chrono_detail
+} // namespace detail
+} // namespace chrono
+
+#endif // BOOST_CHRONO_DETAIL_IS_EVENLY_DIVISIBLE_BY_HPP

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/no_warning/signed_unsigned_cmp.hpp

@@ -0,0 +1,54 @@
+//  is_evenly_divisible_by.hpp  --------------------------------------------------------------//
+
+//  Copyright 2009-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_CHRONO_DETAIL_NO_WARNING_SIGNED_UNSIGNED_CMP_HPP
+#define BOOST_CHRONO_DETAIL_NO_WARNING_SIGNED_UNSIGNED_CMP_HPP
+
+//
+// We simply cannot include this header on gcc without getting copious warnings of the kind:
+//
+//../../../boost/chrono/detail/no_warning/signed_unsigned_cmp.hpp:37: warning: comparison between signed and unsigned integer expressions
+//
+// And yet there is no other reasonable implementation, so we declare this a system header
+// to suppress these warnings.
+//
+
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#pragma GCC system_header
+#elif defined __SUNPRO_CC
+#pragma disable_warn
+#elif defined _MSC_VER
+#pragma warning(push, 1)
+#endif
+
+namespace boost {
+namespace chrono {
+namespace detail {
+
+  template <class T, class U>
+  bool lt(T t, U u)
+  {
+    return t < u;
+  }
+
+  template <class T, class U>
+  bool gt(T t, U u)
+  {
+    return t > u;
+  }
+
+} // namespace detail
+} // namespace detail
+} // namespace chrono
+
+#if defined __SUNPRO_CC
+#pragma enable_warn
+#elif defined _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_CHRONO_DETAIL_NO_WARNING_SIGNED_UNSIGNED_CMP_HPP

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/scan_keyword.hpp

@@ -0,0 +1,163 @@
+//  scan_keyword.hpp  --------------------------------------------------------------//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//  Adaptation to Boost of the libcxx
+
+//  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_CHRONO_DETAIL_SCAN_KEYWORD_HPP
+#define BOOST_CHRONO_DETAIL_SCAN_KEYWORD_HPP
+
+#include <boost/chrono/config.hpp>
+
+#include <boost/move/unique_ptr.hpp>
+#include <ios>
+#include <exception>
+#include <stdlib.h>
+#include <boost/throw_exception.hpp>
+
+namespace boost {
+    using movelib::unique_ptr;
+
+namespace chrono {
+namespace chrono_detail {
+
+inline void free_aux(void* ptr) { free(ptr); }
+
+// scan_keyword
+// Scans [b, e) until a match is found in the basic_strings range
+//  [kb, ke) or until it can be shown that there is no match in [kb, ke).
+//  b will be incremented (visibly), consuming CharT until a match is found
+//  or proved to not exist.  A keyword may be "", in which will match anything.
+//  If one keyword is a prefix of another, and the next CharT in the input
+//  might match another keyword, the algorithm will attempt to find the longest
+//  matching keyword.  If the longer matching keyword ends up not matching, then
+//  no keyword match is found.  If no keyword match is found, ke is returned
+//  and failbit is set in err.
+//  Else an iterator pointing to the matching keyword is found.  If more than
+//  one keyword matches, an iterator to the first matching keyword is returned.
+//  If on exit b == e, eofbit is set in err.
+//  Examples:
+//  Keywords:  "a", "abb"
+//  If the input is "a", the first keyword matches and eofbit is set.
+//  If the input is "abc", no match is found and "ab" are consumed.
+
+template <class InputIterator, class ForwardIterator>
+ForwardIterator
+scan_keyword(InputIterator& b, InputIterator e,
+               ForwardIterator kb, ForwardIterator ke,
+               std::ios_base::iostate& err
+               )
+{
+    typedef typename std::iterator_traits<InputIterator>::value_type CharT;
+    size_t nkw = std::distance(kb, ke);
+    const unsigned char doesnt_match = '\0';
+    const unsigned char might_match = '\1';
+    const unsigned char does_match = '\2';
+    unsigned char statbuf[100];
+    unsigned char* status = statbuf;
+    //  Change free by free_aux to avoid
+    // Error: Could not find a match for boost::interprocess::unique_ptr<unsigned char, void(*)(void*)>::unique_ptr(int, extern "C" void(void*))
+    unique_ptr<unsigned char, void(*)(void*)> stat_hold(0, free_aux);
+    if (nkw > sizeof(statbuf))
+    {
+        status = (unsigned char*)malloc(nkw);
+        if (status == 0)
+          throw_exception(std::bad_alloc());
+        stat_hold.reset(status);
+    }
+    size_t n_might_match = nkw;  // At this point, any keyword might match
+    size_t n_does_match = 0;       // but none of them definitely do
+    // Initialize all statuses to might_match, except for "" keywords are does_match
+    unsigned char* st = status;
+    for (ForwardIterator ky = kb; ky != ke; ++ky, ++st)
+    {
+        if (!ky->empty())
+            *st = might_match;
+        else
+        {
+            *st = does_match;
+            --n_might_match;
+            ++n_does_match;
+        }
+    }
+    // While there might be a match, test keywords against the next CharT
+    for (size_t indx = 0; b != e && n_might_match > 0; ++indx)
+    {
+        // Peek at the next CharT but don't consume it
+        CharT c = *b;
+        bool consume = false;
+        // For each keyword which might match, see if the indx character is c
+        // If a match if found, consume c
+        // If a match is found, and that is the last character in the keyword,
+        //    then that keyword matches.
+        // If the keyword doesn't match this character, then change the keyword
+        //    to doesn't match
+        st = status;
+        for (ForwardIterator ky = kb; ky != ke; ++ky, ++st)
+        {
+            if (*st == might_match)
+            {
+                CharT kc = (*ky)[indx];
+                if (c == kc)
+                {
+                    consume = true;
+                    if (ky->size() == indx+1)
+                    {
+                        *st = does_match;
+                        --n_might_match;
+                        ++n_does_match;
+                    }
+                }
+                else
+                {
+                    *st = doesnt_match;
+                    --n_might_match;
+                }
+            }
+        }
+        // consume if we matched a character
+        if (consume)
+        {
+            ++b;
+            // If we consumed a character and there might be a matched keyword that
+            //   was marked matched on a previous iteration, then such keywords
+            //   which are now marked as not matching.
+            if (n_might_match + n_does_match > 1)
+            {
+                st = status;
+                for (ForwardIterator ky = kb; ky != ke; ++ky, ++st)
+                {
+                    if (*st == does_match && ky->size() != indx+1)
+                    {
+                        *st = doesnt_match;
+                        --n_does_match;
+                    }
+                }
+            }
+        }
+    }
+    // We've exited the loop because we hit eof and/or we have no more "might matches".
+    if (b == e)
+        err |= std::ios_base::eofbit;
+    // Return the first matching result
+    for (st = status; kb != ke; ++kb, ++st)
+        if (*st == does_match)
+            break;
+    if (kb == ke)
+        err |= std::ios_base::failbit;
+    return kb;
+}
+}
+}
+}
+#endif // BOOST_CHRONO_DETAIL_SCAN_KEYWORD_HPP

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/static_assert.hpp

@@ -0,0 +1,30 @@
+//  static_assert.hpp  --------------------------------------------------------------//
+
+//  Copyright 2009-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_CHRONO_DETAIL_STATIC_ASSERT_HPP
+#define BOOST_CHRONO_DETAIL_STATIC_ASSERT_HPP
+
+#include <boost/chrono/config.hpp>
+
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
+#elif defined(BOOST_CHRONO_USES_STATIC_ASSERT)
+#include <boost/static_assert.hpp>
+#define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
+#elif defined(BOOST_CHRONO_USES_MPL_ASSERT)
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/bool.hpp>
+#define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES)                                 \
+    BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
+#else
+//~ #elif defined(BOOST_CHRONO_USES_ARRAY_ASSERT)
+#define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_JOIN(boost_chrono_test_,__LINE__)[(CND)?1:-1]
+//~ #define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES)
+#endif
+
+#endif // BOOST_CHRONO_DETAIL_STATIC_ASSERT_HPP

externals/vcpkg/packages/boost-chrono_x64-windows/include/boost/chrono/detail/system.hpp

@@ -0,0 +1,20 @@
+//  Copyright 2009-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_CHRONO_DETAIL_SYSTEM_HPP
+#define BOOST_CHRONO_DETAIL_SYSTEM_HPP
+
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+
+#include <boost/system/error_code.hpp>
+
+namespace boost {
+namespace chrono {
+    inline bool is_throws(system::error_code  & ec) { return (&ec==&boost::throws()); }
+}
+}
+
+#endif
+#endif