passenger 6.0.26 → 6.1.0

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

@@ -1,226 +0,0 @@
-//
-// experimental/promise.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 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)
-//
-
-#ifndef BOOST_ASIO_EXPERIMENTAL_PROMISE_HPP
-#define BOOST_ASIO_EXPERIMENTAL_PROMISE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-#include <boost/asio/detail/type_traits.hpp>
-#include <boost/asio/any_io_executor.hpp>
-#include <boost/asio/associated_cancellation_slot.hpp>
-#include <boost/asio/associated_executor.hpp>
-#include <boost/asio/bind_executor.hpp>
-#include <boost/asio/cancellation_signal.hpp>
-#include <boost/asio/dispatch.hpp>
-#include <boost/asio/experimental/impl/promise.hpp>
-#include <boost/asio/post.hpp>
-
-#include <algorithm>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace experimental {
-
-template <typename T>
-struct is_promise : std::false_type {};
-
-template <typename ... Ts>
-struct is_promise<promise<Ts...>> : std::true_type {};
-
-template <typename T>
-constexpr bool is_promise_v = is_promise<T>::value;
-
-template <typename ... Ts>
-struct promise_value_type
-{
-  using type = std::tuple<Ts...>;
-};
-
-template <typename T>
-struct promise_value_type<T>
-{
-  using type = T;
-};
-
-template <>
-struct promise_value_type<>
-{
-  using type = std::tuple<>;
-};
-
-#if defined(GENERATING_DOCUMENTATION)
-/// A disposable handle for an eager operation.
-/**
- * @tparam Signature The signature of the operation.
- *
- * @tparam Executor The executor to be used by the promise (taken from the
- * operation).
- *
- * @tparam Allocator The allocator used for the promise. Can be set through
- * use_allocator.
- *
- * A promise can be used to initiate an asynchronous option that can be
- * completed later. If the promise gets destroyed before completion, the
- * operation gets a cancel signal and the result is ignored.
- *
- * A promise fulfills the requirements of async_operation.
- *
- * @par Examples
- * Reading and writing from one coroutine.
- * @code
- * awaitable<void> read_write_some(boost::asio::ip::tcp::socket & sock,
- *     boost::asio::mutable_buffer read_buf, boost::asio::const_buffer to_write)
- * {
- *   auto p = boost::asio::async_read(read_buf,
- *       boost::asio::experimental::use_promise);
- *   co_await boost::asio::async_write_some(to_write);
- *   co_await p;
- * }
- * @endcode
- */
-template<typename Signature = void(),
-    typename Executor = boost::asio::any_io_executor,
-    typename Allocator = std::allocator<void>>
-struct promise
-#else
-template <typename ... Ts, typename Executor, typename Allocator>
-struct promise<void(Ts...), Executor,  Allocator>
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-  /// The value that's returned by the promise.
-  using value_type = typename promise_value_type<Ts...>::type;
-
-  /// Cancel the promise. Usually done through the destructor.
-  void cancel(cancellation_type level = cancellation_type::all)
-  {
-    if (impl_ && !impl_->done)
-    {
-      boost::asio::dispatch(impl_->executor,
-          [level, impl = impl_]{ impl->cancel.emit(level); });
-    }
-  }
-
-  /// Check if the promise is completed already.
-  bool completed() const noexcept
-  {
-    return impl_ && impl_->done;
-  }
-
-  /// Wait for the promise to become ready.
-  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void(Ts...)) CompletionToken>
-  inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void(Ts...))
-  operator()(CompletionToken&& token)
-  {
-    assert(impl_);
-
-    return async_initiate<CompletionToken, void(Ts...)>(
-        initiate_async_wait{impl_}, token);
-  }
-
-  promise() = delete;
-  promise(const promise& ) = delete;
-  promise(promise&& ) noexcept = default;
-
-  /// Destruct the promise and cancel the operation.
-  /**
-   * It is safe to destruct a promise of a promise that didn't complete.
-   */
-  ~promise() { cancel(); }
-
-private:
-#if !defined(GENERATING_DOCUMENTATION)
-  template <typename, typename, typename> friend struct promise;
-  friend struct detail::promise_handler<void(Ts...), Executor, Allocator>;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  std::shared_ptr<detail::promise_impl<
-    void(Ts...), Executor, Allocator>> impl_;
-
-  promise(
-      std::shared_ptr<detail::promise_impl<
-        void(Ts...), Executor, Allocator>> impl)
-    : impl_(impl)
-  {
-  }
-
-  struct initiate_async_wait
-  {
-    std::shared_ptr<detail::promise_impl<
-      void(Ts...), Executor, Allocator>> self_;
-
-    template <typename WaitHandler>
-    void operator()(WaitHandler&& handler) const
-    {
-      const auto alloc = get_associated_allocator(
-          handler, self_->get_allocator());
-
-      auto cancel = get_associated_cancellation_slot(handler);
-
-      if (self_->done)
-      {
-        auto exec = boost::asio::get_associated_executor(
-            handler, self_->get_executor());
-
-        boost::asio::post(exec,
-            [self = std::move(self_),
-              handler = std::forward<WaitHandler>(handler)]() mutable
-            {
-              self->apply(std::move(handler));
-            });
-      }
-      else
-      {
-        if (cancel.is_connected())
-        {
-          struct cancel_handler
-          {
-            std::weak_ptr<detail::promise_impl<
-              void(Ts...), Executor, Allocator>> self;
-
-            cancel_handler(
-                std::weak_ptr<detail::promise_impl<
-                  void(Ts...), Executor, Allocator>> self)
-              : self(std::move(self))
-            {
-            }
-
-            void operator()(cancellation_type level) const
-            {
-              if (auto p = self.lock())
-              {
-                p->cancel.emit(level);
-                p->cancel_();
-              }
-            }
-          };
-          cancel.template emplace<cancel_handler>(self_);
-        }
-
-        self_->set_completion(alloc, std::forward<WaitHandler>(handler));
-      }
-    }
-  };
-};
-
-} // namespace experimental
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_EXPERIMENTAL_PROMISE_HPP

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

