summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/include/asio/execution/connect.hpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asio/include/asio/execution/connect.hpp')
-rw-r--r--3rdparty/asio/include/asio/execution/connect.hpp489
1 files changed, 489 insertions, 0 deletions
diff --git a/3rdparty/asio/include/asio/execution/connect.hpp b/3rdparty/asio/include/asio/execution/connect.hpp
new file mode 100644
index 00000000000..527f123294f
--- /dev/null
+++ b/3rdparty/asio/include/asio/execution/connect.hpp
@@ -0,0 +1,489 @@
+//
+// execution/connect.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2021 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_EXECUTION_CONNECT_HPP
+#define ASIO_EXECUTION_CONNECT_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/execution/detail/as_invocable.hpp"
+#include "asio/execution/detail/as_operation.hpp"
+#include "asio/execution/detail/as_receiver.hpp"
+#include "asio/execution/executor.hpp"
+#include "asio/execution/operation_state.hpp"
+#include "asio/execution/receiver.hpp"
+#include "asio/execution/sender.hpp"
+#include "asio/traits/connect_member.hpp"
+#include "asio/traits/connect_free.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+#if defined(GENERATING_DOCUMENTATION)
+
+namespace asio {
+namespace execution {
+
+/// A customisation point that connects a sender to a receiver.
+/**
+ * The name <tt>execution::connect</tt> denotes a customisation point object.
+ * For some subexpressions <tt>s</tt> and <tt>r</tt>, let <tt>S</tt> be a type
+ * such that <tt>decltype((s))</tt> is <tt>S</tt> and let <tt>R</tt> be a type
+ * such that <tt>decltype((r))</tt> is <tt>R</tt>. The expression
+ * <tt>execution::connect(s, r)</tt> is expression-equivalent to:
+ *
+ * @li <tt>s.connect(r)</tt>, if that expression is valid, if its type
+ * satisfies <tt>operation_state</tt>, and if <tt>S</tt> satisfies
+ * <tt>sender</tt>.
+ *
+ * @li Otherwise, <tt>connect(s, r)</tt>, if that expression is valid, if its
+ * type satisfies <tt>operation_state</tt>, and if <tt>S</tt> satisfies
+ * <tt>sender</tt>, with overload resolution performed in a context that
+ * includes the declaration <tt>void connect();</tt> and that does not include
+ * a declaration of <tt>execution::connect</tt>.
+ *
+ * @li Otherwise, <tt>as_operation{s, r}</tt>, if <tt>r</tt> is not an instance
+ * of <tt>as_receiver<F, S></tt> for some type <tt>F</tt>, and if
+ * <tt>receiver_of<R> && executor_of<remove_cvref_t<S>,
+ * as_invocable<remove_cvref_t<R>, S>></tt> is <tt>true</tt>, where
+ * <tt>as_operation</tt> is an implementation-defined class equivalent to
+ * @code template <class S, class R>
+ * struct as_operation
+ * {
+ * remove_cvref_t<S> e_;
+ * remove_cvref_t<R> r_;
+ * void start() noexcept try {
+ * execution::execute(std::move(e_),
+ * as_invocable<remove_cvref_t<R>, S>{r_});
+ * } catch(...) {
+ * execution::set_error(std::move(r_), current_exception());
+ * }
+ * }; @endcode
+ * and <tt>as_invocable</tt> is a class template equivalent to the following:
+ * @code template<class R>
+ * struct as_invocable
+ * {
+ * R* r_;
+ * explicit as_invocable(R& r) noexcept
+ * : r_(std::addressof(r)) {}
+ * as_invocable(as_invocable && other) noexcept
+ * : r_(std::exchange(other.r_, nullptr)) {}
+ * ~as_invocable() {
+ * if(r_)
+ * execution::set_done(std::move(*r_));
+ * }
+ * void operator()() & noexcept try {
+ * execution::set_value(std::move(*r_));
+ * r_ = nullptr;
+ * } catch(...) {
+ * execution::set_error(std::move(*r_), current_exception());
+ * r_ = nullptr;
+ * }
+ * };
+ * @endcode
+ *
+ * @li Otherwise, <tt>execution::connect(s, r)</tt> is ill-formed.
+ */
+inline constexpr unspecified connect = unspecified;
+
+/// A type trait that determines whether a @c connect expression is
+/// well-formed.
+/**
+ * Class template @c can_connect is a trait that is derived from
+ * @c true_type if the expression <tt>execution::connect(std::declval<S>(),
+ * std::declval<R>())</tt> is well formed; otherwise @c false_type.
+ */
+template <typename S, typename R>
+struct can_connect :
+ integral_constant<bool, automatically_determined>
+{
+};
+
+/// A type trait to determine the result of a @c connect expression.
+template <typename S, typename R>
+struct connect_result
+{
+ /// The type of the connect expression.
+ /**
+ * The type of the expression <tt>execution::connect(std::declval<S>(),
+ * std::declval<R>())</tt>.
+ */
+ typedef automatically_determined type;
+};
+
+/// A type alis to determine the result of a @c connect expression.
+template <typename S, typename R>
+using connect_result_t = typename connect_result<S, R>::type;
+
+} // namespace execution
+} // namespace asio
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+namespace asio_execution_connect_fn {
+
+using asio::conditional;
+using asio::declval;
+using asio::enable_if;
+using asio::execution::detail::as_invocable;
+using asio::execution::detail::as_operation;
+using asio::execution::detail::is_as_receiver;
+using asio::execution::is_executor_of;
+using asio::execution::is_operation_state;
+using asio::execution::is_receiver;
+using asio::execution::is_sender;
+using asio::false_type;
+using asio::remove_cvref;
+using asio::traits::connect_free;
+using asio::traits::connect_member;
+
+void connect();
+
+enum overload_type
+{
+ call_member,
+ call_free,
+ adapter,
+ ill_formed
+};
+
+template <typename S, typename R, typename = void,
+ typename = void, typename = void, typename = void>
+struct call_traits
+{
+ ASIO_STATIC_CONSTEXPR(overload_type, overload = ill_formed);
+ ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false);
+ typedef void result_type;
+};
+
+template <typename S, typename R>
+struct call_traits<S, void(R),
+ typename enable_if<
+ connect_member<S, R>::is_valid
+ >::type,
+ typename enable_if<
+ is_operation_state<typename connect_member<S, R>::result_type>::value
+ >::type,
+ typename enable_if<
+ is_sender<typename remove_cvref<S>::type>::value
+ >::type> :
+ connect_member<S, R>
+{
+ ASIO_STATIC_CONSTEXPR(overload_type, overload = call_member);
+};
+
+template <typename S, typename R>
+struct call_traits<S, void(R),
+ typename enable_if<
+ !connect_member<S, R>::is_valid
+ >::type,
+ typename enable_if<
+ connect_free<S, R>::is_valid
+ >::type,
+ typename enable_if<
+ is_operation_state<typename connect_free<S, R>::result_type>::value
+ >::type,
+ typename enable_if<
+ is_sender<typename remove_cvref<S>::type>::value
+ >::type> :
+ connect_free<S, R>
+{
+ ASIO_STATIC_CONSTEXPR(overload_type, overload = call_free);
+};
+
+template <typename S, typename R>
+struct call_traits<S, void(R),
+ typename enable_if<
+ !connect_member<S, R>::is_valid
+ >::type,
+ typename enable_if<
+ !connect_free<S, R>::is_valid
+ >::type,
+ typename enable_if<
+ is_receiver<R>::value
+ >::type,
+ typename enable_if<
+ conditional<
+ !is_as_receiver<
+ typename remove_cvref<R>::type
+ >::value,
+ is_executor_of<
+ typename remove_cvref<S>::type,
+ as_invocable<typename remove_cvref<R>::type, S>
+ >,
+ false_type
+ >::type::value
+ >::type>
+{
+ ASIO_STATIC_CONSTEXPR(overload_type, overload = adapter);
+ ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false);
+ typedef as_operation<S, R> result_type;
+};
+
+struct impl
+{
+#if defined(ASIO_HAS_MOVE)
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<S, void(R)>::overload == call_member,
+ typename call_traits<S, void(R)>::result_type
+ >::type
+ operator()(S&& s, R&& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<S, void(R)>::is_noexcept))
+ {
+ return ASIO_MOVE_CAST(S)(s).connect(ASIO_MOVE_CAST(R)(r));
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<S, void(R)>::overload == call_free,
+ typename call_traits<S, void(R)>::result_type
+ >::type
+ operator()(S&& s, R&& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<S, void(R)>::is_noexcept))
+ {
+ return connect(ASIO_MOVE_CAST(S)(s), ASIO_MOVE_CAST(R)(r));
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<S, void(R)>::overload == adapter,
+ typename call_traits<S, void(R)>::result_type
+ >::type
+ operator()(S&& s, R&& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<S, void(R)>::is_noexcept))
+ {
+ return typename call_traits<S, void(R)>::result_type(
+ ASIO_MOVE_CAST(S)(s), ASIO_MOVE_CAST(R)(r));
+ }
+#else // defined(ASIO_HAS_MOVE)
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<S&, void(R&)>::overload == call_member,
+ typename call_traits<S&, void(R&)>::result_type
+ >::type
+ operator()(S& s, R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<S&, void(R&)>::is_noexcept))
+ {
+ return s.connect(r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<const S&, void(R&)>::overload == call_member,
+ typename call_traits<const S&, void(R&)>::result_type
+ >::type
+ operator()(const S& s, R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<const S&, void(R&)>::is_noexcept))
+ {
+ return s.connect(r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<S&, void(R&)>::overload == call_free,
+ typename call_traits<S&, void(R&)>::result_type
+ >::type
+ operator()(S& s, R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<S&, void(R&)>::is_noexcept))
+ {
+ return connect(s, r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<const S&, void(R&)>::overload == call_free,
+ typename call_traits<const S&, void(R&)>::result_type
+ >::type
+ operator()(const S& s, R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<const S&, void(R&)>::is_noexcept))
+ {
+ return connect(s, r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<S&, void(R&)>::overload == adapter,
+ typename call_traits<S&, void(R&)>::result_type
+ >::type
+ operator()(S& s, R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<S&, void(R&)>::is_noexcept))
+ {
+ return typename call_traits<S&, void(R&)>::result_type(s, r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<const S&, void(R&)>::overload == adapter,
+ typename call_traits<const S&, void(R&)>::result_type
+ >::type
+ operator()(const S& s, R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<const S&, void(R&)>::is_noexcept))
+ {
+ return typename call_traits<const S&, void(R&)>::result_type(s, r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<S&, void(const R&)>::overload == call_member,
+ typename call_traits<S&, void(const R&)>::result_type
+ >::type
+ operator()(S& s, const R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<S&, void(const R&)>::is_noexcept))
+ {
+ return s.connect(r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<const S&, void(const R&)>::overload == call_member,
+ typename call_traits<const S&, void(const R&)>::result_type
+ >::type
+ operator()(const S& s, const R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<const S&, void(const R&)>::is_noexcept))
+ {
+ return s.connect(r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<S&, void(const R&)>::overload == call_free,
+ typename call_traits<S&, void(const R&)>::result_type
+ >::type
+ operator()(S& s, const R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<S&, void(const R&)>::is_noexcept))
+ {
+ return connect(s, r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<const S&, void(const R&)>::overload == call_free,
+ typename call_traits<const S&, void(const R&)>::result_type
+ >::type
+ operator()(const S& s, const R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<const S&, void(const R&)>::is_noexcept))
+ {
+ return connect(s, r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<S&, void(const R&)>::overload == adapter,
+ typename call_traits<S&, void(const R&)>::result_type
+ >::type
+ operator()(S& s, const R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<S&, void(const R&)>::is_noexcept))
+ {
+ return typename call_traits<S&, void(const R&)>::result_type(s, r);
+ }
+
+ template <typename S, typename R>
+ ASIO_CONSTEXPR typename enable_if<
+ call_traits<const S&, void(const R&)>::overload == adapter,
+ typename call_traits<const S&, void(const R&)>::result_type
+ >::type
+ operator()(const S& s, const R& r) const
+ ASIO_NOEXCEPT_IF((
+ call_traits<const S&, void(const R&)>::is_noexcept))
+ {
+ return typename call_traits<const S&, void(const R&)>::result_type(s, r);
+ }
+#endif // defined(ASIO_HAS_MOVE)
+};
+
+template <typename T = impl>
+struct static_instance
+{
+ static const T instance;
+};
+
+template <typename T>
+const T static_instance<T>::instance = {};
+
+} // namespace asio_execution_connect_fn
+namespace asio {
+namespace execution {
+namespace {
+
+static ASIO_CONSTEXPR const asio_execution_connect_fn::impl&
+ connect = asio_execution_connect_fn::static_instance<>::instance;
+
+} // namespace
+
+template <typename S, typename R>
+struct can_connect :
+ integral_constant<bool,
+ asio_execution_connect_fn::call_traits<S, void(R)>::overload !=
+ asio_execution_connect_fn::ill_formed>
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename S, typename R>
+constexpr bool can_connect_v = can_connect<S, R>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename S, typename R>
+struct is_nothrow_connect :
+ integral_constant<bool,
+ asio_execution_connect_fn::call_traits<S, void(R)>::is_noexcept>
+{
+};
+
+#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename S, typename R>
+constexpr bool is_nothrow_connect_v
+ = is_nothrow_connect<S, R>::value;
+
+#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
+
+template <typename S, typename R>
+struct connect_result
+{
+ typedef typename asio_execution_connect_fn::call_traits<
+ S, void(R)>::result_type type;
+};
+
+#if defined(ASIO_HAS_ALIAS_TEMPLATES)
+
+template <typename S, typename R>
+using connect_result_t = typename connect_result<S, R>::type;
+
+#endif // defined(ASIO_HAS_ALIAS_TEMPLATES)
+
+} // namespace execution
+} // namespace asio
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXECUTION_CONNECT_HPP