passenger 6.0.14 → 6.0.15

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/use_coro.hpp

@@ -2,8 +2,8 @@
 // experimental/use_coro.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2021 Klemens D. Morgenstern
-//                    (klemens dot morgenstern at gmx dot net)
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -12,6 +12,10 @@
 #ifndef BOOST_ASIO_EXPERIMENTAL_USE_CORO_HPP
 #define BOOST_ASIO_EXPERIMENTAL_USE_CORO_HPP
 
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
 #include <boost/asio/detail/config.hpp>
 #include <optional>
 #include <boost/asio/bind_cancellation_slot.hpp>
@@ -28,257 +32,140 @@ class any_io_executor;
 
 namespace experimental {
 
+/// A @ref completion_token that represents the currently executing resumable
+/// coroutine.
+/**
+ * The @c use_coro_t class, with its value @c use_coro, is used to represent an
+ * operation that can be awaited by the current resumable coroutine. This
+ * completion token may be passed as a handler to an asynchronous operation.
+ * For example:
+ *
+ * @code coro<void> my_coroutine(tcp::socket my_socket)
+ * {
+ *   std::size_t n = co_await my_socket.async_read_some(buffer, use_coro);
+ *   ...
+ * } @endcode
+ *
+ * When used with co_await, the initiating function (@c async_read_some in the
+ * above example) suspends the current coroutine. The coroutine is resumed when
+ * the asynchronous operation completes, and the result of the operation is
+ * returned.
+ */
 template <typename Executor = any_io_executor>
 struct use_coro_t
 {
-};
-
-constexpr use_coro_t<> use_coro;
-
-template <typename Yield, typename Return, typename Executor>
-struct coro;
-
-namespace detail {
-
-template <typename Yield, typename Return, typename Executor>
-struct coro_promise;
-
-template <typename Executor, typename... Ts>
-struct coro_init_handler
-{
-  struct handler_t
+  /// Default constructor.
+  BOOST_ASIO_CONSTEXPR use_coro_t(
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+# if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+      boost::asio::detail::source_location location =
+        boost::asio::detail::source_location::current()
+# endif // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+    )
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+# if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+    : file_name_(location.file_name()),
+      line_(location.line()),
+      function_name_(location.function_name())
+# else // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+    : file_name_(0),
+      line_(0),
+      function_name_(0)
+# endif // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
   {
-  };
-
-  constexpr static handler_t handler{};
-
-  struct init_helper;
-
-  struct promise_type
-  {
-    auto initial_suspend() noexcept { return suspend_always{}; }
-
-    auto final_suspend() noexcept { return suspend_always(); }
-
-    void return_void() {}
-
-    void unhandled_exception() { assert(false); }
-
-    auto await_transform(handler_t)
-    {
-      assert(executor);
-      assert(h);
-      return init_helper{this};
-    }
-
-    std::optional<Executor> executor;
-    std::optional<std::tuple<Ts...>> result;
-    coroutine_handle<> h;
-
-    coro_init_handler get_return_object() { return coro_init_handler{this}; }
-
-    cancellation_slot cancel_slot;
-  };
-
-  struct init_helper
-  {
-    promise_type *self_;
-
-    constexpr static bool await_ready() noexcept { return true; }
-
-    constexpr static void await_suspend(coroutine_handle<>) noexcept {}
-
-    auto await_resume() const noexcept
-    {
-      assert(self_);
-      return bind_cancellation_slot(self_->cancel_slot,
-          bind_executor(*self_->executor, [self = self_](Ts... ts)
-          {
-            self->result.emplace(std::move(ts)...);
-            self->h.resume();
-          }));
-    }
-  };
-
-  promise_type* promise;
-
-  void unhandled_exception() noexcept
-  {
-    throw;
   }
 
-  struct noexcept_version
+  /// Constructor used to specify file name, line, and function name.
+  BOOST_ASIO_CONSTEXPR use_coro_t(const char* file_name,
+      int line, const char* function_name)
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+    : file_name_(file_name),
+      line_(line),
+      function_name_(function_name)
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
   {
-    promise_type *promise;
-
-    constexpr static bool await_ready() noexcept { return false; }
-
-    template <typename Yield, typename Return,
-        convertible_to<Executor> Executor1>
-    auto await_suspend(
-        coroutine_handle<coro_promise<Yield, Return, Executor1> > h) noexcept
-    {
-      promise->executor = h.promise().get_executor();
-      promise->h = h;
-      return coroutine_handle<promise_type>::from_promise(*promise);
-    }
-
-    template <typename... Args>
-    static auto resume_impl(std::tuple<Args...>&& tup)
-    {
-      return std::move(tup);
-    }
-
-    template <typename Arg>
-    static auto resume_impl(std::tuple<Arg>&& tup)
-    {
-      return get<0>(std::move(tup));
-    }
-
-    static void resume_impl(std::tuple<>&&) {}
-
-    auto await_resume() const noexcept
-    {
-      auto res = std::move(promise->result.value());
-      coroutine_handle<promise_type>::from_promise(*promise).destroy();
-      return resume_impl(std::move(res));
-    }
-  };
+#if !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+    (void)file_name;
+    (void)line;
+    (void)function_name;
+#endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+  }
 
-  struct throwing_version
+  /// Adapts an executor to add the @c use_coro_t completion token as the
+  /// default.
+  template <typename InnerExecutor>
+  struct executor_with_default : InnerExecutor
   {
-    promise_type *promise;
-
-    constexpr static bool await_ready() noexcept { return false; }
-
-    template <typename Yield, typename Return,
-        convertible_to<Executor> Executor1>
-    auto await_suspend(
-        coroutine_handle<coro_promise<Yield, Return, Executor1> > h) noexcept
-    {
-      promise->executor = h.promise().get_executor();
-      promise->h = h;
-      return coroutine_handle<promise_type>::from_promise(*promise);
-    }
-
-    template <typename... Args>
-    static auto resume_impl(std::tuple<Args...>&& tup)
+    /// Specify @c use_coro_t as the default completion token type.
+    typedef use_coro_t default_completion_token_type;
+
+    /// Construct the adapted executor from the inner executor type.
+    template <typename InnerExecutor1>
+    executor_with_default(const InnerExecutor1& ex,
+        typename constraint<
+          conditional<
+            !is_same<InnerExecutor1, executor_with_default>::value,
+            is_convertible<InnerExecutor1, InnerExecutor>,
+            false_type
+          >::type::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
     {
-      return std::move(tup);
-    }
-
-    static void resume_impl(std::tuple<>&&) {}
-
-    template <typename Arg>
-    static auto resume_impl(std::tuple<Arg>&& tup)
-    {
-      return get<0>(std::move(tup));
-    }
-
-    template <typename... Args>
-    static auto resume_impl(std::tuple<std::exception_ptr, Args...>&& tup)
-    {
-      auto ex = get<0>(std::move(tup));
-      if (ex)
-        std::rethrow_exception(ex);
-
-      if constexpr (sizeof...(Args) == 0u)
-        return;
-      else if constexpr (sizeof...(Args) == 1u)
-        return get<1>(std::move(tup));
-      else
-      {
-        return
-          [&]<std::size_t... Idx>(std::index_sequence<Idx...>)
-          {
-            return std::make_tuple(std::get<Idx + 1>(std::move(tup))...);
-          }(std::make_index_sequence<sizeof...(Args) - 1>{});
-      }
-    }
-
-    template <typename... Args>
-    static auto resume_impl(
-        std::tuple<boost::system::error_code, Args...>&& tup)
-    {
-      auto ec = get<0>(std::move(tup));
-      if (ec)
-        boost::asio::detail::throw_exception(
-            boost::system::system_error(ec, "error_code in use_coro"));
-
-      if constexpr (sizeof...(Args) == 0u)
-        return;
-      else if constexpr (sizeof...(Args) == 1u)
-        return get<1>(std::move(tup));
-      else
-        return
-          [&]<std::size_t... Idx>(std::index_sequence<Idx...>)
-          {
-            return std::make_tuple(std::get<Idx + 1>(std::move(tup))...);
-          }(std::make_index_sequence<sizeof...(Args) - 1>{});
-    }
-
-    static auto resume_impl(std::tuple<std::exception_ptr>&& tup)
-    {
-      auto ex = get<0>(std::move(tup));
-      if (ex)
-        std::rethrow_exception(ex);
-    }
-
-    static auto resume_impl(
-        std::tuple<boost::system::error_code>&& tup)
-    {
-      auto ec = get<0>(std::move(tup));
-      if (ec)
-        boost::asio::detail::throw_error(ec, "error_code in use_coro");
-    }
-
-    auto await_resume() const
-    {
-      auto res = std::move(promise->result.value());
-      coroutine_handle<promise_type>::from_promise(*promise).destroy();
-      return resume_impl(std::move(res));
     }
   };
 
-  auto as_noexcept(cancellation_slot&& sl) && noexcept
-  {
-    promise->cancel_slot = std::move(sl);
-    return noexcept_version{promise};
-  }
-
-  auto as_throwing(cancellation_slot&& sl) && noexcept
+  /// Type alias to adapt an I/O object to use @c use_coro_t as its
+  /// default completion token type.
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  template <typename T>
+  using as_default_on_t = typename T::template rebind_executor<
+      executor_with_default<typename T::executor_type> >::other;
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+  /// Function helper to adapt an I/O object to use @c use_coro_t as its
+  /// default completion token type.
+  template <typename T>
+  static typename decay<T>::type::template rebind_executor<
+      executor_with_default<typename decay<T>::type::executor_type>
+    >::other
+  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
   {
-    promise->cancel_slot = std::move(sl);
-    return throwing_version{promise};
+    return typename decay<T>::type::template rebind_executor<
+        executor_with_default<typename decay<T>::type::executor_type>
+      >::other(BOOST_ASIO_MOVE_CAST(T)(object));
   }
-};
-
-} // namespace detail
-} // namespace experimental
-
-#if !defined(GENERATING_DOCUMENTATION)
 
-template <typename Executor, typename R, typename... Args>
-struct async_result<experimental::use_coro_t<Executor>, R(Args...)>
-{
-  using return_type = experimental::detail::coro_init_handler<
-    Executor, typename decay<Args>::type...>;
-
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation initiation,
-      experimental::use_coro_t<Executor>, InitArgs... args)
-  {
-    std::move(initiation)(co_await return_type::handler, std::move(args)...);
-  }
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+  const char* file_name_;
+  int line_;
+  const char* function_name_;
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 };
 
-#endif // !defined(GENERATING_DOCUMENTATION)
+/// A @ref completion_token object that represents the currently executing
+/// resumable coroutine.
+/**
+ * See the documentation for boost::asio::use_coro_t for a usage example.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+constexpr use_coro_t<> use_coro;
+#elif defined(BOOST_ASIO_HAS_CONSTEXPR)
+constexpr use_coro_t<> use_coro(0, 0, 0);
+#elif defined(BOOST_ASIO_MSVC)
+__declspec(selectany) use_coro_t<> use_coro(0, 0, 0);
+#endif
 
+} // namespace experimental
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#include <boost/asio/experimental/impl/use_coro.hpp>
 #include <boost/asio/experimental/coro.hpp>
 
 #endif // BOOST_ASIO_EXPERIMENTAL_USE_CORO_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/file_base.hpp

@@ -0,0 +1,168 @@
+//
+// file_base.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_FILE_BASE_HPP
+#define BOOST_ASIO_FILE_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_FILE) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#if !defined(BOOST_ASIO_WINDOWS)
+# include <fcntl.h>
+#endif // !defined(BOOST_ASIO_WINDOWS)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// The file_base class is used as a base for the basic_stream_file and
+/// basic_random_access_file class templates so that we have a common place to
+/// define flags.
+class file_base
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// A bitmask type (C++ Std [lib.bitmask.types]).
+  typedef unspecified flags;
+
+  /// Open the file for reading.
+  static const flags read_only = implementation_defined;
+
+  /// Open the file for writing.
+  static const flags write_only = implementation_defined;
+
+  /// Open the file for reading and writing.
+  static const flags read_write = implementation_defined;
+
+  /// Open the file in append mode.
+  static const flags append = implementation_defined;
+
+  /// Create the file if it does not exist.
+  static const flags create = implementation_defined;
+
+  /// Ensure a new file is created. Must be combined with @c create.
+  static const flags exclusive = implementation_defined;
+
+  /// Open the file with any existing contents truncated.
+  static const flags truncate = implementation_defined;
+
+  /// Open the file so that write operations automatically synchronise the file
+  /// data and metadata to disk.
+  static const flags sync_all_on_write = implementation_defined;
+#else
+  enum flags
+  {
+#if defined(BOOST_ASIO_WINDOWS)
+    read_only = 1,
+    write_only = 2,
+    read_write = 4,
+    append = 8,
+    create = 16,
+    exclusive = 32,
+    truncate = 64,
+    sync_all_on_write = 128
+#else // defined(BOOST_ASIO_WINDOWS)
+    read_only = O_RDONLY,
+    write_only = O_WRONLY,
+    read_write = O_RDWR,
+    append = O_APPEND,
+    create = O_CREAT,
+    exclusive = O_EXCL,
+    truncate = O_TRUNC,
+    sync_all_on_write = O_SYNC
+#endif // defined(BOOST_ASIO_WINDOWS)
+  };
+
+  // Implement bitmask operations as shown in C++ Std [lib.bitmask.types].
+
+  friend flags operator&(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
+  }
+
+  friend flags operator|(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
+  }
+
+  friend flags operator^(flags x, flags y)
+  {
+    return static_cast<flags>(
+        static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
+  }
+
+  friend flags operator~(flags x)
+  {
+    return static_cast<flags>(~static_cast<unsigned int>(x));
+  }
+
+  friend flags& operator&=(flags& x, flags y)
+  {
+    x = x & y;
+    return x;
+  }
+
+  friend flags& operator|=(flags& x, flags y)
+  {
+    x = x | y;
+    return x;
+  }
+
+  friend flags& operator^=(flags& x, flags y)
+  {
+    x = x ^ y;
+    return x;
+  }
+#endif
+
+  /// Basis for seeking in a file.
+  enum seek_basis
+  {
+#if defined(GENERATING_DOCUMENTATION)
+    /// Seek to an absolute position.
+    seek_set = implementation_defined,
+
+    /// Seek to an offset relative to the current file position.
+    seek_cur = implementation_defined,
+
+    /// Seek to an offset relative to the end of the file.
+    seek_end = implementation_defined
+#else
+    seek_set = SEEK_SET,
+    seek_cur = SEEK_CUR,
+    seek_end = SEEK_END
+#endif
+  };
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~file_base()
+  {
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_FILE)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_FILE_BASE_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/generic/basic_endpoint.hpp

@@ -2,7 +2,7 @@
 // generic/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/generic/datagram_protocol.hpp

@@ -2,7 +2,7 @@
 // generic/datagram_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/generic/detail/endpoint.hpp

@@ -2,7 +2,7 @@
 // generic/detail/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/generic/detail/impl/endpoint.ipp

@@ -2,7 +2,7 @@
 // generic/detail/impl/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/generic/raw_protocol.hpp

@@ -2,7 +2,7 @@
 // generic/raw_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/generic/seq_packet_protocol.hpp

@@ -2,7 +2,7 @@
 // generic/seq_packet_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/generic/stream_protocol.hpp

@@ -2,7 +2,7 @@
 // generic/stream_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/handler_alloc_hook.hpp

@@ -2,7 +2,7 @@
 // handler_alloc_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/handler_continuation_hook.hpp

@@ -2,7 +2,7 @@
 // handler_continuation_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/handler_invoke_hook.hpp

@@ -2,7 +2,7 @@
 // handler_invoke_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

data/src/cxx_supportlib/vendor-modified/boost/asio/high_resolution_timer.hpp

@@ -2,7 +2,7 @@
 // high_resolution_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)