Update contrib/restricted/boost/chrono to 1.79.0

20 files changed, 200 insertions, 297 deletions

diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/chrono.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/chrono.hpp
index 0bd3400a253..9bf6c2bb12a 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/chrono.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/chrono.hpp
@@ -40,7 +40,7 @@ system_clock::now(system::error_code & ec)
 {
     timeval tv;
     gettimeofday(&tv, 0);
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -89,7 +89,7 @@ BOOST_CHRONO_STATIC
 steady_clock::rep
 steady_simplified_ec(system::error_code & ec)
 {
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -131,21 +131,21 @@ steady_full_ec(system::error_code & ec)
     const double factor = chrono_detail::compute_steady_factor(err);
     if (err != 0)
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             err,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::steady_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return steady_clock::rep();
         }
     }
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -217,21 +217,21 @@ steady_clock::now(system::error_code & ec)
     chrono_detail::FP_ec fp = chrono_detail::init_steady_clock_ec(err);
     if ( err != 0  )
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             err,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::steady_clock" ));
         }
         else
         {
-            ec.assign( err, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( err, ::boost::system::system_category() );
             return time_point();
         }
     }
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp
index 6e55b0f2ff0..29fe86ccfc8 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp
@@ -95,12 +95,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -108,19 +108,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds(c * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -129,12 +129,12 @@ namespace boost
       clock_t c = ::clock();
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -142,19 +142,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds(c * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -171,12 +171,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_user_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -184,19 +184,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          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))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_user_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -254,12 +254,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_system_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -267,19 +267,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          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))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_system_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -319,12 +319,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -338,12 +338,12 @@ namespace boost
           return time_point(duration(r));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/thread_clock.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/thread_clock.hpp
index 690458f41cf..74b820ace69 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/thread_clock.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/mac/thread_clock.hpp
@@ -58,21 +58,21 @@ namespace boost { namespace chrono {
         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))
+            if (::boost::chrono::is_throws(ec))
             {
                 boost::throw_exception(
                         system::system_error(
                                 EINVAL,
-                                BOOST_CHRONO_SYSTEM_CATEGORY,
+                                ::boost::system::system_category(),
                                 "chrono::thread_clock" ));
             }
             else
             {
-                ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+                ec.assign( errno, ::boost::system::system_category() );
                 return time_point();
             }
         }
-        if (!BOOST_CHRONO_IS_THROWS(ec))
+        if (!::boost::chrono::is_throws(ec))
         {
             ec.clear();
         }
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/chrono.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/chrono.hpp
index c4c8a6add75..8baac39f39f 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/chrono.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/chrono.hpp
@@ -12,6 +12,7 @@
 
 #include <time.h>  // for clock_gettime
 #include <boost/assert.hpp>
