A protoco‐allocator type that may be rebound to obtain an allocator that forwards memory allocation operations through an instance of any_completion_handler.

any_io_executor

Polymorphic executor type for use with I/O objects.

append_t

Completion token type used to specify that the completion handler arguments should be passed additional values after the results of the operation.

as_tuple_t

A completion_token adapter used to specify that the completion handler arguments should be combined into a single tuple argument.

associated_allocator

Traits type used to obtain the allocator associated with an object.

associated_allocator<reference_wrapper<T>, Allocator>

Specialisation of associated_allocator for std::reference_wrapper.

associated_allocator<allocator_binder<T, Allocator>, Allocator1>

associated_cancellation_slot

Traits type used to obtain the cancellation_slot associated with an object.

associated_cancellation_slot<reference_wrapper<T>, CancellationSlot>

Specialisation of associated_cancellation_slot for std::reference_wrapper.

associated_cancellation_slot<cancellation_slot_binder<T, CancellationSlot>, CancellationSlot1>

associated_executor

Traits type used to obtain the executor associated with an object.

associated_executor<any_completion_handler<Signatures...>, Candidate>

associated_executor<reference_wrapper<T>, Executor>

Specialisation of associated_executor for std::reference_wrapper.

associated_executor<executor_binder<T, Executor>, Executor1>

associated_immediate_executor

Traits type used to obtain the immediate executor associated with an object.

associated_immediate_executor<any_completion_handler<Signatures...>, Candidate>

associated_immediate_executor<reference_wrapper<T>, Executor>

Specialisation of associated_immediate_executor for std::reference_wrapper.

associated_immediate_executor<immediate_executor_binder<T, Executor>, Executor1>

associator

Used to generically specialise associators for a type.

associator<Associator, /* implementation-defined */, DefaultCandidate>

associator<Associator, allocator_binder<T, Allocator>, DefaultCandidate>

associator<Associator, /* implementation-defined */, DefaultCandidate>

associator<Associator, cancellation_slot_binder<T, CancellationSlot>, DefaultCandidate>

associator<Associator, /* implementation-defined */, DefaultCandidate>

associator<Associator, executor_binder<T, Executor>, DefaultCandidate>

associator<Associator, immediate_executor_binder<T, Executor>, DefaultCandidate>

associator<Associator, /* implementation-defined */, DefaultCandidate>

async_completion

Helper template to deduce the handler type from a CompletionToken, capture a local copy of the handler, and then create an async_result for the handler.

async_result

async_result</* implementation-defined */, Signatures...>

async_result</* implementation-defined */, Signature>

async_result</* implementation-defined */, Signatures...>

async_result<void, Signatures...>

async_result<partial_allocator_binder<Allocator>, Signatures...>

async_result<partial_cancellation_slot_binder<CancellationSlot>, Signatures...>

async_result<partial_executor_binder<Executor>, Signatures...>

async_result<partial_immediate_executor_binder<Executor>, Signatures...>

async_result<allocator_binder<T, Allocator>, Signature>

async_result<cancellation_slot_binder<T, CancellationSlot>, Signature>

async_result<executor_binder<T, Executor>, Signature>

async_result<immediate_executor_binder<T, Executor>, Signature>

awaitable

The return type of a coroutine or asynchronous operation.

bad_executor

Exception thrown when trying to access an empty polymorphic executor.

basic_datagram_socket

Provides datagram‐oriented socket functionality.

basic_file

Provides file functionality.

basic_io_object

basic_io_object<IoObjectService, true>

basic_random_access_file

Provides random‐access file functionality.

basic_raw_socket

Provides raw‐oriented socket functionality.

basic_readable_pipe

Provides pipe functionality.

basic_seq_packet_socket

Provides sequenced packet socket functionality.

basic_serial_port

Provides serial port functionality.

basic_signal_set

Provides signal functionality.

basic_socket

Provides socket functionality.