@@ -1,191 +0,0 @@
-//
-// experimental/use_coro.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 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)
-//
-
-#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 <memory>
-#include <boost/asio/deferred.hpp>
-#include <boost/asio/detail/source_location.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-
-class any_io_executor;
-
-namespace experimental {
-
-/// A @ref completion_token that creates another coro for the task completion.
-/**
- * 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.
- *
- * Note that this token is not the most efficient (use the default completion
- * token @c boost::asio::deferred for that) but does provide type erasure, as it
- * will always return a @c coro.
- */
-template <typename Allocator = std::allocator<void>>
-struct use_coro_t
-{
-
-  /// The allocator type. The allocator is used when constructing the
-  /// @c std::promise object for a given asynchronous operation.
-  typedef Allocator allocator_type;
-
-  /// Default constructor.
-  constexpr use_coro_t(
-      allocator_type allocator = allocator_type{}
-#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)
-    )
-    : allocator_(allocator)
-#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)
-  {
-  }
-
-  /// Specify an alternate allocator.
-  template <typename OtherAllocator>
-  use_coro_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
-  {
-    return use_future_t<OtherAllocator>(allocator);
-  }
-
-  /// Obtain allocator.
-  allocator_type get_allocator() const
-  {
-    return allocator_;
-  }
-
-  /// Constructor used to specify file name, line, and function name.
-  constexpr use_coro_t(const char* file_name,
-      int line, const char* function_name,
-      allocator_type allocator = allocator_type{}) :
-#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-      file_name_(file_name),
-      line_(line),
-      function_name_(function_name),
-#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-      allocator_(allocator)
-  {
-#if !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-    (void)file_name;
-    (void)line;
-    (void)function_name;
-#endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-  }
-
-  /// Adapts an executor to add the @c use_coro_t completion token as the
-  /// default.
-  template <typename InnerExecutor>
-  struct executor_with_default : InnerExecutor
-  {
-    /// 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,
-        constraint_t<
-          conditional_t<
-            !is_same<InnerExecutor1, executor_with_default>::value,
-            is_convertible<InnerExecutor1, InnerExecutor>,
-            false_type
-          >::value
-        > = 0) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-  };
-
-  /// Type alias to adapt an I/O object to use @c use_coro_t as its
-  /// default completion token type.
-  template <typename T>
-  using as_default_on_t = typename T::template rebind_executor<
-      executor_with_default<typename T::executor_type>>::other;
-
-  /// 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<T>::template rebind_executor<
-      executor_with_default<typename decay_t<T>::executor_type>
-    >::other
-  as_default_on(T&& object)
-  {
-    return typename decay_t<T>::template rebind_executor<
-        executor_with_default<typename decay_t<T>::executor_type>
-      >::other(static_cast<T&&>(object));
-  }
-
-#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-  const char* file_name_;
-  int line_;
-  const char* function_name_;
-#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-
-private:
-  Allocator allocator_;
-};
-
-/// 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)
-BOOST_ASIO_INLINE_VARIABLE constexpr use_coro_t<> use_coro;
-#else
-BOOST_ASIO_INLINE_VARIABLE constexpr 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/experimental/use_promise.hpp

@@ -1,113 +0,0 @@
-//
-// experimental/use_promise.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 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)
-//
-
-#ifndef BOOST_ASIO_EXPERIMENTAL_USE_PROMISE_HPP
-#define BOOST_ASIO_EXPERIMENTAL_USE_PROMISE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-#include <memory>
-#include <boost/asio/detail/type_traits.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace experimental {
-
-template <typename Allocator = std::allocator<void>>
-struct use_promise_t
-{
-  /// The allocator type. The allocator is used when constructing the
-  /// @c promise object for a given asynchronous operation.
-  typedef Allocator allocator_type;
-
-  /// Construct using default-constructed allocator.
-  constexpr use_promise_t()
-  {
-  }
-
-  /// Construct using specified allocator.
-  explicit use_promise_t(const Allocator& allocator)
-    : allocator_(allocator)
-  {
-  }
-
-  /// Obtain allocator.
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_;
-  }
-
-  /// Adapts an executor to add the @c use_promise_t completion token as the
-  /// default.
-  template <typename InnerExecutor>
-  struct executor_with_default : InnerExecutor
-  {
-    /// Specify @c use_promise_t as the default completion token type.
-    typedef use_promise_t<Allocator> default_completion_token_type;
-
-    /// Construct the adapted executor from the inner executor type.
-    executor_with_default(const InnerExecutor& ex) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-
-    /// Convert the specified executor to the inner executor type, then use
-    /// that to construct the adapted executor.
-    template <typename OtherExecutor>
-    executor_with_default(const OtherExecutor& ex,
-        constraint_t<
-          is_convertible<OtherExecutor, InnerExecutor>::value
-        > = 0) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-  };
-
-  /// Function helper to adapt an I/O object to use @c use_promise_t as its
-  /// default completion token type.
-  template <typename T>
-  static typename decay_t<T>::template rebind_executor<
-      executor_with_default<typename decay_t<T>::executor_type>
-    >::other
-  as_default_on(T&& object)
-  {
-    return typename decay_t<T>::template rebind_executor<
-        executor_with_default<typename decay_t<T>::executor_type>
-      >::other(static_cast<T&&>(object));
-  }
-
-  /// Specify an alternate allocator.
-  template <typename OtherAllocator>
-  use_promise_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
-  {
-    return use_promise_t<OtherAllocator>(allocator);
-  }
-
-private:
-  Allocator allocator_;
-};
-
-BOOST_ASIO_INLINE_VARIABLE constexpr use_promise_t<> use_promise;
-
-} // namespace experimental
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#include <boost/asio/experimental/impl/use_promise.hpp>
-
-#endif // BOOST_ASIO_EXPERIMENTAL_USE_CORO_HPP

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

@@ -1,168 +0,0 @@
-//
-// file_base.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 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