+#include <boost/predef/os.h>
 
 namespace boost
 {
@@ -36,22 +37,22 @@ namespace chrono
     timespec ts;
     if ( ::clock_gettime( CLOCK_REALTIME, &ts ) )
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             errno,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::system_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return time_point();
         }
     }
 
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -75,11 +76,20 @@ namespace chrono
   steady_clock::time_point steady_clock::now() BOOST_NOEXCEPT
   {
     timespec ts;
-    if ( ::clock_gettime( CLOCK_MONOTONIC, &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
     {
-      BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
-    }
-
+#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));
   }
@@ -88,24 +98,34 @@ namespace chrono
   steady_clock::time_point steady_clock::now(system::error_code & ec)
   {
     timespec ts;
-    if ( ::clock_gettime( CLOCK_MONOTONIC, &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
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+#endif
+      if ( ::clock_gettime( CLOCK_MONOTONIC, &ts ) )
+      {
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             errno,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::steady_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            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))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp
index feecc86792d..f9a9e1293c8 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp
@@ -73,17 +73,17 @@ process_real_cpu_clock::time_point process_real_cpu_clock::now(
     clock_t c = ::times( &tm );
     if ( c == clock_t(-1) ) // error
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             errno,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::process_real_cpu_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return time_point();
         }
     }
@@ -91,7 +91,7 @@ process_real_cpu_clock::time_point process_real_cpu_clock::now(
     {
         if ( chrono_detail::tick_factor() != -1 )
         {
-            if (!BOOST_CHRONO_IS_THROWS(ec))
+            if (!::boost::chrono::is_throws(ec))
             {
                 ec.clear();
             }
@@ -100,17 +100,17 @@ process_real_cpu_clock::time_point process_real_cpu_clock::now(
         }
         else
         {
-            if (BOOST_CHRONO_IS_THROWS(ec))
+            if (::boost::chrono::is_throws(ec))
             {
                 boost::throw_exception(
                         system::system_error(
                                 errno,
-                                BOOST_CHRONO_SYSTEM_CATEGORY,
+                                ::boost::system::system_category(),
                                 "chrono::process_real_cpu_clock" ));
             }
             else
             {
-                ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+                ec.assign( errno, ::boost::system::system_category() );
                 return time_point();
             }
         }
@@ -149,17 +149,17 @@ process_user_cpu_clock::time_point process_user_cpu_clock::now(
     clock_t c = ::times( &tm );
     if ( c == clock_t(-1) ) // error
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             errno,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::process_user_cpu_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return time_point();
         }
     }
@@ -167,7 +167,7 @@ process_user_cpu_clock::time_point process_user_cpu_clock::now(
     {
         if ( chrono_detail::tick_factor() != -1 )
         {
-            if (!BOOST_CHRONO_IS_THROWS(ec))
+            if (!::boost::chrono::is_throws(ec))
             {
                 ec.clear();
             }
@@ -176,17 +176,17 @@ process_user_cpu_clock::time_point process_user_cpu_clock::now(
         }
         else
         {
-            if (BOOST_CHRONO_IS_THROWS(ec))
+            if (::boost::chrono::is_throws(ec))
             {
                 boost::throw_exception(
                         system::system_error(
                                 errno,
-                                BOOST_CHRONO_SYSTEM_CATEGORY,
+                                ::boost::system::system_category(),
                                 "chrono::process_user_cpu_clock" ));
             }
             else
             {
-                ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+                ec.assign( errno, ::boost::system::system_category() );
                 return time_point();
             }
         }
@@ -226,17 +226,17 @@ process_system_cpu_clock::time_point process_system_cpu_clock::now(
     clock_t c = ::times( &tm );
     if ( c == clock_t(-1) ) // error
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             errno,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::process_system_cpu_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return time_point();
         }
     }
@@ -244,7 +244,7 @@ process_system_cpu_clock::time_point process_system_cpu_clock::now(
     {
         if ( chrono_detail::tick_factor() != -1 )
         {
-            if (!BOOST_CHRONO_IS_THROWS(ec))
+            if (!::boost::chrono::is_throws(ec))
             {
                 ec.clear();
             }
@@ -253,17 +253,17 @@ process_system_cpu_clock::time_point process_system_cpu_clock::now(
         }
         else
         {
-            if (BOOST_CHRONO_IS_THROWS(ec))
+            if (::boost::chrono::is_throws(ec))
             {
                 boost::throw_exception(
                         system::system_error(
                                 errno,
-                                BOOST_CHRONO_SYSTEM_CATEGORY,
+                                ::boost::system::system_category(),
                                 "chrono::process_system_cpu_clock" ));
             }
             else
             {
-                ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+                ec.assign( errno, ::boost::system::system_category() );
                 return time_point();
             }
         }
@@ -306,17 +306,17 @@ process_cpu_clock::time_point process_cpu_clock::now(
     clock_t c = ::times( &tm );
     if ( c == clock_t(-1) ) // error
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             errno,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::process_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return time_point();
         }
     }
@@ -332,17 +332,17 @@ process_cpu_clock::time_point process_cpu_clock::now(
         }
         else
         {
-            if (BOOST_CHRONO_IS_THROWS(ec))
+            if (::boost::chrono::is_throws(ec))
             {
                 boost::throw_exception(
                         system::system_error(
                                 errno,
-                                BOOST_CHRONO_SYSTEM_CATEGORY,
+                                ::boost::system::system_category(),
                                 "chrono::process_clock" ));
             }
             else
             {
-                ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+                ec.assign( errno, ::boost::system::system_category() );
                 return time_point();
             }
         }
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/thread_clock.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/thread_clock.hpp
index a42b3c8a150..a2a2d9cf65d 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/thread_clock.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/posix/thread_clock.hpp
@@ -65,21 +65,21 @@ namespace boost { namespace chrono {
         if ( ::clock_gettime( clock_id, &ts ) )
 #endif
         {
-            if (BOOST_CHRONO_IS_THROWS(ec))
+            if (::boost::chrono::is_throws(ec))
             {
                 boost::throw_exception(
                         system::system_error(
                                 errno,
-                                BOOST_CHRONO_SYSTEM_CATEGORY,
+                                ::boost::system::system_category(),
                                 "chrono::thread_clock" ));
             }
             else
             {
-                ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+                ec.assign( errno, ::boost::system::system_category() );
                 return time_point();
             }
         }
-        if (!BOOST_CHRONO_IS_THROWS(ec))
+        if (!::boost::chrono::is_throws(ec))
         {
             ec.clear();
         }
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/chrono.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/chrono.hpp
index e61f11e7cec..5c753f5e288 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/chrono.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/chrono.hpp
@@ -12,9 +12,10 @@
 #ifndef BOOST_CHRONO_DETAIL_INLINED_WIN_CHRONO_HPP
 #define BOOST_CHRONO_DETAIL_INLINED_WIN_CHRONO_HPP
 
-#include <boost/detail/winapi/time.hpp>
-#include <boost/detail/winapi/timers.hpp>
-#include <boost/detail/winapi/get_last_error.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
@@ -26,8 +27,8 @@ namespace chrono_detail
 
   BOOST_CHRONO_INLINE double get_nanosecs_per_tic() BOOST_NOEXCEPT
   {
-      boost::detail::winapi::LARGE_INTEGER_ freq;
-      if ( !boost::detail::winapi::QueryPerformanceFrequency( &freq ) )
+      boost::winapi::LARGE_INTEGER_ freq;
+      if ( !boost::winapi::QueryPerformanceFrequency( &freq ) )
           return 0.0L;
       return double(1000000000.0L / freq.QuadPart);
   }
@@ -38,14 +39,14 @@ namespace chrono_detail
   {
     double nanosecs_per_tic = chrono_detail::get_nanosecs_per_tic();
 
-    boost::detail::winapi::LARGE_INTEGER_ pcount;
+    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::detail::winapi::QueryPerformanceCounter( &pcount ) )
+    while ( ! boost::winapi::QueryPerformanceCounter( &pcount ) )
     {
       if ( ++times > 3 )
       {
@@ -64,29 +65,29 @@ namespace chrono_detail
   {
     double nanosecs_per_tic = chrono_detail::get_nanosecs_per_tic();
 
-    boost::detail::winapi::LARGE_INTEGER_ pcount;
+    boost::winapi::LARGE_INTEGER_ pcount;
     if ( (nanosecs_per_tic <= 0.0L)
-            || (!boost::detail::winapi::QueryPerformanceCounter( &pcount )) )
+            || (!boost::winapi::QueryPerformanceCounter( &pcount )) )
     {
-        boost::detail::winapi::DWORD_ cause =
+        boost::winapi::DWORD_ cause =
             ((nanosecs_per_tic <= 0.0L)
-                    ? ERROR_NOT_SUPPORTED
-                    : boost::detail::winapi::GetLastError());
-        if (BOOST_CHRONO_IS_THROWS(ec)) {
+                    ? boost::winapi::ERROR_NOT_SUPPORTED_
+                    : boost::winapi::GetLastError());
+        if (::boost::chrono::is_throws(ec)) {
             boost::throw_exception(
                     system::system_error(
                             cause,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::steady_clock" ));
         }
         else
         {
-            ec.assign( cause, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( cause, ::boost::system::system_category() );
             return steady_clock::time_point(duration(0));
         }
     }
 
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -98,8 +99,8 @@ namespace chrono_detail
   BOOST_CHRONO_INLINE
   system_clock::time_point system_clock::now() BOOST_NOEXCEPT
   {
-    boost::detail::winapi::FILETIME_ ft;
-    boost::detail::winapi::GetSystemTimeAsFileTime( &ft );  // never fails
+    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)
@@ -113,9 +114,9 @@ namespace chrono_detail
   BOOST_CHRONO_INLINE
   system_clock::time_point system_clock::now( system::error_code & ec )
   {
-    boost::detail::winapi::FILETIME_ ft;
-    boost::detail::winapi::GetSystemTimeAsFileTime( &ft );  // never fails
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    boost::winapi::FILETIME_ ft;
+    boost::winapi::GetSystemTimeAsFileTime( &ft );  // never fails
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp
index 7169f8020a1..87b5d4af199 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp
@@ -19,10 +19,10 @@
 #include <time.h>
 #include <boost/assert.hpp>
 
-#include <boost/detail/winapi/get_last_error.hpp>
-#include <boost/detail/winapi/get_current_process.hpp>
+#include <boost/winapi/get_last_error.hpp>
+#include <boost/winapi/get_current_process.hpp>
 #if BOOST_PLAT_WINDOWS_DESKTOP
-#include <boost/detail/winapi/get_process_times.hpp>
+#include <boost/winapi/get_process_times.hpp>
 #endif
 
 namespace boost
@@ -53,10 +53,10 @@ process_real_cpu_clock::time_point process_real_cpu_clock::now(
             boost::throw_exception(
                     system::system_error(
                             errno,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::process_real_cpu_clock" ));
     }
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
       ec.clear();
     }
@@ -72,10 +72,10 @@ process_user_cpu_clock::time_point process_user_cpu_clock::now() BOOST_NOEXCEPT
 {
 
     //  note that Windows uses 100 nanosecond ticks for FILETIME
-    boost::detail::winapi::FILETIME_ creation, exit, user_time, system_time;
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
 
-    if ( boost::detail::winapi::GetProcessTimes(
-            boost::detail::winapi::GetCurrentProcess(), &creation, &exit,
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
             &system_time, &user_time ) )
     {
         return time_point(duration(
@@ -97,13 +97,13 @@ process_user_cpu_clock::time_point process_user_cpu_clock::now(
 {
 
     //  note that Windows uses 100 nanosecond ticks for FILETIME
-    boost::detail::winapi::FILETIME_ creation, exit, user_time, system_time;
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
 
-    if ( boost::detail::winapi::GetProcessTimes(
-            boost::detail::winapi::GetCurrentProcess(), &creation, &exit,
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
             &system_time, &user_time ) )
     {
-        if (!BOOST_CHRONO_IS_THROWS(ec))
+        if (!::boost::chrono::is_throws(ec))
         {
             ec.clear();
         }
@@ -114,18 +114,18 @@ process_user_cpu_clock::time_point process_user_cpu_clock::now(
     }
     else
     {
-        boost::detail::winapi::DWORD_ cause = boost::detail::winapi::GetLastError();
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        boost::winapi::DWORD_ cause = boost::winapi::GetLastError();
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             cause,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::process_user_cpu_clock" ));
         }
         else
         {
-            ec.assign( cause, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( cause, ::boost::system::system_category() );
             return time_point();
         }
     }
@@ -137,10 +137,10 @@ process_system_cpu_clock::time_point process_system_cpu_clock::now() BOOST_NOEXC
 {
 
     //  note that Windows uses 100 nanosecond ticks for FILETIME
-    boost::detail::winapi::FILETIME_ creation, exit, user_time, system_time;
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
 
-    if ( boost::detail::winapi::GetProcessTimes(
-            boost::detail::winapi::GetCurrentProcess(), &creation, &exit,
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
             &system_time, &user_time ) )
     {
         return time_point(duration(
@@ -162,13 +162,13 @@ process_system_cpu_clock::time_point process_system_cpu_clock::now(
 {
 
     //  note that Windows uses 100 nanosecond ticks for FILETIME
-    boost::detail::winapi::FILETIME_ creation, exit, user_time, system_time;
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
 
-    if ( boost::detail::winapi::GetProcessTimes(
-            boost::detail::winapi::GetCurrentProcess(), &creation, &exit,
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
             &system_time, &user_time ) )
     {
-        if (!BOOST_CHRONO_IS_THROWS(ec))
+        if (!::boost::chrono::is_throws(ec))
         {
             ec.clear();
         }
@@ -179,18 +179,18 @@ process_system_cpu_clock::time_point process_system_cpu_clock::now(
     }
     else
     {
-        boost::detail::winapi::DWORD_ cause = boost::detail::winapi::GetLastError();
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        boost::winapi::DWORD_ cause = boost::winapi::GetLastError();
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             cause,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::process_system_cpu_clock" ));
         }
         else
         {
-            ec.assign( cause, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( cause, ::boost::system::system_category() );
             return time_point();
         }
     }
@@ -202,10 +202,10 @@ process_cpu_clock::time_point process_cpu_clock::now()  BOOST_NOEXCEPT
 {
 
     //  note that Windows uses 100 nanosecond ticks for FILETIME
-    boost::detail::winapi::FILETIME_ creation, exit, user_time, system_time;
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
 
-    if ( boost::detail::winapi::GetProcessTimes(
-            boost::detail::winapi::GetCurrentProcess(), &creation, &exit,
+    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()
@@ -233,13 +233,13 @@ process_cpu_clock::time_point process_cpu_clock::now(
 {
 
     //  note that Windows uses 100 nanosecond ticks for FILETIME
-    boost::detail::winapi::FILETIME_ creation, exit, user_time, system_time;
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
 
-    if ( boost::detail::winapi::GetProcessTimes(
-            boost::detail::winapi::GetCurrentProcess(), &creation, &exit,
+    if ( boost::winapi::GetProcessTimes(
+            boost::winapi::GetCurrentProcess(), &creation, &exit,
             &system_time, &user_time ) )
     {
-        if (!BOOST_CHRONO_IS_THROWS(ec))
+        if (!::boost::chrono::is_throws(ec))
         {
             ec.clear();
         }
@@ -256,18 +256,18 @@ process_cpu_clock::time_point process_cpu_clock::now(
     }
     else
     {
-        boost::detail::winapi::DWORD_ cause = boost::detail::winapi::GetLastError();
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        boost::winapi::DWORD_ cause = boost::winapi::GetLastError();
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             cause,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::process_cpu_clock" ));
         }
         else
         {
-            ec.assign( cause, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( cause, ::boost::system::system_category() );
             return time_point();
         }
     }
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/thread_clock.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/thread_clock.hpp
index 037ccbee3e9..9c9490d0ba3 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/thread_clock.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/inlined/win/thread_clock.hpp
@@ -16,9 +16,9 @@
 #include <cassert>
 #include <boost/assert.hpp>
 
-#include <boost/detail/winapi/get_last_error.hpp>
-#include <boost/detail/winapi/get_current_thread.hpp>
-#include <boost/detail/winapi/get_thread_times.hpp>
+#include <boost/winapi/get_last_error.hpp>
+#include <boost/winapi/get_current_thread.hpp>
+#include <boost/winapi/get_thread_times.hpp>
 
 namespace boost
 {
@@ -29,10 +29,10 @@ namespace chrono
 thread_clock::time_point thread_clock::now( system::error_code & ec )
 {
     //  note that Windows uses 100 nanosecond ticks for FILETIME
-    boost::detail::winapi::FILETIME_ creation, exit, user_time, system_time;
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
 
-    if ( boost::detail::winapi::GetThreadTimes(
-            boost::detail::winapi::GetCurrentThread (), &creation, &exit,
+    if ( boost::winapi::GetThreadTimes(
+            boost::winapi::GetCurrentThread (), &creation, &exit,
             &system_time, &user_time ) )
     {
         duration user = duration(
@@ -43,7 +43,7 @@ thread_clock::time_point thread_clock::now( system::error_code & ec )
                 ((static_cast<duration::rep>(system_time.dwHighDateTime) << 32)
                         | system_time.dwLowDateTime) * 100 );
 
-        if (!BOOST_CHRONO_IS_THROWS(ec))
+        if (!::boost::chrono::is_throws(ec))
         {
             ec.clear();
         }
@@ -52,17 +52,17 @@ thread_clock::time_point thread_clock::now( system::error_code & ec )
     }
     else
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
-                            boost::detail::winapi::GetLastError(),
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            boost::winapi::GetLastError(),
+                            ::boost::system::system_category(),
                             "chrono::thread_clock" ));
         }
         else
         {
-            ec.assign( boost::detail::winapi::GetLastError(), BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( boost::winapi::GetLastError(), ::boost::system::system_category() );
             return thread_clock::time_point(duration(0));
         }
     }
@@ -73,10 +73,10 @@ thread_clock::time_point thread_clock::now() BOOST_NOEXCEPT
 {
 
     //  note that Windows uses 100 nanosecond ticks for FILETIME
-    boost::detail::winapi::FILETIME_ creation, exit, user_time, system_time;
+    boost::winapi::FILETIME_ creation, exit, user_time, system_time;
 
-    if ( boost::detail::winapi::GetThreadTimes(
-            boost::detail::winapi::GetCurrentThread (), &creation, &exit,
+    if ( boost::winapi::GetThreadTimes(
+            boost::winapi::GetCurrentThread (), &creation, &exit,
             &system_time, &user_time ) )
     {
         duration user   = duration(
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/detail/system.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/detail/system.hpp
index ebe27abac8b..3d82006a0b4 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/detail/system.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/detail/system.hpp
@@ -10,10 +10,11 @@
 
 #include <boost/system/error_code.hpp>
 
-#define BOOST_CHRONO_SYSTEM_CATEGORY boost::system::system_category()
-
-#define BOOST_CHRONO_THROWS boost::throws()
-#define BOOST_CHRONO_IS_THROWS(EC) (&EC==&boost::throws())
+namespace boost {
+namespace chrono {
+    inline bool is_throws(system::error_code  & ec) { return (&ec==&boost::throws()); }
+}
+}
 
 #endif
 #endif
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/io/duration_io.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/io/duration_io.hpp
index f3aca6adfd4..c25adeeee6c 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/io/duration_io.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/io/duration_io.hpp
@@ -17,7 +17,7 @@
 #include <boost/chrono/io/duration_put.hpp>
 #include <boost/chrono/io/duration_get.hpp>
 #include <boost/chrono/io/utility/manip_base.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_floating_point.hpp>
 #include <locale>
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/io/duration_style.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/io/duration_style.hpp
index 65b76a902ca..68f6c97e62f 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/io/duration_style.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/io/duration_style.hpp
@@ -10,7 +10,7 @@
 #ifndef BOOST_CHRONO_IO_DURATION_STYLE_HPP
 #define BOOST_CHRONO_IO_DURATION_STYLE_HPP
 
-#include <boost/detail/scoped_enum_emulation.hpp>
+#include <boost/core/scoped_enum.hpp>
 
 namespace boost
 {
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/io/time_point_io.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/io/time_point_io.hpp
index 3143efac69e..96a6f0a9dea 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/io/time_point_io.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/io/time_point_io.hpp
@@ -29,7 +29,7 @@
 #include <boost/chrono/round.hpp>
 #include <boost/chrono/detail/scan_keyword.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>
 #include <cstring>
 #include <locale>
 #include <ctime>
@@ -767,7 +767,7 @@ namespace boost
     }
     inline int32_t days_from_1970(int32_t year)
     {
-      static const int days_from_0_to_1970 = days_from_0(1970);
+      static const int32_t days_from_0_to_1970 = days_from_0(1970);
       return days_from_0(year) - days_from_0_to_1970;
     }
     inline int32_t days_from_1jan(int32_t year,int32_t month,int32_t day)
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/io/timezone.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/io/timezone.hpp
index 67975da96fb..430a55991d9 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/io/timezone.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/io/timezone.hpp
@@ -9,7 +9,8 @@
 
 #ifndef BOOST_CHRONO_IO_TIMEZONE_HPP
 #define BOOST_CHRONO_IO_TIMEZONE_HPP
-#include <boost/detail/scoped_enum_emulation.hpp>
+
+#include <boost/core/scoped_enum.hpp>
 
 namespace boost
 {
diff --git a/contrib/restricted/boost/chrono/include/boost/chrono/system_clocks.hpp b/contrib/restricted/boost/chrono/include/boost/chrono/system_clocks.hpp
index 5ba6a3b0e9c..3087311ffe2 100644
--- a/contrib/restricted/boost/chrono/include/boost/chrono/system_clocks.hpp
+++ b/contrib/restricted/boost/chrono/include/boost/chrono/system_clocks.hpp
@@ -96,9 +96,9 @@ namespace boost {
 namespace chrono {
 
   // Clocks
-  class BOOST_CHRONO_DECL system_clock;
+  class system_clock;
 #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
-  class BOOST_CHRONO_DECL steady_clock;
+  class steady_clock;
 #endif
 
 #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
diff --git a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_current_process.hpp b/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_current_process.hpp
deleted file mode 100644
index b516a3480bd..00000000000
--- a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_current_process.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright 2017 Andrey Semashev
- *
- * Distributed under the Boost Software License, Version 1.0.
- * See http://www.boost.org/LICENSE_1_0.txt
- *
- * This header is deprecated, use boost/winapi/get_current_process.hpp instead.
- */
-
-#ifndef BOOST_DETAIL_WINAPI_GET_CURRENT_PROCESS_HPP
-#define BOOST_DETAIL_WINAPI_GET_CURRENT_PROCESS_HPP
-
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED("<boost/winapi/get_current_process.hpp>")
-
-#include <boost/winapi/get_current_process.hpp>
-#include <boost/detail/winapi/detail/deprecated_namespace.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#endif // BOOST_DETAIL_WINAPI_GET_CURRENT_PROCESS_HPP
diff --git a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_current_thread.hpp b/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_current_thread.hpp
deleted file mode 100644
index 296386e25a2..00000000000
--- a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_current_thread.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright 2017 Andrey Semashev
- *
- * Distributed under the Boost Software License, Version 1.0.
- * See http://www.boost.org/LICENSE_1_0.txt
- *
- * This header is deprecated, use boost/winapi/get_current_thread.hpp instead.
- */
-
-#ifndef BOOST_DETAIL_WINAPI_GET_CURRENT_THREAD_HPP
-#define BOOST_DETAIL_WINAPI_GET_CURRENT_THREAD_HPP
-
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED("<boost/winapi/get_current_thread.hpp>")
-
-#include <boost/winapi/get_current_thread.hpp>
-#include <boost/detail/winapi/detail/deprecated_namespace.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#endif // BOOST_DETAIL_WINAPI_GET_CURRENT_THREAD_HPP
diff --git a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_last_error.hpp b/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_last_error.hpp
deleted file mode 100644
index b48aa6a92b2..00000000000
--- a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_last_error.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright 2017 Andrey Semashev
- *
- * Distributed under the Boost Software License, Version 1.0.
- * See http://www.boost.org/LICENSE_1_0.txt
- *
- * This header is deprecated, use boost/winapi/get_last_error.hpp instead.
- */
-
-#ifndef BOOST_DETAIL_WINAPI_GET_LAST_ERROR_HPP
-#define BOOST_DETAIL_WINAPI_GET_LAST_ERROR_HPP
-
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED("<boost/winapi/get_last_error.hpp>")
-
-#include <boost/winapi/get_last_error.hpp>
-#include <boost/detail/winapi/detail/deprecated_namespace.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#endif // BOOST_DETAIL_WINAPI_GET_LAST_ERROR_HPP
diff --git a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_process_times.hpp b/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_process_times.hpp
deleted file mode 100644
index 3bd72472ed5..00000000000
--- a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_process_times.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright 2017 Andrey Semashev
- *
- * Distributed under the Boost Software License, Version 1.0.
- * See http://www.boost.org/LICENSE_1_0.txt
- *
- * This header is deprecated, use boost/winapi/get_process_times.hpp instead.
- */
-
-#ifndef BOOST_DETAIL_WINAPI_GET_PROCESS_TIMES_HPP
-#define BOOST_DETAIL_WINAPI_GET_PROCESS_TIMES_HPP
-
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED("<boost/winapi/get_process_times.hpp>")
-
-#include <boost/winapi/get_process_times.hpp>
-#include <boost/detail/winapi/detail/deprecated_namespace.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#endif // BOOST_DETAIL_WINAPI_GET_PROCESS_TIMES_HPP
diff --git a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_thread_times.hpp b/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_thread_times.hpp
deleted file mode 100644
index 2301430c4c5..00000000000
--- a/contrib/restricted/boost/winapi/include/boost/detail/winapi/get_thread_times.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright 2017 Andrey Semashev
- *
- * Distributed under the Boost Software License, Version 1.0.
- * See http://www.boost.org/LICENSE_1_0.txt
- *
- * This header is deprecated, use boost/winapi/get_thread_times.hpp instead.
- */
-
-#ifndef BOOST_DETAIL_WINAPI_GET_THREAD_TIMES_HPP
-#define BOOST_DETAIL_WINAPI_GET_THREAD_TIMES_HPP
-
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED("<boost/winapi/get_thread_times.hpp>")
-
-#include <boost/winapi/get_thread_times.hpp>
-#include <boost/detail/winapi/detail/deprecated_namespace.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#endif // BOOST_DETAIL_WINAPI_GET_THREAD_TIMES_HPP