From 4a4e232c5aa0d07862fae55ad2606538d23dbbf0 Mon Sep 17 00:00:00 2001
From: "Andrew Dolder P.E" <andrew@vitaltrades.com>
Date: Fri, 2 Apr 2021 12:15:04 -0500
Subject: [PATCH] Add files via upload

---
 asio/include/asio/detail/work_dispatcher.hpp | 148 +++++++++
 asio/include/asio/detail/wrapped_handler.hpp | 327 +++++++++++++++++++
 2 files changed, 475 insertions(+)
 create mode 100644 asio/include/asio/detail/work_dispatcher.hpp
 create mode 100644 asio/include/asio/detail/wrapped_handler.hpp

diff --git a/asio/include/asio/detail/work_dispatcher.hpp b/asio/include/asio/detail/work_dispatcher.hpp
new file mode 100644
index 0000000..5b4433d
--- /dev/null
+++ b/asio/include/asio/detail/work_dispatcher.hpp
@@ -0,0 +1,148 @@
+//
+// detail/work_dispatcher.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2020 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 ASIO_DETAIL_WORK_DISPATCHER_HPP
+#define ASIO_DETAIL_WORK_DISPATCHER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/associated_executor.hpp"
+#include "asio/associated_allocator.hpp"
+#include "asio/executor_work_guard.hpp"
+#include "asio/execution/executor.hpp"
+#include "asio/execution/allocator.hpp"
+#include "asio/execution/blocking.hpp"
+#include "asio/execution/outstanding_work.hpp"
+#include "asio/prefer.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Handler, typename Executor, typename = void>
+struct is_work_dispatcher_required : true_type
+{
+};
+
+template <typename Handler, typename Executor>
+struct is_work_dispatcher_required<Handler, Executor,
+    typename enable_if<
+      is_same<
+        typename associated_executor<Handler,
+          Executor>::asio_associated_executor_is_unspecialised,
+        void
+      >::value
+    >::type> : false_type
+{
+};
+
+template <typename Handler, typename Executor, typename = void>
+class work_dispatcher
+{
+public:
+  template <typename CompletionHandler>
+  work_dispatcher(ASIO_MOVE_ARG(CompletionHandler) handler,
+      const Executor& handler_ex)
+    : handler_(ASIO_MOVE_CAST(CompletionHandler)(handler)),
+      executor_(asio::prefer(handler_ex,
+          execution::outstanding_work.tracked))
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  work_dispatcher(const work_dispatcher& other)
+    : handler_(other.handler_),
+      executor_(other.executor_)
+  {
+  }
+
+  work_dispatcher(work_dispatcher&& other)
+    : handler_(ASIO_MOVE_CAST(Handler)(other.handler_)),
+      executor_(ASIO_MOVE_CAST(work_executor_type)(other.executor_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  void operator()()
+  {
+    execution::execute(
+        asio::prefer(executor_,
+          execution::blocking.possibly,
+          execution::allocator((get_associated_allocator)(handler_))),
+        ASIO_MOVE_CAST(Handler)(handler_));
+  }
+
+private:
+  typedef typename decay<
+      typename prefer_result<const Executor&,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type work_executor_type;
+
+  Handler handler_;
+  work_executor_type executor_;
+};
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
+template <typename Handler, typename Executor>
+class work_dispatcher<Handler, Executor,
+    typename enable_if<!execution::is_executor<Executor>::value>::type>
+{
+public:
+  template <typename CompletionHandler>
+  work_dispatcher(ASIO_MOVE_ARG(CompletionHandler) handler,
+      const Executor& handler_ex)
+    : work_(handler_ex),
+      handler_(ASIO_MOVE_CAST(CompletionHandler)(handler))
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  work_dispatcher(const work_dispatcher& other)
+    : work_(other.work_),
+      handler_(other.handler_)
+  {
+  }
+
+  work_dispatcher(work_dispatcher&& other)
+    : work_(ASIO_MOVE_CAST(executor_work_guard<Executor>)(other.work_)),
+      handler_(ASIO_MOVE_CAST(Handler)(other.handler_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  void operator()()
+  {
+    typename associated_allocator<Handler>::type alloc(
+        (get_associated_allocator)(handler_));
+    work_.get_executor().dispatch(
+        ASIO_MOVE_CAST(Handler)(handler_), alloc);
+    work_.reset();
+  }
+
+private:
+  executor_work_guard<Executor> work_;
+  Handler handler_;
+};
+
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_WORK_DISPATCHER_HPP
diff --git a/asio/include/asio/detail/wrapped_handler.hpp b/asio/include/asio/detail/wrapped_handler.hpp
new file mode 100644
index 0000000..b1aed8b
--- /dev/null
+++ b/asio/include/asio/detail/wrapped_handler.hpp
@@ -0,0 +1,327 @@
+//
+// detail/wrapped_handler.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2020 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 ASIO_DETAIL_WRAPPED_HANDLER_HPP
+#define ASIO_DETAIL_WRAPPED_HANDLER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/bind_handler.hpp"
+#include "asio/detail/handler_alloc_helpers.hpp"
+#include "asio/detail/handler_cont_helpers.hpp"
+#include "asio/detail/handler_invoke_helpers.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+struct is_continuation_delegated
+{
+  template <typename Dispatcher, typename Handler>
+  bool operator()(Dispatcher&, Handler& handler) const
+  {
+    return asio_handler_cont_helpers::is_continuation(handler);
+  }
+};
+
+struct is_continuation_if_running
+{
+  template <typename Dispatcher, typename Handler>
+  bool operator()(Dispatcher& dispatcher, Handler&) const
+  {
+    return dispatcher.running_in_this_thread();
+  }
+};
+
+template <typename Dispatcher, typename Handler,
+    typename IsContinuation = is_continuation_delegated>
+class wrapped_handler
+{
+public:
+  typedef void result_type;
+
+  wrapped_handler(Dispatcher dispatcher, Handler& handler)
+    : dispatcher_(dispatcher),
+      handler_(ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  wrapped_handler(const wrapped_handler& other)
+    : dispatcher_(other.dispatcher_),
+      handler_(other.handler_)
+  {
+  }
+
+  wrapped_handler(wrapped_handler&& other)
+    : dispatcher_(other.dispatcher_),
+      handler_(ASIO_MOVE_CAST(Handler)(other.handler_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  void operator()()
+  {
+    dispatcher_.dispatch(ASIO_MOVE_CAST(Handler)(handler_));
+  }
+
+  void operator()() const
+  {
+    dispatcher_.dispatch(handler_);
+  }
+
+  template <typename Arg1>
+  void operator()(const Arg1& arg1)
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
+  }
+
+  template <typename Arg1>
+  void operator()(const Arg1& arg1) const
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
+  }
+
+  template <typename Arg1, typename Arg2>
+  void operator()(const Arg1& arg1, const Arg2& arg2)
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
+  }
+
+  template <typename Arg1, typename Arg2>
+  void operator()(const Arg1& arg1, const Arg2& arg2) const
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3>
+  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3>
+  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) const
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
+      const Arg4& arg4)
+  {
+    dispatcher_.dispatch(
+        detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
+      const Arg4& arg4) const
+  {
+    dispatcher_.dispatch(
+        detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+      typename Arg5>
+  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
+      const Arg4& arg4, const Arg5& arg5)
+  {
+    dispatcher_.dispatch(
+        detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+      typename Arg5>
+  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
+      const Arg4& arg4, const Arg5& arg5) const
+  {
+    dispatcher_.dispatch(
+        detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
+  }
+
+//private:
+  Dispatcher dispatcher_;
+  Handler handler_;
+};
+
+template <typename Handler, typename Context>
+class rewrapped_handler
+{
+public:
+  explicit rewrapped_handler(Handler& handler, const Context& context)
+    : context_(context),
+      handler_(ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+  explicit rewrapped_handler(const Handler& handler, const Context& context)
+    : context_(context),
+      handler_(handler)
+  {
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  rewrapped_handler(const rewrapped_handler& other)
+    : context_(other.context_),
+      handler_(other.handler_)
+  {
+  }
+
+  rewrapped_handler(rewrapped_handler&& other)
+    : context_(ASIO_MOVE_CAST(Context)(other.context_)),
+      handler_(ASIO_MOVE_CAST(Handler)(other.handler_))
+  {
+  }
+#endif // defined(ASIO_HAS_MOVE)
+
+  void operator()()
+  {
+    handler_();
+  }
+
+  void operator()() const
+  {
+    handler_();
+  }
+
+//private:
+  Context context_;
+  Handler handler_;
+};
+
+template <typename Dispatcher, typename Handler, typename IsContinuation>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
+{
+#if defined(ASIO_NO_DEPRECATED)
+  asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(ASIO_NO_DEPRECATED)
+  return asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(ASIO_NO_DEPRECATED)
+}
+
+template <typename Dispatcher, typename Handler, typename IsContinuation>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
+{
+  asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
+}
+
+template <typename Dispatcher, typename Handler, typename IsContinuation>
+inline bool asio_handler_is_continuation(
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
+{
+  return IsContinuation()(this_handler->dispatcher_, this_handler->handler_);
+}
+
+template <typename Function, typename Dispatcher,
+    typename Handler, typename IsContinuation>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
+{
+  this_handler->dispatcher_.dispatch(
+      rewrapped_handler<Function, Handler>(
+        function, this_handler->handler_));
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Dispatcher,
+    typename Handler, typename IsContinuation>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
+{
+  this_handler->dispatcher_.dispatch(
+      rewrapped_handler<Function, Handler>(
+        function, this_handler->handler_));
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler, typename Context>
+inline asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size,
+    rewrapped_handler<Handler, Context>* this_handler)
+{
+#if defined(ASIO_NO_DEPRECATED)
+  asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+  return asio_handler_allocate_is_no_longer_used();
+#else // defined(ASIO_NO_DEPRECATED)
+  return asio_handler_alloc_helpers::allocate(
+      size, this_handler->handler_);
+#endif // defined(ASIO_NO_DEPRECATED)
+}
+
+template <typename Handler, typename Context>
+inline asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size,
+    rewrapped_handler<Handler, Context>* this_handler)
+{
+  asio_handler_alloc_helpers::deallocate(
+      pointer, size, this_handler->context_);
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
+}
+
+template <typename Dispatcher, typename Context>
+inline bool asio_handler_is_continuation(
+    rewrapped_handler<Dispatcher, Context>* this_handler)
+{
+  return asio_handler_cont_helpers::is_continuation(
+      this_handler->context_);
+}
+
+template <typename Function, typename Handler, typename Context>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function,
+    rewrapped_handler<Handler, Context>* this_handler)
+{
+  asio_handler_invoke_helpers::invoke(
+      function, this_handler->context_);
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
+}
+
+template <typename Function, typename Handler, typename Context>
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function,
+    rewrapped_handler<Handler, Context>* this_handler)
+{
+  asio_handler_invoke_helpers::invoke(
+      function, this_handler->context_);
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
+}
+
+} // namespace detail
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_DETAIL_WRAPPED_HANDLER_HPP