basic_socket_acceptor

Provides the ability to accept new connections.

basic_socket_iostream

basic_socket_streambuf

basic_stream_file

Provides stream‐oriented file functionality.

basic_stream_socket

Provides stream‐oriented socket functionality.

basic_streambuf

basic_streambuf_ref

basic_system_executor

An executor that uses arbitrary threads.

basic_waitable_timer

Provides waitable timer functionality.

basic_writable_pipe

Provides pipe functionality.

buffer_registration

Automatically registers and unregistered buffers with an execution context.

buffered_read_stream

Adds buffering to the read‐related operations of a stream.

buffered_stream

Adds buffering to the read‐ and write‐related operations of a stream.

buffered_write_stream

Adds buffering to the write‐related operations of a stream.

buffers_iterator

A random access iterator over the bytes in a buffer sequence.

can_prefer

can_query

can_require

can_require_concept

cancel_after_t

A completion_token adapter that cancels an operation after a timeout.

cancel_after_timer

A completion_token adapter that cancels an operation after a timeout.

cancel_at_t

A completion_token adapter that cancels an operation at a given time.

cancel_at_timer

A completion_token adapter that cancels an operation at a given time.

cancellation_filter

A simple cancellation signal propagation filter.

cancellation_signal

A cancellation signal with a single slot.

cancellation_slot

A slot associated with a cancellation signal.

cancellation_slot_binder

A call wrapper type to bind a cancellation slot of type CancellationSlot to an object of type T.

cancellation_state

A cancellation state is used for chaining signals and slots in compositions.

completion_signature_of

config

Provides access to the configuration values associated with an execution context.

config_from_concurrency_hint

Configures an execution context based on a concurrency hint.

config_from_env

Configures an execution context by reading environment variables.

config_from_string

Configures an execution context by reading variables from a string.

config_service

Base class for configuration implementations.

conjunction

conjunction<T>

conjunction<Head, Tail...>

consign_t

Completion token type used to specify that the completion handler should carry additional values along with it.

const_buffer

Holds a buffer that cannot be modified.

const_registered_buffer

Holds a registered buffer over non‐modifiable data.

constraint

coroutine

Provides support for implementing stackless coroutines.

default_completion_token

defaulted_constraint

deferred_async_operation

Encapsulates a deferred asynchronous operation.

deferred_async_operation<deferred_signatures<Signatures...>, Initiation, InitArgs...>

Encapsulates a deferred asynchronous operation thas has multiple completion signatures.

deferred_conditional

Used to represent a deferred conditional branch.

deferred_function

Wraps a function object so that it may be used as an element in a deferred composition.

deferred_init_tag

Tag type to disambiguate deferred constructors.

deferred_noop

Used to represent an empty deferred action.

deferred_sequence

Defines a link between two consecutive operations in a sequence.

deferred_signatures

Helper type to wrap multiple completion signatures.

deferred_t

Class used to specify that an asynchronous operation should return a function object to lazily launch the operation.

deferred_values

Encapsulates deferred values.

detached_t

A completion_token type used to specify that an asynchronous operation is detached.

disposition_traits

disposition_traits<boost::system::error_code>

Specialisation of disposition_traits for error_code.

disposition_traits<std::exception_ptr>

Specialisation of disposition_traits for std::exception_ptr.

disposition_traits<no_error_t>

Specialisation of disposition_traits for no_error_t.

dynamic_string_buffer

Adapt a basic_string to the DynamicBuffer requirements.

dynamic_vector_buffer

Adapt a vector to the DynamicBuffer requirements.

execution_context

A context for function object execution.

executor

Polymorphic wrapper for executors.

executor_arg_t

A special type, similar to std::nothrow_t, used to disambiguate constructors that accept executor arguments.

executor_binder

A call wrapper type to bind an executor of type Executor to an object of type T.

executor_work_guard

executor_work_guard<Executor>

