async_accept(basic_socket<Protocol1, SocketService>& peer,
ASIO_MOVE_ARG(AcceptHandler) handler,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a AcceptHandler.
ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;
return this->get_service().async_accept(this->get_implementation(),
peer, static_cast<endpoint_type*>(0),
ASIO_MOVE_CAST(AcceptHandler)(handler));
}
* @code void handler(
* const asio::error_code& error, // Result of operation.
*
* std::size_t bytes_transferred // Number of bytes written from the
* // buffers. If an error occurred,
* // this will be less than the sum
* // of the buffer sizes.
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation of
* the handler will be performed in a manner equivalent to using
* asio::io_service::post().
*/
template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
ASIO_INITFN_RESULT_TYPE( WriteHandler, void( asio::error_code, std::size_t ) )
async_write( AsyncWriteStream& s, basic_streambuf<Allocator>& b, ASIO_MOVE_ARG( WriteHandler ) handler );
/// Start an asynchronous operation to write a certain amount of data to a
/// stream.
/**
* This function is used to asynchronously write a certain number of bytes of
* data to a stream. The function call always returns immediately. The
* asynchronous operation will continue until one of the following conditions
* is true:
*
* @li All of the data in the supplied basic_streambuf has been written.
*
* @li The completion_condition function object returns 0.
*
* This operation is implemented in terms of zero or more calls to the stream's
* async_write_some function, and is known as a <em>composed operation</em>. The
/**
* This function is used to ask the strand to execute the given function
* object on its underlying executor. The function object will be executed
* inside this function if the strand is not otherwise busy and if the
* underlying executor's @c dispatch() function is also able to execute the
* function before returning.
*
* @param f The function object to be called. The executor will make
* a copy of the handler object as required. The function signature of the
* function object must be: @code void function(); @endcode
*
* @param a An allocator that may be used by the executor to allocate the
* internal storage needed for function invocation.
*/
template <typename Function, typename Allocator>
void dispatch(ASIO_MOVE_ARG(Function) f, const Allocator& a)
{
detail::strand_executor_service::dispatch(impl_,
executor_, ASIO_MOVE_CAST(Function)(f), a);
}
/// Request the strand to invoke the given function object.
/**
* This function is used to ask the executor to execute the given function
* object. The function object will never be executed inside this function.
* Instead, it will be scheduled by the underlying executor's defer function.
*
* @param f The function object to be called. The executor will make
* a copy of the handler object as required. The function signature of the
* function object must be: @code void function(); @endcode
*
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation of
* the handler will be performed in a manner equivalent to using
* clmdep_asio::io_service::post().
*
* @note This overload is equivalent to calling:
* @code clmdep_asio::async_read(
* s, b,
* clmdep_asio::transfer_all(),
* handler); @endcode
*/
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
ASIO_INITFN_RESULT_TYPE(ReadHandler,
void (clmdep_asio::error_code, std::size_t))
async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
ASIO_MOVE_ARG(ReadHandler) handler);
/// Start an asynchronous operation to read a certain amount of data from a
/// stream.
/**
* This function is used to asynchronously read a certain number of bytes of
* data from a stream. The function call always returns immediately. The
* asynchronous operation will continue until one of the following conditions is
* true:
*
* @li The supplied buffer is full (that is, it has reached maximum size).
*
* @li The completion_condition function object returns 0.
*
* This operation is implemented in terms of zero or more calls to the stream's
* async_read_some function, and is known as a <em>composed operation</em>. The
/// Flush all data from the buffer to the next layer. Returns the number of
/// bytes written to the next layer on the last write operation. Throws an
/// exception on failure.
std::size_t flush();
/// Flush all data from the buffer to the next layer. Returns the number of
/// bytes written to the next layer on the last write operation, or 0 if an
/// error occurred.
std::size_t flush(asio::error_code& ec);
/// Start an asynchronous flush.
template <typename WriteHandler>
ASIO_INITFN_RESULT_TYPE(WriteHandler,
void (asio::error_code, std::size_t))
async_flush(ASIO_MOVE_ARG(WriteHandler) handler);
/// Write the given data to the stream. Returns the number of bytes written.
/// Throws an exception on failure.
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers);
/// Write the given data to the stream. Returns the number of bytes written,
/// or 0 if an error occurred and the error handler did not throw.
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
asio::error_code& ec);
/// Start an asynchronous write. The data being written must be valid for the
/// lifetime of the asynchronous operation.
template <typename ConstBufferSequence, typename WriteHandler>
inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
typename enable_if<
is_const_buffer_sequence<ConstBufferSequence>::value
>::type*)
{
asio::error_code ec;
std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
asio::detail::throw_error(ec, "write");
return bytes_transferred;
}
template <typename SyncWriteStream, typename DynamicBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
ASIO_MOVE_ARG(DynamicBufferSequence) buffers,
CompletionCondition completion_condition, asio::error_code& ec,
typename enable_if<
is_dynamic_buffer_sequence<DynamicBufferSequence>::value
>::type*)
{
typename decay<DynamicBufferSequence>::type b(
ASIO_MOVE_CAST(DynamicBufferSequence)(buffers));
std::size_t bytes_transferred = write(s, b.data(), completion_condition, ec);
b.consume(bytes_transferred);
return bytes_transferred;
}
template <typename SyncWriteStream, typename DynamicBufferSequence>
inline std::size_t write(SyncWriteStream& s,
* @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
* initializing the object as <tt>result(handler)</tt>.
*
* @li Obtains the handler's associated executor object @c ex by performing
* <tt>get_associated_executor(handler)</tt>.
*
* @li Obtains the handler's associated allocator object @c alloc by performing
* <tt>get_associated_allocator(handler)</tt>.
*
* @li Performs <tt>ex.post(std::move(handler), alloc)</tt>.
*
* @li Returns <tt>result.get()</tt>.
*/
template <typename CompletionToken>
ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) post(
ASIO_MOVE_ARG(CompletionToken) token);
/// Submits a completion token or function object for execution.
/**
* This function submits an object for execution using the specified executor.
* The function object is queued for execution, and is never called from the
* current thread prior to returning from <tt>post()</tt>.
*
* This function has the following effects:
*
* @li Constructs a function object handler of type @c Handler, initialized
* with <tt>handler(forward<CompletionToken>(token))</tt>.
*
* @li Constructs an object @c result of type <tt>async_result<Handler></tt>,
* initializing the object as <tt>result(handler)</tt>.
*
#include "asio/detail/recycling_allocator.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution_context.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
inline execution_context& system_executor::context() const ASIO_NOEXCEPT
{
return detail::global<context_impl>();
}
template <typename Function, typename Allocator>
void system_executor::dispatch(
ASIO_MOVE_ARG(Function) f, const Allocator&) const
{
typename decay<Function>::type tmp(ASIO_MOVE_CAST(Function)(f));
asio_handler_invoke_helpers::invoke(tmp, tmp);
}
template <typename Function, typename Allocator>
void system_executor::post(
ASIO_MOVE_ARG(Function) f, const Allocator& a) const
{
context_impl& ctx = detail::global<context_impl>();
// Make a local, non-const copy of the function.
typedef typename decay<Function>::type function_type;
function_type tmp(ASIO_MOVE_CAST(Function)(f));
*
* // ...
*
* void connect_handler(
* const asio::error_code& ec,
* tcp::resolver::iterator i)
* {
* // ...
* } @endcode
*/
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
ASIO_INITFN_RESULT_TYPE(ComposedConnectHandler,
void (asio::error_code, Iterator))
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ASIO_MOVE_ARG(ComposedConnectHandler) handler);
/// Asynchronously establishes a socket connection by trying each endpoint in a
/// sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c async_connect
* member function, once for each endpoint in the sequence, until a connection
* is successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param end An iterator pointing to the end of a sequence of endpoints.
};
// Helper to:
// - Apply the empty base optimisation to the executor.
// - Perform uses_executor construction of the target type, if required.
template <typename T, typename Executor, bool UsesExecutor>
class executor_binder_base;
template <typename T, typename Executor>
class executor_binder_base<T, Executor, true>
: protected Executor
{
protected:
template <typename E, typename U>
executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u)
: executor_(ASIO_MOVE_CAST(E)(e)),
target_(executor_arg_t(), executor_, ASIO_MOVE_CAST(U)(u))
{
}
Executor executor_;
T target_;
};
template <typename T, typename Executor>
class executor_binder_base<T, Executor, false>
{
protected:
template <typename E, typename U>
executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u)
* }
* }
*
* ...
*
* asio::ip::tcp::acceptor acceptor(io_service);
* ...
* acceptor.async_wait(
* asio::ip::tcp::acceptor::wait_read,
* wait_handler);
* @endcode
*/
template <typename WaitHandler>
ASIO_INITFN_RESULT_TYPE(WaitHandler,
void (asio::error_code))
async_wait(wait_type w, ASIO_MOVE_ARG(WaitHandler) handler)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a WaitHandler.
ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
return this->get_service().async_wait(this->get_implementation(),
w, ASIO_MOVE_CAST(WaitHandler)(handler));
}
/// Accept a new connection.
/**
* This function is used to accept a new connection from a peer into the
* given socket. The function call will block until a new connection has been
* accepted successfully or an error occurs.
*
/// Request the executor to invoke the given function object. /** * This function is used to ask the executor to execute the given function * object. The function object is executed according to the rules of the * target executor object. * * @param f The function object to be called. The executor will make a copy * of the handler object as required. The function signature of the function * object must be: @code void function(); @endcode * * @param a An allocator that may be used by the executor to allocate the * internal storage needed for function invocation. */ template <typename Function, typename Allocator> void dispatch(ASIO_MOVE_ARG(Function) f, const Allocator& a) const; /// Request the executor to invoke the given function object. /** * This function is used to ask the executor to execute the given function * object. The function object is executed according to the rules of the * target executor object. * * @param f The function object to be called. The executor will make * a copy of the handler object as required. The function signature of the * function object must be: @code void function(); @endcode * * @param a An allocator that may be used by the executor to allocate the * internal storage needed for function invocation. */ template <typename Function, typename Allocator>
* not, the handler will not be invoked from within this function. Invocation of
* the handler will be performed in a manner equivalent to using
* asio::io_context::post().
*
* @note This overload is equivalent to calling:
* @code asio::async_read_at(
* d, 42, b,
* asio::transfer_all(),
* handler); @endcode
*/
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename ReadHandler>
ASIO_INITFN_RESULT_TYPE(ReadHandler,
void (asio::error_code, std::size_t))
async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, ASIO_MOVE_ARG(ReadHandler) handler);
/// Start an asynchronous operation to read a certain amount of data at the
/// specified offset.
/**
* This function is used to asynchronously read a certain number of bytes of
* data from a random access device at the specified offset. The function call
* always returns immediately. The asynchronous operation will continue until
* one of the following conditions is true:
*
* @li The completion_condition function object returns 0.
*
* This operation is implemented in terms of zero or more calls to the device's
* async_read_some_at function.
*
* @param d The device from which the data is to be read. The type must support
// Wraps a handler to create an OVERLAPPED object for use with overlapped I/O.
class win_iocp_overlapped_ptr
: private noncopyable
{
public:
// Construct an empty win_iocp_overlapped_ptr.
win_iocp_overlapped_ptr()
: ptr_(0),
iocp_service_(0)
{
}
// Construct an win_iocp_overlapped_ptr to contain the specified handler.
template <typename Handler>
explicit win_iocp_overlapped_ptr(
asio::io_service& io_service, ASIO_MOVE_ARG(Handler) handler)
: ptr_(0),
iocp_service_(0)
{
this->reset(io_service, ASIO_MOVE_CAST(Handler)(handler));
}
// Destructor automatically frees the OVERLAPPED object unless released.
~win_iocp_overlapped_ptr()
{
reset();
}
// Reset to empty.
void reset()
{
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/associated_allocator.hpp"
#include "asio/associated_executor.hpp"
#include "asio/detail/work_dispatcher.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
template <typename CompletionToken>
ASIO_INITFN_RESULT_TYPE(CompletionToken, void()) post(
ASIO_MOVE_ARG(CompletionToken) token)
{
typedef ASIO_HANDLER_TYPE(CompletionToken, void()) handler;
async_completion<CompletionToken, void()> init(token);
typename associated_executor<handler>::type ex(
(get_associated_executor)(init.completion_handler));
typename associated_allocator<handler>::type alloc(
(get_associated_allocator)(init.completion_handler));
ex.post(ASIO_MOVE_CAST(handler)(init.completion_handler), alloc);
return init.result.get();
}
namespace asio {
/**
* @defgroup connect asio::connect
*
* @brief Establishes a socket connection by trying each endpoint in a sequence.
*/
/*@{*/
/// Establishes a socket connection by trying each endpoint in a sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c connect member
* function, once for each endpoint in the sequence, until a connection is
* successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @returns On success, an iterator denoting the successfully connected
* endpoint. Otherwise, the end iterator.
*
* @throws asio::system_error Thrown on failure. If the sequence is
* empty, the associated @c error_code is asio::error::not_found.
* Otherwise, contains the error from the last connection attempt.
*
* @note This overload assumes that a default constructed object of type @c
* Iterator represents the end of the sequence. This is a valid assumption for
* iterator types such as @c asio::ip::tcp::resolver::iterator.
*
* @par Example
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::socket s(io_service);
* asio::connect(s, r.resolve(q)); @endcode
*/
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
/// Establishes a socket connection by trying each endpoint in a sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c connect member
* function, once for each endpoint in the sequence, until a connection is
* successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param ec Set to indicate what error occurred, if any. If the sequence is
* empty, set to asio::error::not_found. Otherwise, contains the error
* from the last connection attempt.
*
* @returns On success, an iterator denoting the successfully connected
* endpoint. Otherwise, the end iterator.
*
* @note This overload assumes that a default constructed object of type @c
* Iterator represents the end of the sequence. This is a valid assumption for
* iterator types such as @c asio::ip::tcp::resolver::iterator.
*
* @par Example
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::socket s(io_service);
* asio::error_code ec;
* asio::connect(s, r.resolve(q), ec);
* if (ec)
* {
* // An error occurred.
* } @endcode
*/
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, asio::error_code& ec);
/// Establishes a socket connection by trying each endpoint in a sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c connect member
* function, once for each endpoint in the sequence, until a connection is
* successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param end An iterator pointing to the end of a sequence of endpoints.
*
* @returns On success, an iterator denoting the successfully connected
* endpoint. Otherwise, the end iterator.
*
* @throws asio::system_error Thrown on failure. If the sequence is
* empty, the associated @c error_code is asio::error::not_found.
* Otherwise, contains the error from the last connection attempt.
*
* @par Example
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::resolver::iterator i = r.resolve(q), end;
* tcp::socket s(io_service);
* asio::connect(s, i, end); @endcode
*/
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end);
/// Establishes a socket connection by trying each endpoint in a sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c connect member
* function, once for each endpoint in the sequence, until a connection is
* successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param end An iterator pointing to the end of a sequence of endpoints.
*
* @param ec Set to indicate what error occurred, if any. If the sequence is
* empty, set to asio::error::not_found. Otherwise, contains the error
* from the last connection attempt.
*
* @returns On success, an iterator denoting the successfully connected
* endpoint. Otherwise, the end iterator.
*
* @par Example
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::resolver::iterator i = r.resolve(q), end;
* tcp::socket s(io_service);
* asio::error_code ec;
* asio::connect(s, i, end, ec);
* if (ec)
* {
* // An error occurred.
* } @endcode
*/
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, asio::error_code& ec);
/// Establishes a socket connection by trying each endpoint in a sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c connect member
* function, once for each endpoint in the sequence, until a connection is
* successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param connect_condition A function object that is called prior to each
* connection attempt. The signature of the function object must be:
* @code Iterator connect_condition(
* const asio::error_code& ec,
* Iterator next); @endcode
* The @c ec parameter contains the result from the most recent connect
* operation. Before the first connection attempt, @c ec is always set to
* indicate success. The @c next parameter is an iterator pointing to the next
* endpoint to be tried. The function object should return the next iterator,
* but is permitted to return a different iterator so that endpoints may be
* skipped. The implementation guarantees that the function object will never
* be called with the end iterator.
*
* @returns On success, an iterator denoting the successfully connected
* endpoint. Otherwise, the end iterator.
*
* @throws asio::system_error Thrown on failure. If the sequence is
* empty, the associated @c error_code is asio::error::not_found.
* Otherwise, contains the error from the last connection attempt.
*
* @note This overload assumes that a default constructed object of type @c
* Iterator represents the end of the sequence. This is a valid assumption for
* iterator types such as @c asio::ip::tcp::resolver::iterator.
*
* @par Example
* The following connect condition function object can be used to output
* information about the individual connection attempts:
* @code struct my_connect_condition
* {
* template <typename Iterator>
* Iterator operator()(
* const asio::error_code& ec,
* Iterator next)
* {
* if (ec) std::cout << "Error: " << ec.message() << std::endl;
* std::cout << "Trying: " << next->endpoint() << std::endl;
* return next;
* }
* }; @endcode
* It would be used with the asio::connect function as follows:
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::socket s(io_service);
* tcp::resolver::iterator i = asio::connect(
* s, r.resolve(q), my_connect_condition());
* std::cout << "Connected to: " << i->endpoint() << std::endl; @endcode
*/
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition);
/// Establishes a socket connection by trying each endpoint in a sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c connect member
* function, once for each endpoint in the sequence, until a connection is
* successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param connect_condition A function object that is called prior to each
* connection attempt. The signature of the function object must be:
* @code Iterator connect_condition(
* const asio::error_code& ec,
* Iterator next); @endcode
* The @c ec parameter contains the result from the most recent connect
* operation. Before the first connection attempt, @c ec is always set to
* indicate success. The @c next parameter is an iterator pointing to the next
* endpoint to be tried. The function object should return the next iterator,
* but is permitted to return a different iterator so that endpoints may be
* skipped. The implementation guarantees that the function object will never
* be called with the end iterator.
*
* @param ec Set to indicate what error occurred, if any. If the sequence is
* empty, set to asio::error::not_found. Otherwise, contains the error
* from the last connection attempt.
*
* @returns On success, an iterator denoting the successfully connected
* endpoint. Otherwise, the end iterator.
*
* @note This overload assumes that a default constructed object of type @c
* Iterator represents the end of the sequence. This is a valid assumption for
* iterator types such as @c asio::ip::tcp::resolver::iterator.
*
* @par Example
* The following connect condition function object can be used to output
* information about the individual connection attempts:
* @code struct my_connect_condition
* {
* template <typename Iterator>
* Iterator operator()(
* const asio::error_code& ec,
* Iterator next)
* {
* if (ec) std::cout << "Error: " << ec.message() << std::endl;
* std::cout << "Trying: " << next->endpoint() << std::endl;
* return next;
* }
* }; @endcode
* It would be used with the asio::connect function as follows:
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::socket s(io_service);
* asio::error_code ec;
* tcp::resolver::iterator i = asio::connect(
* s, r.resolve(q), my_connect_condition(), ec);
* if (ec)
* {
* // An error occurred.
* }
* else
* {
* std::cout << "Connected to: " << i->endpoint() << std::endl;
* } @endcode
*/
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
ConnectCondition connect_condition, asio::error_code& ec);
/// Establishes a socket connection by trying each endpoint in a sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c connect member
* function, once for each endpoint in the sequence, until a connection is
* successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param end An iterator pointing to the end of a sequence of endpoints.
*
* @param connect_condition A function object that is called prior to each
* connection attempt. The signature of the function object must be:
* @code Iterator connect_condition(
* const asio::error_code& ec,
* Iterator next); @endcode
* The @c ec parameter contains the result from the most recent connect
* operation. Before the first connection attempt, @c ec is always set to
* indicate success. The @c next parameter is an iterator pointing to the next
* endpoint to be tried. The function object should return the next iterator,
* but is permitted to return a different iterator so that endpoints may be
* skipped. The implementation guarantees that the function object will never
* be called with the end iterator.
*
* @returns On success, an iterator denoting the successfully connected
* endpoint. Otherwise, the end iterator.
*
* @throws asio::system_error Thrown on failure. If the sequence is
* empty, the associated @c error_code is asio::error::not_found.
* Otherwise, contains the error from the last connection attempt.
*
* @par Example
* The following connect condition function object can be used to output
* information about the individual connection attempts:
* @code struct my_connect_condition
* {
* template <typename Iterator>
* Iterator operator()(
* const asio::error_code& ec,
* Iterator next)
* {
* if (ec) std::cout << "Error: " << ec.message() << std::endl;
* std::cout << "Trying: " << next->endpoint() << std::endl;
* return next;
* }
* }; @endcode
* It would be used with the asio::connect function as follows:
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::resolver::iterator i = r.resolve(q), end;
* tcp::socket s(io_service);
* i = asio::connect(s, i, end, my_connect_condition());
* std::cout << "Connected to: " << i->endpoint() << std::endl; @endcode
*/
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
Iterator end, ConnectCondition connect_condition);
/// Establishes a socket connection by trying each endpoint in a sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c connect member
* function, once for each endpoint in the sequence, until a connection is
* successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param end An iterator pointing to the end of a sequence of endpoints.
*
* @param connect_condition A function object that is called prior to each
* connection attempt. The signature of the function object must be:
* @code Iterator connect_condition(
* const asio::error_code& ec,
* Iterator next); @endcode
* The @c ec parameter contains the result from the most recent connect
* operation. Before the first connection attempt, @c ec is always set to
* indicate success. The @c next parameter is an iterator pointing to the next
* endpoint to be tried. The function object should return the next iterator,
* but is permitted to return a different iterator so that endpoints may be
* skipped. The implementation guarantees that the function object will never
* be called with the end iterator.
*
* @param ec Set to indicate what error occurred, if any. If the sequence is
* empty, set to asio::error::not_found. Otherwise, contains the error
* from the last connection attempt.
*
* @returns On success, an iterator denoting the successfully connected
* endpoint. Otherwise, the end iterator.
*
* @par Example
* The following connect condition function object can be used to output
* information about the individual connection attempts:
* @code struct my_connect_condition
* {
* template <typename Iterator>
* Iterator operator()(
* const asio::error_code& ec,
* Iterator next)
* {
* if (ec) std::cout << "Error: " << ec.message() << std::endl;
* std::cout << "Trying: " << next->endpoint() << std::endl;
* return next;
* }
* }; @endcode
* It would be used with the asio::connect function as follows:
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::resolver::iterator i = r.resolve(q), end;
* tcp::socket s(io_service);
* asio::error_code ec;
* i = asio::connect(s, i, end, my_connect_condition(), ec);
* if (ec)
* {
* // An error occurred.
* }
* else
* {
* std::cout << "Connected to: " << i->endpoint() << std::endl;
* } @endcode
*/
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
asio::error_code& ec);
/*@}*/
/**
* @defgroup async_connect asio::async_connect
*
* @brief Asynchronously establishes a socket connection by trying each
* endpoint in a sequence.
*/
/*@{*/
/// Asynchronously establishes a socket connection by trying each endpoint in a
/// sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c async_connect
* member function, once for each endpoint in the sequence, until a connection
* is successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param handler The handler to be called when the connect operation
* completes. Copies will be made of the handler as required. The function
* signature of the handler must be:
* @code void handler(
* // Result of operation. if the sequence is empty, set to
* // asio::error::not_found. Otherwise, contains the
* // error from the last connection attempt.
* const asio::error_code& error,
*
* // On success, an iterator denoting the successfully
* // connected endpoint. Otherwise, the end iterator.
* Iterator iterator
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* asio::io_service::post().
*
* @note This overload assumes that a default constructed object of type @c
* Iterator represents the end of the sequence. This is a valid assumption for
* iterator types such as @c asio::ip::tcp::resolver::iterator.
*
* @par Example
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::socket s(io_service);
*
* // ...
*
* r.async_resolve(q, resolve_handler);
*
* // ...
*
* void resolve_handler(
* const asio::error_code& ec,
* tcp::resolver::iterator i)
* {
* if (!ec)
* {
* asio::async_connect(s, i, connect_handler);
* }
* }
*
* // ...
*
* void connect_handler(
* const asio::error_code& ec,
* tcp::resolver::iterator i)
* {
* // ...
* } @endcode
*/
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
void async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ASIO_MOVE_ARG(ComposedConnectHandler) handler);
/// Asynchronously establishes a socket connection by trying each endpoint in a
/// sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c async_connect
* member function, once for each endpoint in the sequence, until a connection
* is successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param end An iterator pointing to the end of a sequence of endpoints.
*
* @param handler The handler to be called when the connect operation
* completes. Copies will be made of the handler as required. The function
* signature of the handler must be:
* @code void handler(
* // Result of operation. if the sequence is empty, set to
* // asio::error::not_found. Otherwise, contains the
* // error from the last connection attempt.
* const asio::error_code& error,
*
* // On success, an iterator denoting the successfully
* // connected endpoint. Otherwise, the end iterator.
* Iterator iterator
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* asio::io_service::post().
*
* @par Example
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::socket s(io_service);
*
* // ...
*
* r.async_resolve(q, resolve_handler);
*
* // ...
*
* void resolve_handler(
* const asio::error_code& ec,
* tcp::resolver::iterator i)
* {
* if (!ec)
* {
* tcp::resolver::iterator end;
* asio::async_connect(s, i, end, connect_handler);
* }
* }
*
* // ...
*
* void connect_handler(
* const asio::error_code& ec,
* tcp::resolver::iterator i)
* {
* // ...
* } @endcode
*/
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
void async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end,
ASIO_MOVE_ARG(ComposedConnectHandler) handler);
/// Asynchronously establishes a socket connection by trying each endpoint in a
/// sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c async_connect
* member function, once for each endpoint in the sequence, until a connection
* is successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param connect_condition A function object that is called prior to each
* connection attempt. The signature of the function object must be:
* @code Iterator connect_condition(
* const asio::error_code& ec,
* Iterator next); @endcode
* The @c ec parameter contains the result from the most recent connect
* operation. Before the first connection attempt, @c ec is always set to
* indicate success. The @c next parameter is an iterator pointing to the next
* endpoint to be tried. The function object should return the next iterator,
* but is permitted to return a different iterator so that endpoints may be
* skipped. The implementation guarantees that the function object will never
* be called with the end iterator.
*
* @param handler The handler to be called when the connect operation
* completes. Copies will be made of the handler as required. The function
* signature of the handler must be:
* @code void handler(
* // Result of operation. if the sequence is empty, set to
* // asio::error::not_found. Otherwise, contains the
* // error from the last connection attempt.
* const asio::error_code& error,
*
* // On success, an iterator denoting the successfully
* // connected endpoint. Otherwise, the end iterator.
* Iterator iterator
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* asio::io_service::post().
*
* @note This overload assumes that a default constructed object of type @c
* Iterator represents the end of the sequence. This is a valid assumption for
* iterator types such as @c asio::ip::tcp::resolver::iterator.
*
* @par Example
* The following connect condition function object can be used to output
* information about the individual connection attempts:
* @code struct my_connect_condition
* {
* template <typename Iterator>
* Iterator operator()(
* const asio::error_code& ec,
* Iterator next)
* {
* if (ec) std::cout << "Error: " << ec.message() << std::endl;
* std::cout << "Trying: " << next->endpoint() << std::endl;
* return next;
* }
* }; @endcode
* It would be used with the asio::connect function as follows:
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::socket s(io_service);
*
* // ...
*
* r.async_resolve(q, resolve_handler);
*
* // ...
*
* void resolve_handler(
* const asio::error_code& ec,
* tcp::resolver::iterator i)
* {
* if (!ec)
* {
* asio::async_connect(s, i,
* my_connect_condition(),
* connect_handler);
* }
* }
*
* // ...
*
* void connect_handler(
* const asio::error_code& ec,
* tcp::resolver::iterator i)
* {
* if (ec)
* {
* // An error occurred.
* }
* else
* {
* std::cout << "Connected to: " << i->endpoint() << std::endl;
* }
* } @endcode
*/
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
ConnectCondition connect_condition,
ASIO_MOVE_ARG(ComposedConnectHandler) handler);
/// Asynchronously establishes a socket connection by trying each endpoint in a
/// sequence.
/**
* This function attempts to connect a socket to one of a sequence of
* endpoints. It does this by repeated calls to the socket's @c async_connect
* member function, once for each endpoint in the sequence, until a connection
* is successfully established.
*
* @param s The socket to be connected. If the socket is already open, it will
* be closed.
*
* @param begin An iterator pointing to the start of a sequence of endpoints.
*
* @param end An iterator pointing to the end of a sequence of endpoints.
*
* @param connect_condition A function object that is called prior to each
* connection attempt. The signature of the function object must be:
* @code Iterator connect_condition(
* const asio::error_code& ec,
* Iterator next); @endcode
* The @c ec parameter contains the result from the most recent connect
* operation. Before the first connection attempt, @c ec is always set to
* indicate success. The @c next parameter is an iterator pointing to the next
* endpoint to be tried. The function object should return the next iterator,
* but is permitted to return a different iterator so that endpoints may be
* skipped. The implementation guarantees that the function object will never
* be called with the end iterator.
*
* @param handler The handler to be called when the connect operation
* completes. Copies will be made of the handler as required. The function
* signature of the handler must be:
* @code void handler(
* // Result of operation. if the sequence is empty, set to
* // asio::error::not_found. Otherwise, contains the
* // error from the last connection attempt.
* const asio::error_code& error,
*
* // On success, an iterator denoting the successfully
* // connected endpoint. Otherwise, the end iterator.
* Iterator iterator
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* asio::io_service::post().
*
* @par Example
* The following connect condition function object can be used to output
* information about the individual connection attempts:
* @code struct my_connect_condition
* {
* template <typename Iterator>
* Iterator operator()(
* const asio::error_code& ec,
* Iterator next)
* {
* if (ec) std::cout << "Error: " << ec.message() << std::endl;
* std::cout << "Trying: " << next->endpoint() << std::endl;
* return next;
* }
* }; @endcode
* It would be used with the asio::connect function as follows:
* @code tcp::resolver r(io_service);
* tcp::resolver::query q("host", "service");
* tcp::socket s(io_service);
*
* // ...
*
* r.async_resolve(q, resolve_handler);
*
* // ...
*
* void resolve_handler(
* const asio::error_code& ec,
* tcp::resolver::iterator i)
* {
* if (!ec)
* {
* tcp::resolver::iterator end;
* asio::async_connect(s, i, end,
* my_connect_condition(),
* connect_handler);
* }
* }
*
* // ...
*
* void connect_handler(
* const asio::error_code& ec,
* tcp::resolver::iterator i)
* {
* if (ec)
* {
* // An error occurred.
* }
* else
* {
* std::cout << "Connected to: " << i->endpoint() << std::endl;
* }
* } @endcode
*/
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
ASIO_MOVE_ARG(ComposedConnectHandler) handler);
/*@}*/
} // namespace asio
/// 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(ASIO_MOVE_ARG(Handler) handler,
ASIO_MOVE_ARG(Function) function,
const boost::coroutines::attributes& attributes
= boost::coroutines::attributes());
/// 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:
*
* @param buffers The dynamic buffer sequence from which data will be written.
* Successfully written data is automatically consumed from the buffers.
*
* @returns The number of bytes transferred.
*
* @throws asio::system_error Thrown on failure.
*
* @note This overload is equivalent to calling:
* @code asio::write(
* s, buffers,
* asio::transfer_all()); @endcode
*/
template <typename SyncWriteStream, typename DynamicBuffer>
std::size_t write(SyncWriteStream& s,
ASIO_MOVE_ARG(DynamicBuffer) buffers,
typename enable_if<
is_dynamic_buffer<DynamicBuffer>::value
>::type* = 0);
/// Write all of the supplied data to a stream before returning.
/**
* This function is used to write a certain number of bytes of data to a stream.
* The call will block until one of the following conditions is true:
*
* @li All of the data in the supplied dynamic buffer sequence has been written.
*
* @li An error occurred.
*
* This operation is implemented in terms of zero or more calls to the stream's
* write_some function.
* @param handler The handler to be called when the accept operation
* completes. Copies will be made of the handler as required. The function
* signature of the handler must be:
* @code void handler(
* const asio::error_code& error // Result of operation.
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* asio::io_service::post().
*/
template <typename SocketService, typename AcceptHandler>
ASIO_INITFN_RESULT_TYPE(AcceptHandler,
void (asio::error_code))
async_accept(basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint, ASIO_MOVE_ARG(AcceptHandler) handler)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a AcceptHandler.
ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;
return this->get_service().async_accept(this->get_implementation(), peer,
&peer_endpoint, ASIO_MOVE_CAST(AcceptHandler)(handler));
}
};
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_BASIC_SOCKET_ACCEPTOR_HPP
inline io_service::executor_type
io_service::get_executor() ASIO_NOEXCEPT
{
return executor_type(*this);
}
#if !defined(ASIO_NO_DEPRECATED)
inline void io_service::reset()
{
restart();
}
template <typename CompletionHandler>
ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
io_service::dispatch(ASIO_MOVE_ARG(CompletionHandler) handler)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a CompletionHandler.
ASIO_COMPLETION_HANDLER_CHECK(CompletionHandler, handler) type_check;
async_completion<CompletionHandler, void ()> init(handler);
if (impl_.can_dispatch())
{
detail::fenced_block b(detail::fenced_block::full);
asio_handler_invoke_helpers::invoke(init.handler, init.handler);
}
else
{
// Allocate and construct an operation to wrap the handler.
# include <boost/bind.hpp>
#else // defined(ASIO_HAS_BOOST_BIND)
# include <functional>
#endif // defined(ASIO_HAS_BOOST_BIND)
namespace archetypes {
#if defined(ASIO_HAS_BOOST_BIND)
namespace bindns = boost;
#else // defined(ASIO_HAS_BOOST_BIND)
namespace bindns = std;
#endif // defined(ASIO_HAS_BOOST_BIND)
template <typename CompletionToken>
ASIO_INITFN_RESULT_TYPE(CompletionToken, void())
async_op_0(ASIO_MOVE_ARG(CompletionToken) token)
{
typedef typename asio::async_completion<CompletionToken,
void()>::completion_handler_type handler_type;
asio::async_completion<CompletionToken,
void()> completion(token);
typename asio::associated_allocator<handler_type>::type a
= asio::get_associated_allocator(completion.completion_handler);
typename asio::associated_executor<handler_type>::type ex
= asio::get_associated_executor(completion.completion_handler);
ex.post(ASIO_MOVE_CAST(handler_type)(completion.completion_handler), a);
* * @param handler The handler to be called. The io_service will make * a copy of the handler object as required. The function signature of the * handler must be: @code void handler(); @endcode * * @note This function throws an exception only if: * * @li the handler's @c asio_handler_allocate function; or * * @li the handler's copy constructor * * throws an exception. */ template <typename CompletionHandler> ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ()) dispatch(ASIO_MOVE_ARG(CompletionHandler) handler); /// (Deprecated: Use asio::post().) Request the io_service to invoke /// the given handler and return immediately. /** * This function is used to ask the io_service to execute the given handler, * but without allowing the io_service to call the handler from inside this * function. * * The io_service guarantees that the handler will only be called in a thread * in which the run(), run_one(), poll() or poll_one() member functions is * currently being invoked. * * @param handler The handler to be called. The io_service will make * a copy of the handler object as required. The function signature of the * handler must be: @code void handler(); @endcode
static type get(const detail::buffered_flush_handler<WriteHandler>& h,
const Executor& ex = Executor()) ASIO_NOEXCEPT
{
return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
}
};
#endif // !defined(GENERATING_DOCUMENTATION)
template <typename Stream>
template <typename WriteHandler>
ASIO_INITFN_RESULT_TYPE(WriteHandler,
void (asio::error_code, std::size_t))
buffered_write_stream<Stream>::async_flush(
ASIO_MOVE_ARG(WriteHandler) handler)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a WriteHandler.
ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
async_completion<WriteHandler,
void (asio::error_code, std::size_t)> init(handler);
async_write(next_layer_, buffer(storage_.data(), storage_.size()),
detail::buffered_flush_handler<ASIO_HANDLER_TYPE(
WriteHandler, void (asio::error_code, std::size_t))>(
storage_, init.completion_handler));
return init.result.get();
}
{
return service_impl_.cancel(impl, ec);
}
// Wait for a signaled state.
void wait(implementation_type& impl, asio::error_code& ec)
{
service_impl_.wait(impl, ec);
}
/// Start an asynchronous wait.
template <typename WaitHandler>
ASIO_INITFN_RESULT_TYPE(WaitHandler,
void (asio::error_code))
async_wait(implementation_type& impl,
ASIO_MOVE_ARG(WaitHandler) handler)
{
asio::detail::async_result_init<
WaitHandler, void (asio::error_code)> init(
ASIO_MOVE_CAST(WaitHandler)(handler));
service_impl_.async_wait(impl, init.handler);
return init.result.get();
}
private:
// Destroy all user-defined handler objects owned by the service.
void shutdown_service()
{
service_impl_.shutdown_service();
* error code asio::error::operation_aborted.
*
* @param handler The handler to be called when the signal occurs. Copies
* will be made of the handler as required. The function signature of the
* handler must be:
* @code void handler(
* const asio::error_code& error, // Result of operation.
* int signal_number // Indicates which signal occurred.
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* asio::io_service::post().
*/
template <typename SignalHandler>
void async_wait(ASIO_MOVE_ARG(SignalHandler) handler)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a SignalHandler.
ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;
this->service.async_wait(this->implementation,
ASIO_MOVE_CAST(SignalHandler)(handler));
}
};
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_BASIC_SIGNAL_SET_HPP
return service_impl_.clear(impl, ec);
}
/// Cancel all operations associated with the signal set.
asio::error_code cancel(implementation_type& impl,
asio::error_code& ec)
{
return service_impl_.cancel(impl, ec);
}
// Start an asynchronous operation to wait for a signal to be delivered.
template <typename SignalHandler>
ASIO_INITFN_RESULT_TYPE(SignalHandler,
void (asio::error_code, int))
async_wait(implementation_type& impl,
ASIO_MOVE_ARG(SignalHandler) handler)
{
detail::async_result_init<
SignalHandler, void (asio::error_code, int)> init(
ASIO_MOVE_CAST(SignalHandler)(handler));
service_impl_.async_wait(impl, init.handler);
return init.result.get();
}
private:
// Destroy all user-defined handler objects owned by the service.
void shutdown_service()
{
service_impl_.shutdown_service();
*
* @param handler The handler to be called when the timer expires. Copies
* will be made of the handler as required. The function signature of the
* handler must be:
* @code void handler(
* const clmdep_asio::error_code& error // Result of operation.
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* clmdep_asio::io_service::post().
*/
template <typename WaitHandler>
ASIO_INITFN_RESULT_TYPE(WaitHandler,
void (clmdep_asio::error_code))
async_wait(ASIO_MOVE_ARG(WaitHandler) handler)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a WaitHandler.
ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
return this->service.async_wait(this->implementation,
ASIO_MOVE_CAST(WaitHandler)(handler));
}
};
} // namespace clmdep_asio
#include "asio/detail/pop_options.hpp"
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
* the SyncReadStream concept.
*
* @param buffers The dynamic buffer sequence into which the data will be read.
*
* @returns The number of bytes transferred.
*
* @throws asio::system_error Thrown on failure.
*
* @note This overload is equivalent to calling:
* @code asio::read(
* s, buffers,
* asio::transfer_all()); @endcode
*/
template <typename SyncReadStream, typename DynamicBufferSequence>
std::size_t read(SyncReadStream& s,
ASIO_MOVE_ARG(DynamicBufferSequence) buffers,
typename enable_if<
is_dynamic_buffer_sequence<DynamicBufferSequence>::value
>::type* = 0);
/// Attempt to read a certain amount of data from a stream before returning.
/**
* This function is used to read a certain number of bytes of data from a
* stream. The call will block until one of the following conditions is true:
*
* @li The supplied buffer is full (that is, it has reached maximum size).
*
* @li An error occurred.
*
* This operation is implemented in terms of zero or more calls to the stream's
* read_some function.
* @e Shared @e objects: Unsafe.
*/
class overlapped_ptr
: private noncopyable
{
public:
/// Construct an empty overlapped_ptr.
overlapped_ptr()
: impl_()
{
}
/// Construct an overlapped_ptr to contain the specified handler.
template <typename Handler>
explicit overlapped_ptr(asio::io_context& io_context,
ASIO_MOVE_ARG(Handler) handler)
: impl_(io_context, ASIO_MOVE_CAST(Handler)(handler))
{
}
/// Destructor automatically frees the OVERLAPPED object unless released.
~overlapped_ptr()
{
}
/// Reset to empty.
void reset()
{
impl_.reset();
}
void on_work_started() ASIO_NOEXCEPT
{
executor_.on_work_started();
}
void on_work_finished() ASIO_NOEXCEPT
{
executor_.on_work_finished();
}
execution_context& context() ASIO_NOEXCEPT
{
return executor_.context();
}
void dispatch(ASIO_MOVE_ARG(function) f)
{
executor_.dispatch(ASIO_MOVE_CAST(function)(f), allocator_);
}
void post(ASIO_MOVE_ARG(function) f)
{
executor_.post(ASIO_MOVE_CAST(function)(f), allocator_);
}
void defer(ASIO_MOVE_ARG(function) f)
{
executor_.defer(ASIO_MOVE_CAST(function)(f), allocator_);
}
type_id_result_type target_type() const ASIO_NOEXCEPT