FM / asio

/usr/include/boost/asio

Name	Size	Mode	Actions
detail/	-	0755	rm
execution/	-	0755	rm
generic/	-	0755	rm
impl/	-	0755	rm
ip/	-	0755	rm
local/	-	0755	rm
posix/	-	0755	rm
ssl/	-	0755	rm
traits/	-	0755	rm
ts/	-	0755	rm
windows/	-	0755	rm
any_io_executor.hpp	2625	0644	edit dl rm
associated_allocator.hpp	3791	0644	edit dl rm
associated_executor.hpp	5057	0644	edit dl rm
async_result.hpp	19423	0644	edit dl rm
awaitable.hpp	3270	0644	edit dl rm
basic_datagram_socket.hpp	47521	0644	edit dl rm
basic_deadline_timer.hpp	24158	0644	edit dl rm
basic_io_object.hpp	8096	0644	edit dl rm
basic_raw_socket.hpp	46996	0644	edit dl rm
basic_seq_packet_socket.hpp	29184	0644	edit dl rm
basic_serial_port.hpp	31912	0644	edit dl rm
basic_signal_set.hpp	19876	0644	edit dl rm
basic_socket.hpp	65516	0644	edit dl rm
basic_socket_acceptor.hpp	88062	0644	edit dl rm
basic_socket_iostream.hpp	13298	0644	edit dl rm
basic_socket_streambuf.hpp	21713	0644	edit dl rm
basic_streambuf.hpp	13714	0644	edit dl rm
basic_streambuf_fwd.hpp	920	0644	edit dl rm
basic_stream_socket.hpp	41520	0644	edit dl rm
basic_waitable_timer.hpp	28528	0644	edit dl rm
bind_executor.hpp	16510	0644	edit dl rm
buffer.hpp	83254	0644	edit dl rm
buffered_read_stream.hpp	8424	0644	edit dl rm
buffered_read_stream_fwd.hpp	699	0644	edit dl rm
buffered_stream.hpp	9074	0644	edit dl rm
buffered_stream_fwd.hpp	669	0644	edit dl rm
buffered_write_stream.hpp	8042	0644	edit dl rm
buffered_write_stream_fwd.hpp	705	0644	edit dl rm
buffers_iterator.hpp	14049	0644	edit dl rm
completion_condition.hpp	5500	0644	edit dl rm
compose.hpp	4596	0644	edit dl rm
connect.hpp	43157	0644	edit dl rm
coroutine.hpp	9897	0644	edit dl rm
co_spawn.hpp	14509	0644	edit dl rm
deadline_timer.hpp	1138	0644	edit dl rm
defer.hpp	5070	0644	edit dl rm
detached.hpp	3517	0644	edit dl rm
dispatch.hpp	4537	0644	edit dl rm
error.hpp	10351	0644	edit dl rm
execution.hpp	1871	0644	edit dl rm
execution_context.hpp	14341	0644	edit dl rm
executor.hpp	10467	0644	edit dl rm
executor_work_guard.hpp	8039	0644	edit dl rm
handler_alloc_hook.hpp	3471	0644	edit dl rm
handler_continuation_hook.hpp	1474	0644	edit dl rm
handler_invoke_hook.hpp	3744	0644	edit dl rm
high_resolution_timer.hpp	1394	0644	edit dl rm
io_context.hpp	55226	0644	edit dl rm
io_context_strand.hpp	13706	0644	edit dl rm
io_service.hpp	861	0644	edit dl rm
io_service_strand.hpp	575	0644	edit dl rm
is_applicable_property.hpp	1605	0644	edit dl rm
is_executor.hpp	1306	0644	edit dl rm
is_read_buffered.hpp	1646	0644	edit dl rm
is_write_buffered.hpp	1667	0644	edit dl rm
multiple_exceptions.hpp	1631	0644	edit dl rm
packaged_task.hpp	3358	0644	edit dl rm
placeholders.hpp	4146	0644	edit dl rm
post.hpp	4760	0644	edit dl rm
prefer.hpp	18821	0644	edit dl rm
query.hpp	8323	0644	edit dl rm
read.hpp	53894	0644	edit dl rm
read_at.hpp	27766	0644	edit dl rm
read_until.hpp	119477	0644	edit dl rm
redirect_error.hpp	1938	0644	edit dl rm
require.hpp	14926	0644	edit dl rm
require_concept.hpp	9218	0644	edit dl rm
serial_port.hpp	1010	0644	edit dl rm
serial_port_base.hpp	4975	0644	edit dl rm
signal_set.hpp	748	0644	edit dl rm
socket_base.hpp	15939	0644	edit dl rm
spawn.hpp	11793	0644	edit dl rm
ssl.hpp	848	0644	edit dl rm
static_thread_pool.hpp	826	0644	edit dl rm
steady_timer.hpp	1306	0644	edit dl rm
strand.hpp	17193	0644	edit dl rm
streambuf.hpp	826	0644	edit dl rm
system_context.hpp	2649	0644	edit dl rm
system_executor.hpp	22529	0644	edit dl rm
system_timer.hpp	1306	0644	edit dl rm
this_coro.hpp	1149	0644	edit dl rm
thread_pool.hpp	37567	0644	edit dl rm
time_traits.hpp	2281	0644	edit dl rm
unyield.hpp	381	0644	edit dl rm
uses_executor.hpp	2348	0644	edit dl rm
use_awaitable.hpp	5821	0644	edit dl rm
use_future.hpp	4820	0644	edit dl rm
version.hpp	686	0644	edit dl rm
wait_traits.hpp	1451	0644	edit dl rm
write.hpp	52959	0644	edit dl rm
write_at.hpp	29514	0644	edit dl rm
yield.hpp	482	0644	edit dl rm