file_base

The file_base class is used as a base for the basic_stream_file and basic_random_access_file class templates so that we have a common place to define flags.

immediate_executor_binder

A call wrapper type to bind a immediate executor of type Executor to an object of type T.

invalid_service_owner

Exception thrown when trying to add a service object to an execution_context where the service has a different owner.

io_context

Provides core I/O functionality.

is_applicable_property

is_applicable_property<T, execution::prefer_only<InnerProperty>>

is_async_operation

is_completion_condition

is_connect_condition

is_const_buffer_sequence

Trait to determine whether a type satisfies the ConstBufferSequence requirements.

is_contiguous_iterator

The is_contiguous_iterator class is a traits class that may be used to determine whether a type is a contiguous iterator.

is_deferred

Trait for detecting objects that are usable as deferred operations.

is_deferred<deferred_noop>

is_deferred<deferred_function<Function>>

is_deferred<deferred_values<Values...>>

is_deferred<deferred_conditional<OnTrue, OnFalse>>

is_deferred<deferred_sequence<Head, Tail>>

is_deferred<deferred_async_operation<Signature, Initiation, InitArgs...>>

is_disposition

Trait used for testing whether a type satisfies the requirements of a disposition.

is_dynamic_buffer

Trait to determine whether a type satisfies the DynamicBuffer requirements.

is_dynamic_buffer_v1

Trait to determine whether a type satisfies the DynamicBuffer_v1 requirements.

is_dynamic_buffer_v2

Trait to determine whether a type satisfies the DynamicBuffer_v2 requirements.

is_endpoint_sequence

is_executor

The is_executor trait detects whether a type T meets the Executor type requirements.

is_match_condition

Type trait used to determine whether a type can be used as a match condition function with read_until and async_read_until.

is_mutable_buffer_sequence

Trait to determine whether a type satisfies the MutableBufferSequence requirements.

is_nothrow_prefer

is_nothrow_query

is_nothrow_require

is_nothrow_require_concept

is_read_buffered

The is_read_buffered class is a traits class that may be used to determine whether a stream type supports buffering of read data.

is_write_buffered

The is_write_buffered class is a traits class that may be used to determine whether a stream type supports buffering of written data.

multiple_exceptions

Exception thrown when there are multiple pending exceptions to rethrow.

mutable_buffer

Holds a buffer that can be modified.

mutable_registered_buffer

Holds a registered buffer over modifiable data.

no_error_t

A tag type used to indicate the absence of an error.

null_buffers

(Deprecated: Use the socket/descriptor wait() and async_wait() member functions.) An implementation of both the ConstBufferSequence and MutableBufferSequence concepts to represent a null buffer sequence.

partial_allocator_binder

A function object type that adapts a completion_token to specify that the completion handler should have the supplied allocator as its associated allocator.

partial_as_tuple

A function object type that adapts a completion_token to specify that the completion handler arguments should be combined into a single tuple argument.

partial_cancel_after

A function object type that adapts a completion_token to cancel an operation after a timeout.

partial_cancel_after_timer

A function object type that adapts a completion_token to cancel an operation after a timeout.

partial_cancel_at

A function object type that adapts a completion_token to cancel an operation at a given time.

partial_cancel_at_timer

A function object type that adapts a completion_token to cancel an operation at a given time.

partial_cancellation_slot_binder

A function object type that adapts a completion_token to specify that the completion handler should have the supplied cancellation slot as its associated cancellation slot.

partial_executor_binder

A function object type that adapts a completion_token to specify that the completion handler should have the supplied executor as its associated executor.

partial_immediate_executor_binder

A function object type that adapts a completion_token to specify that the completion handler should have the supplied executor as its associated immediate executor.

partial_redirect_error

A function object type that adapts a completion_token to capture error_code values to a variable.

prefer_result

prepend_t

Completion token type used to specify that the completion handler arguments should be passed additional values before the results of the operation.