Edit: /usr/include/boost/asio/spawn.hpp (11793B)

//
// spawn.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 BOOST_ASIO_SPAWN_HPP
#define BOOST_ASIO_SPAWN_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/coroutine/all.hpp>
#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/bind_executor.hpp>
#include <boost/asio/detail/memory.hpp>
#include <boost/asio/detail/type_traits.hpp>
#include <boost/asio/detail/wrapped_handler.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/is_executor.hpp>
#include <boost/asio/strand.hpp>

#include <boost/asio/detail/push_options.hpp>

namespace boost {
namespace asio {

/// Context object the represents the currently executing coroutine.
/**
 * The basic_yield_context class is used to represent the currently executing
 * stackful coroutine. A basic_yield_context may be passed as a handler to an
 * asynchronous operation. For example:
 *
 * @code template <typename Handler>
 * void my_coroutine(basic_yield_context<Handler> yield)
 * {
 *   ...
 *   std::size_t n = my_socket.async_read_some(buffer, yield);
 *   ...
 * } @endcode
 *
 * The initiating function (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 Handler>
class basic_yield_context
{
public:
  /// The coroutine callee type, used by the implementation.
  /**
   * When using Boost.Coroutine v1, this type is:
   * @code typename coroutine<void()> @endcode
   * When using Boost.Coroutine v2 (unidirectional coroutines), this type is:
   * @code push_coroutine<void> @endcode
   */
#if defined(GENERATING_DOCUMENTATION)
  typedef implementation_defined callee_type;
#elif defined(BOOST_COROUTINES_UNIDIRECT) || defined(BOOST_COROUTINES_V2)
  typedef boost::coroutines::push_coroutine<void> callee_type;
#else
  typedef boost::coroutines::coroutine<void()> callee_type;
#endif
  