query_result

recycling_allocator

An allocator that caches memory blocks in thread‐local storage for reuse.

recycling_allocator<void>

A proto‐allocator that caches memory blocks in thread‐local storage for reuse.

redirect_error_t

A completion_token adapter used to specify that an error produced by an asynchronous operation is captured to an error_code variable.

registered_buffer_id

Type used to identify a registered buffer.

remove_cvref

require_concept_result

require_result

result_of

result_of<F(Args...)>

serial_port_base

The serial_port_base class is used as a base for the basic_serial_port class template so that we have a common place to define the serial port options.

service_already_exists

Exception thrown when trying to add a duplicate service to an execution_context.

signal_set_base

The signal_set_base class is used as a base for the basic_signal_set class templates so that we have a common place to define the flags enum.

socket_base

The socket_base class is used as a base for the basic_stream_socket and basic_datagram_socket class templates so that we have a common place to define the shutdown_type and enum.

strand

Provides serialised function invocation for any executor type.

system_context

The executor context for the system executor.

thread_pool

A simple fixed‐size thread pool.

type_identity

use_awaitable_t

A completion_token that represents the currently executing coroutine.

use_future_t

A completion_token type that causes an asynchronous operation to return a future.

uses_executor

The uses_executor trait detects whether a type T has an associated executor that is convertible from type Executor.

uses_executor<executor_binder<T, Executor>, Executor>

void_type

wait_traits

Wait traits suitable for use with the basic_waitable_timer class template.

add_const_t

add_lvalue_reference_t

aligned_storage_t

associated_allocator_t

associated_cancellation_slot_t

associated_executor_t

associated_immediate_executor_t

cancellation_type_t

completion_signature_of_t

conditional_t

constraint_t

decay_t

default_completion_token_t

disable_cancellation

A cancellation filter that disables cancellation.

enable_if_t

enable_partial_cancellation

enable_terminal_cancellation

A cancellation filter that enables terminal cancellation only.

enable_total_cancellation

high_resolution_timer

Typedef for a timer based on the high resolution clock.

Typedef for the typical usage of a random‐access file.

readable_pipe

Typedef for the typical usage of a readable pipe.

require_concept_result_t

Typedef for the typical usage of a serial port.

signal_set

Typedef for the typical usage of a signal set.

static_thread_pool

steady_timer

Typedef for a timer based on the steady clock.

stream_file

Typedef for the typical usage of a stream‐oriented file.

streambuf

Typedef for the typical usage of basic_streambuf.

system_executor

An executor that uses arbitrary threads.

system_timer

Typedef for a timer based on the system clock.

type_identity_t

void_t

writable_pipe

Typedef for the typical usage of a writable pipe.

Enums

Name

Description

cancellation_type

Functions

Name

Description

add_service

(Deprecated: Use make_service().) Add a service object to the execution_context.

aligned_delete

aligned_new

append

Completion token type used to specify that the completion handler arguments should be passed additional values after the results of the operation.

asio_handler_is_continuation

Default continuation function for handlers.

async_compose

Launch an asynchronous operation with a stateful implementation.

async_connect

Asynchronously establishes a socket connection by trying each endpoint in a sequence.

async_immediate

Launch a trivial asynchronous operation that completes immediately.

async_initiate

async_read

Start an asynchronous operation to read a certain amount of data from a stream.

async_read_at

Start an asynchronous operation to read a certain amount of data at the specified offset.

async_read_until

async_read_until overloads

async_write

async_write overloads

async_write_at

async_write_at overloads

bind_allocator

bind_allocator overloads

bind_cancellation_slot

bind_cancellation_slot overloads

bind_executor

bind_executor overloads

bind_immediate_executor

bind_immediate_executor overloads

buffer

buffer overloads

buffer_copy

buffer_copy overloads

buffer_sequence_begin

Get an iterator to the first element in a buffer sequence.

buffer_sequence_end

Get an iterator to one past the end element in a buffer sequence.

buffer_size

Get the total number of bytes in a buffer sequence.

buffers_begin

Construct an iterator representing the beginning of the buffers' data.

buffers_end

Construct an iterator representing the end of the buffers' data.

cancel_after

cancel_after overloads

cancel_at

cancel_at overloads

co_composed

Creates an initiation function object that may be used to launch a coroutine‐based composed asynchronous operation.

co_spawn

Spawn a new coroutined‐based thread of execution.

composed

Creates an initiation function object that may be used to launch an asynchronous operation with a stateful implementation.

connect

Establishes a socket connection by trying each endpoint in a sequence.

connect_pipe

Connect two pipe ends using an anonymous pipe.

consign

Completion token adapter used to specify that the completion handler should carry additional values along with it.

defer

Submits a completion token or function object for execution.

dispatch

Submits a completion token or function object for execution.

dynamic_buffer

dynamic_buffer overloads

get_associated_allocator

Helper function to obtain an object's associated allocator.

get_associated_cancellation_slot

Helper function to obtain an object's associated cancellation_slot.

get_associated_executor

Helper function to obtain an object's associated executor.

get_associated_immediate_executor

Helper function to obtain an object's associated executor.

has_service

Determine if an execution_context contains a specified service type.

make_service

Creates a service object and adds it to the execution_context.

make_strand

make_strand overloads

make_work_guard

Create an executor_work_guard object.

operator&

Bitwise and operator.

operator&=

Bitwise and‐assignment operator.

operator+

Addition operators

operator‐

Subtraction operator.

operatorˆ

Bitwise xor operator.

operatorˆ=

Bitwise xor‐assignment operator.

operator|

Bitwise disjunction operators

operator|=

Bitwise or‐assignment operator.

operator~

Bitwise negation operator.

post

Submits a completion token or function object for execution.

prepend

Completion token type used to specify that the completion handler arguments should be passed additional values before the results of the operation.

read

Attempt to read a certain amount of data from a stream before returning.

read_at

Attempt to read a certain amount of data at the specified offset before returning.

read_size_helper

read_until

read_until overloads

redirect_error

redirect_error overloads

register_buffers

throw_exception

Helper function to throw an exception arising from a disposition.

to_exception_ptr

Helper function to convert a disposition to an exception_ptr.

Obtain the service object corresponding to the given type.

write overloads

write_at overloads

Negation operator.

Equality operators

Inequality operators

Compare two iterators.

operator<=

Compare two iterators.

operator>

Compare two iterators.

operator>=

Compare two iterators.

Variables

Name

Description

as_tuple

A function object that adapts a completion_token to specify that the completion handler arguments should be combined into a single tuple argument.

can_prefer_v

can_query_v

can_require_concept_v

can_require_v

deferred

A completion_token object used to specify that an asynchronous operation should return a function object to lazily launch the operation.

detached

A completion_token object used to specify that an asynchronous operation is detached.

executor_arg

A special value, similar to std::nothrow, used to disambiguate constructors that accept executor arguments.

is_applicable_property_v

is_disposition_v

is_nothrow_prefer_v

is_nothrow_query_v

is_nothrow_require_concept_v

is_nothrow_require_v

no_error

A special value used to indicate the absence of an error.

use_awaitable

use_future

A completion_token object that causes an asynchronous operation to return a future.

Concepts

Name

async_operation

completion_handler_for

completion_signature

completion_token_for

disposition

Using Declarations

Name

add_const

add_lvalue_reference

is_copy_constructible

is_destructible

is_function

is_integral

is_move_constructible

is_nothrow_copy_assignable

is_nothrow_copy_constructible

is_nothrow_default_constructible

is_nothrow_destructible

is_nothrow_move_assignable

is_nothrow_move_constructible

Created with MrDocs

Edit this Page