  /// The coroutine caller type, used by the implementation.
  /**
   * When using Boost.Coroutine v1, this type is:
   * @code typename coroutine<void()>::caller_type @endcode
   * When using Boost.Coroutine v2 (unidirectional coroutines), this type is:
   * @code pull_coroutine<void> @endcode
   */
#if defined(GENERATING_DOCUMENTATION)
  typedef implementation_defined caller_type;
#elif defined(BOOST_COROUTINES_UNIDIRECT) || defined(BOOST_COROUTINES_V2)
  typedef boost::coroutines::pull_coroutine<void> caller_type;
#else
  typedef boost::coroutines::coroutine<void()>::caller_type caller_type;
#endif

/// Construct a yield context to represent the specified coroutine.
  /**
   * Most applications do not need to use this constructor. Instead, the
   * spawn() function passes a yield context as an argument to the coroutine
   * function.
   */
  basic_yield_context(
      const detail::weak_ptr<callee_type>& coro,
      caller_type& ca, Handler& handler)
    : coro_(coro),
      ca_(ca),
      handler_(handler),
      ec_(0)
  {
  }

/// Construct a yield context from another yield context type.
  /**
   * Requires that OtherHandler be convertible to Handler.
   */
  template <typename OtherHandler>
  basic_yield_context(const basic_yield_context<OtherHandler>& other)
    : coro_(other.coro_),
      ca_(other.ca_),
      handler_(other.handler_),
      ec_(other.ec_)
  {
  }

/// Return a yield context that sets the specified error_code.
  /**
   * By default, when a yield context is used with an asynchronous operation, a
   * non-success error_code is converted to system_error and thrown. This
   * operator may be used to specify an error_code object that should instead be
   * set with the asynchronous operation's result. For example:
   *
   * @code template <typename Handler>
   * void my_coroutine(basic_yield_context<Handler> yield)
   * {
   *   ...
   *   std::size_t n = my_socket.async_read_some(buffer, yield[ec]);
   *   if (ec)
   *   {
   *     // An error occurred.
   *   }
   *   ...
   * } @endcode
   */
  basic_yield_context operator[](boost::system::error_code& ec) const
  {
    basic_yield_context tmp(*this);
    tmp.ec_ = &ec;
    return tmp;
  }

#if defined(GENERATING_DOCUMENTATION)
private:
#endif // defined(GENERATING_DOCUMENTATION)
  detail::weak_ptr<callee_type> coro_;
  caller_type& ca_;
  Handler handler_;
  boost::system::error_code* ec_;
};

#if defined(GENERATING_DOCUMENTATION)
/// Context object that represents the currently executing coroutine.
typedef basic_yield_context<unspecified> yield_context;
#else // defined(GENERATING_DOCUMENTATION)
typedef basic_yield_context<
  executor_binder<void(*)(), any_io_executor> > yield_context;
#endif // defined(GENERATING_DOCUMENTATION)

/**
 * @defgroup spawn boost::asio::spawn
 *
 * @brief Start a new stackful coroutine.
 *
 * The spawn() function is a high-level wrapper over the Boost.Coroutine
 * library. This function enables programs to implement asynchronous logic in a
 * synchronous manner, as illustrated by the following example:
 *
 * @code boost::asio::spawn(my_strand, do_echo);
 *
 * // ...
 *
 * void do_echo(boost::asio::yield_context yield)
 * {
 *   try
 *   {
 *     char data[128];
 *     for (;;)
 *     {
 *       std::size_t length =
 *         my_socket.async_read_some(
 *           boost::asio::buffer(data), yield);
 *
 *       boost::asio::async_write(my_socket,
 *           boost::asio::buffer(data, length), yield);
 *     }
 *   }
 *   catch (std::exception& e)
 *   {
 *     // ...
 *   }
 * } @endcode
 */
/*@{*/

/// Start a new stackful coroutine, calling the specified handler when it
/// completes.
/**
 * This function is used to launch a new coroutine.
 *
 * @param function The coroutine function. The function must have the signature:
 * @code void function(basic_yield_context<Handler> yield); @endcode
 *
 * @param attributes Boost.Coroutine attributes used to customise the coroutine.
 */
template <typename Function>
void spawn(BOOST_ASIO_MOVE_ARG(Function) function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes());

/// Start a new stackful coroutine, calling the specified handler when it
/// completes.
/**
 * This function is used to launch a new coroutine.
 *
 * @param handler A handler to be called when the coroutine exits. More
 * importantly, the handler provides an execution context (via the the handler
 * invocation hook) for the coroutine. The handler must have the signature:
 * @code void handler(); @endcode
 *
 * @param function The coroutine function. The function must have the signature:
 * @code void function(basic_yield_context<Handler> yield); @endcode
 *
 * @param attributes Boost.Coroutine attributes used to customise the coroutine.
 */
template <typename Handler, typename Function>
void spawn(BOOST_ASIO_MOVE_ARG(Handler) handler,
    BOOST_ASIO_MOVE_ARG(Function) function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes(),
    typename enable_if<
      !is_executor<typename decay<Handler>::type>::value &&
      !execution::is_executor<typename decay<Handler>::type>::value &&
      !is_convertible<Handler&, execution_context&>::value>::type* = 0);

/// Start a new stackful coroutine, inheriting the execution context of another.
/**
 * This function is used to launch a new coroutine.
 *
 * @param ctx Identifies the current coroutine as a parent of the new
 * coroutine. This specifies that the new coroutine should inherit the
 * execution context of the parent. For example, if the parent coroutine is
 * executing in a particular strand, then the new coroutine will execute in the
 * same strand.
 *
 * @param function The coroutine function. The function must have the signature:
 * @code void function(basic_yield_context<Handler> yield); @endcode
 *
 * @param attributes Boost.Coroutine attributes used to customise the coroutine.
 */
template <typename Handler, typename Function>
void spawn(basic_yield_context<Handler> ctx,
    BOOST_ASIO_MOVE_ARG(Function) function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes());

/// Start a new stackful coroutine that executes on a given executor.
/**
 * This function is used to launch a new coroutine.
 *
 * @param ex Identifies the executor that will run the coroutine. The new
 * coroutine is implicitly given its own strand within this executor.
 *
 * @param function The coroutine function. The function must have the signature:
 * @code void function(yield_context yield); @endcode
 *
 * @param attributes Boost.Coroutine attributes used to customise the coroutine.
 */
template <typename Function, typename Executor>
void spawn(const Executor& ex,
    BOOST_ASIO_MOVE_ARG(Function) function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes(),
    typename enable_if<
      is_executor<Executor>::value || execution::is_executor<Executor>::value
    >::type* = 0);

/// Start a new stackful coroutine that executes on a given strand.
/**
 * This function is used to launch a new coroutine.
 *
 * @param ex Identifies the strand that will run the coroutine.
 *
 * @param function The coroutine function. The function must have the signature:
 * @code void function(yield_context yield); @endcode
 *
 * @param attributes Boost.Coroutine attributes used to customise the coroutine.
 */
template <typename Function, typename Executor>
void spawn(const strand<Executor>& ex,
    BOOST_ASIO_MOVE_ARG(Function) function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes());

#if !defined(BOOST_ASIO_NO_TS_EXECUTORS)

/// Start a new stackful coroutine that executes in the context of a strand.
/**
 * This function is used to launch a new coroutine.
 *
 * @param s Identifies a strand. By starting multiple coroutines on the same
 * strand, the implementation ensures that none of those coroutines can execute
 * simultaneously.
 *
 * @param function The coroutine function. The function must have the signature:
 * @code void function(yield_context yield); @endcode
 *
 * @param attributes Boost.Coroutine attributes used to customise the coroutine.
 */
template <typename Function>
void spawn(const boost::asio::io_context::strand& s,
    BOOST_ASIO_MOVE_ARG(Function) function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes());

#endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)

/// Start a new stackful coroutine that executes on a given execution context.
/**
 * This function is used to launch a new coroutine.
 *
 * @param ctx Identifies the execution context that will run the coroutine. The
 * new coroutine is implicitly given its own strand within this execution
 * context.
 *
 * @param function The coroutine function. The function must have the signature:
 * @code void function(yield_context yield); @endcode
 *
 * @param attributes Boost.Coroutine attributes used to customise the coroutine.
 */
template <typename Function, typename ExecutionContext>
void spawn(ExecutionContext& ctx,
    BOOST_ASIO_MOVE_ARG(Function) function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes(),
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type* = 0);

/*@}*/

} // namespace asio
} // namespace boost

#include <boost/asio/detail/pop_options.hpp>

#include <boost/asio/impl/spawn.hpp>

#endif // BOOST_ASIO_SPAWN_HPP

cmd: