net Namespace Reference

Namespaces
namespace	impl
namespace	ip
namespace	socket_option
namespace	tls

Classes
struct	associated_allocator
struct	associated_allocator_impl
struct	associated_allocator_impl< T, ProtoAllocator, std::void_t< typename T::allocator_type > >
struct	associated_executor
struct	associated_executor_impl
struct	associated_executor_impl< T, Executor, std::void_t< typename T::executor_type > >
class	async_completion
class	async_result
class	basic_datagram_socket
class	basic_socket
class	basic_socket_acceptor
class	basic_socket_impl
class	basic_socket_impl_base
	template-less base-class of basic_socket_impl. More...
class	basic_stream_socket
class	basic_waitable_timer
class	const_buffer
class	consuming_buffers
class	dynamic_string_buffer
class	dynamic_vector_buffer
class	execution_context
struct	executor_arg_t
class	executor_binder
class	executor_work_guard
struct	fd_event
class	InterfaceFlag
	flags of the network interface. More...
class	io_context
class	IoServiceBase
struct	is_const_buffer_sequence
struct	is_dynamic_buffer
struct	is_executor
struct	is_executor< io_context::executor_type >
struct	is_mutable_buffer_sequence
class	linux_epoll_io_service
class	mutable_buffer
class	NetworkInterfaceEntry
	an entry in the network interface result. More...
class	NetworkInterfaceNetworks
	networks of a network interface. More...
class	NetworkInterfaceResolver
class	NetworkInterfaceResults
	results of a NetworkInterfaceResolver::query(). More...
class	poll_io_service
	io_service based on the poll() system-call. More...
class	prepared_buffers
class	service_already_exists
class	socket_base
class	strand
class	system_context
class	system_executor
class	transfer_all
class	transfer_at_least
class	transfer_exactly
struct	uses_executor
struct	wait_traits

Typedefs
template<class T , class ProtoAllocator = std::allocator<void>>
using	associated_allocator_t = typename associated_allocator< T, ProtoAllocator >::type
template<class T , class Executor = system_executor>
using	associated_executor_t = typename associated_executor< T, Executor >::type
using	io_service_impl_default = linux_epoll_io_service
using	system_timer = basic_waitable_timer< std::chrono::system_clock >
using	steady_timer = basic_waitable_timer< std::chrono::steady_clock >
using	high_resolution_timer = basic_waitable_timer< std::chrono::high_resolution_clock >

Enumerations
enum class	stream_errc { eof = 1 , not_found }
enum class	fork_event { prepare , parent , child }
enum class	io_service_errc { no_fds = 1 }
enum class	socket_errc { already_open = 1 , not_found = 2 }

Functions
const std::error_category &	stream_category () noexcept
std::error_code	make_error_code (net::stream_errc e) noexcept
std::error_condition	make_error_condition (net::stream_errc e) noexcept
const const_buffer *	buffer_sequence_begin (const const_buffer &b) noexcept
const const_buffer *	buffer_sequence_end (const const_buffer &b) noexcept
template<class C >
auto	buffer_sequence_begin (C &c) noexcept -> decltype(c.begin())
template<class C >
auto	buffer_sequence_begin (const C &c) noexcept -> decltype(c.begin())
template<class C >
auto	buffer_sequence_end (C &c) noexcept -> decltype(c.end())
template<class C >
auto	buffer_sequence_end (const C &c) noexcept -> decltype(c.end())
const mutable_buffer *	buffer_sequence_begin (const mutable_buffer &b) noexcept
const mutable_buffer *	buffer_sequence_end (const mutable_buffer &b) noexcept
template<class ConstBufferSequence >
size_t	buffer_size (const ConstBufferSequence &buffers) noexcept
template<>
size_t	buffer_size< const_buffer > (const const_buffer &b) noexcept
template<>
size_t	buffer_size< mutable_buffer > (const mutable_buffer &b) noexcept
template<class MutableBufferSequence , class ConstBufferSequence >
size_t	buffer_copy (const MutableBufferSequence &dest, const ConstBufferSequence &src, const size_t max_size) noexcept
	copy bytes from a ConstBufferSequence to a MutableBufferSequence. More...
template<class MutableBufferSequence , class ConstBufferSequence >
size_t	buffer_copy (const MutableBufferSequence &dest, const ConstBufferSequence &src) noexcept
mutable_buffer	operator+ (const mutable_buffer &b, size_t n) noexcept
mutable_buffer	operator+ (size_t n, const mutable_buffer &b) noexcept
const_buffer	operator+ (const const_buffer &b, size_t n) noexcept
const_buffer	operator+ (size_t n, const const_buffer &b) noexcept
mutable_buffer	buffer (void *p, size_t n) noexcept
const_buffer	buffer (const void *p, size_t n) noexcept
mutable_buffer	buffer (const mutable_buffer &b) noexcept
mutable_buffer	buffer (const mutable_buffer &b, size_t n) noexcept
const_buffer	buffer (const const_buffer &b) noexcept
const_buffer	buffer (const const_buffer &b, size_t n) noexcept
template<class T , size_t N>
mutable_buffer	buffer (T(&data)[N]) noexcept
template<class T , size_t N>
const_buffer	buffer (const T(&data)[N]) noexcept
template<class T , size_t N>
mutable_buffer	buffer (std::array< T, N > &data) noexcept
template<class T , size_t N>
const_buffer	buffer (std::array< const T, N > &data) noexcept
template<class T , class Allocator >
mutable_buffer	buffer (std::vector< T, Allocator > &data) noexcept
template<class T , class Allocator >
const_buffer	buffer (const std::vector< T, Allocator > &data) noexcept
template<class CharT , class Traits , class Allocator >
mutable_buffer	buffer (std::basic_string< CharT, Traits, Allocator > &data) noexcept
template<class CharT , class Traits , class Allocator >
const_buffer	buffer (const std::basic_string< CharT, Traits, Allocator > &data) noexcept
template<class CharT , class Traits >
const_buffer	buffer (const std::basic_string_view< CharT, Traits > &data) noexcept
template<class T , std::size_t E>
const_buffer	buffer (const std::span< T, E > &data) noexcept
template<class T , size_t N>
mutable_buffer	buffer (T(&data)[N], size_t n) noexcept
template<class T , size_t N>
const_buffer	buffer (const T(&data)[N], size_t n) noexcept
template<class T , size_t N>
mutable_buffer	buffer (std::array< T, N > &data, size_t n) noexcept
template<class T , size_t N>
const_buffer	buffer (std::array< const T, N > &data, size_t n) noexcept
template<class T , class Allocator >
mutable_buffer	buffer (std::vector< T, Allocator > &data, size_t n) noexcept
template<class T , class Allocator >
const_buffer	buffer (const std::vector< T, Allocator > &data, size_t n) noexcept
template<class CharT , class Traits , class Allocator >
mutable_buffer	buffer (std::basic_string< CharT, Traits, Allocator > &data, size_t n) noexcept
template<class CharT , class Traits , class Allocator >
const_buffer	buffer (const std::basic_string< CharT, Traits, Allocator > &data, size_t n) noexcept
template<class T , std::size_t E>
const_buffer	buffer (const std::span< T, E > &data, size_t n) noexcept
template<class T , class Allocator >
dynamic_vector_buffer< T, Allocator >	dynamic_buffer (std::vector< T, Allocator > &vec) noexcept
template<class T , class Allocator >
dynamic_vector_buffer< T, Allocator >	dynamic_buffer (std::vector< T, Allocator > &vec, size_t n) noexcept
template<class CharT , class Traits , class Allocator >
dynamic_string_buffer< CharT, Traits, Allocator >	dynamic_buffer (std::basic_string< CharT, Traits, Allocator > &str) noexcept
template<class CharT , class Traits , class Allocator >
dynamic_string_buffer< CharT, Traits, Allocator >	dynamic_buffer (std::basic_string< CharT, Traits, Allocator > &str, size_t n) noexcept
template<class SyncReadStream , class MutableBufferSequence >
std::enable_if_t< is_mutable_buffer_sequence< MutableBufferSequence >::value, stdx::expected< size_t, std::error_code > >	read (SyncReadStream &stream, const MutableBufferSequence &buffers)
template<class SyncReadStream , class MutableBufferSequence , class CompletionCondition >
std::enable_if_t< is_mutable_buffer_sequence< MutableBufferSequence >::value, stdx::expected< size_t, std::error_code > >	read (SyncReadStream &stream, const MutableBufferSequence &buffers, CompletionCondition cond)
template<class SyncReadStream , class DynamicBuffer >
std::enable_if_t< is_dynamic_buffer< std::decay_t< DynamicBuffer > >::value, stdx::expected< size_t, std::error_code > >	read (SyncReadStream &stream, DynamicBuffer &&b)
template<class SyncReadStream , class DynamicBuffer , class CompletionCondition >
std::enable_if_t< is_dynamic_buffer< std::decay_t< DynamicBuffer > >::value, stdx::expected< size_t, std::error_code > >	read (SyncReadStream &stream, DynamicBuffer &&b, CompletionCondition cond)
template<class AsyncReadStream , class DynamicBuffer , class CompletionCondition , class CompletionToken >
std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, void >	async_read (AsyncReadStream &stream, DynamicBuffer &&b, CompletionCondition completion_condition, CompletionToken &&token)
template<class AsyncReadStream , class DynamicBuffer , class CompletionToken >
std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, void >	async_read (AsyncReadStream &stream, DynamicBuffer &&b, CompletionToken &&token)
template<class SyncWriteStream , class ConstBufferSequence >
std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, stdx::expected< size_t, std::error_code > >	write (SyncWriteStream &stream, const ConstBufferSequence &buffers)
template<class SyncWriteStream , class ConstBufferSequence , class CompletionCondition >
std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, stdx::expected< size_t, std::error_code > >	write (SyncWriteStream &stream, const ConstBufferSequence &buffers, CompletionCondition cond)
template<class SyncWriteStream , class DynamicBuffer >
std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, stdx::expected< size_t, std::error_code > >	write (SyncWriteStream &stream, DynamicBuffer &&b)
template<class SyncWriteStream , class DynamicBuffer , class CompletionCondition >
std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, stdx::expected< size_t, std::error_code > >	write (SyncWriteStream &stream, DynamicBuffer &&b, CompletionCondition cond)
template<class AsyncWriteStream , class ConstBufferSequence , class CompletionCondition , class CompletionToken >
std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, void >	async_write (AsyncWriteStream &stream, const ConstBufferSequence &buffers, CompletionCondition cond, CompletionToken &&token)
template<class AsyncWriteStream , class ConstBufferSequence , class CompletionToken >
std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, void >	async_write (AsyncWriteStream &stream, const ConstBufferSequence &buffers, CompletionToken &&token)
template<class AsyncWriteStream , class DynamicBuffer , class CompletionCondition , class CompletionToken >
std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, void >	async_write (AsyncWriteStream &stream, DynamicBuffer &&b, CompletionCondition cond, CompletionToken &&token)
template<class AsyncWriteStream , class DynamicBuffer , class CompletionToken >
std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, void >	async_write (AsyncWriteStream &stream, DynamicBuffer &&b, CompletionToken &&token)
template<class T >
associated_allocator_t< T >	get_associated_allocator (const T &t) noexcept
template<class T , class ProtoAllocator >
associated_allocator_t< T >	get_associated_allocator (const T &t, const ProtoAllocator &a) noexcept
template<class Service >
Service::key_type &	use_service (execution_context &ctx)
template<class Service , class... Args>
Service &	make_service (execution_context &ctx, Args &&... args)
template<class Service >
bool	has_service (const execution_context &ctx) noexcept
template<class T >
associated_executor_t< T >	get_associated_executor (const T &t) noexcept
template<class T , class Executor >
associated_executor_t< T, Executor >	get_associated_executor (const T &t, const Executor &ex) noexcept
template<class T , class ExecutorContext >
associated_executor_t< T, typename ExecutorContext::executor_type >	get_associated_executor (const T &t, const ExecutorContext &ctx) noexcept
template<class Executor >
std::enable_if_t< is_executor< Executor >::value, executor_work_guard< Executor > >	make_work_guard (const Executor &ex)
template<class ExecutionContext >
std::enable_if_t< std::is_convertible< ExecutionContext &, execution_context & >::value, executor_work_guard< typename ExecutionContext::executor_type > >	make_work_guard (ExecutionContext &ctx)
template<class T >
std::enable_if_t<!is_executor< T >::value &&!std::is_convertible< T &, execution_context & >::value, executor_work_guard< associated_executor_t< T > > >	make_work_guard (const T &t)
template<class T , class U >
auto	make_work_guard (const T &t, U &&u) -> decltype(make_work_guard(get_associated_executor(t, std::forward< U >(u))))
bool	operator== (const system_executor &, const system_executor &)
bool	operator!= (const system_executor &, const system_executor &)
template<class CompletionToken >
auto	dispatch (CompletionToken &&token)
template<class Executor , class CompletionToken >
std::enable_if_t< is_executor< Executor >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type >	dispatch (const Executor &ex, CompletionToken &&token)
	queue a function call for later execution. More...
template<class ExecutionContext , class CompletionToken >
std::enable_if_t< std::is_convertible< ExecutionContext &, execution_context & >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type >	dispatch (ExecutionContext &ctx, CompletionToken &&token)
	queue a function call for later execution. More...
template<class CompletionToken >
auto	post (CompletionToken &&token)
	queue a function call for later execution. More...
template<class Executor , class CompletionToken >
std::enable_if_t< is_executor< Executor >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type >	post (const Executor &ex, CompletionToken &&token)
	queue a function call for later execution. More...
template<class ExecutionContext , class CompletionToken >
std::enable_if_t< std::is_convertible< ExecutionContext &, execution_context & >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type >	post (ExecutionContext &ctx, CompletionToken &&token)
	queue a function call for later execution. More...
template<class CompletionToken >
auto	defer (CompletionToken &&token)
template<class Executor , class CompletionToken >
std::enable_if_t< is_executor< Executor >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type >	defer (const Executor &ex, CompletionToken &&token)
	queue a function call for later execution. More...
template<class ExecutionContext , class CompletionToken >
std::enable_if_t< std::is_convertible< ExecutionContext &, execution_context & >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type >	defer (ExecutionContext &ctx, CompletionToken &&token)
	queue a function call for later execution. More...
template<class Executor >
bool	operator== (const strand< Executor > &a, const strand< Executor > &b)
template<class Executor >
bool	operator!= (const strand< Executor > &a, const strand< Executor > &b)
const std::error_category &	io_service_category () noexcept
std::error_code	make_error_code (net::io_service_errc e) noexcept
constexpr bool	operator== (const fd_event &a, const fd_event &b)
constexpr bool	operator!= (const fd_event &a, const fd_event &b)
const std::error_category &	socket_category () noexcept
std::error_code	make_error_code (net::socket_errc e) noexcept
bool	operator== (const io_context::executor_type &a, const io_context::executor_type &b) noexcept
bool	operator!= (const io_context::executor_type &a, const io_context::executor_type &b) noexcept
template<class Protocol , class EndpointSequence , class ConnectCondition >
stdx::expected< typename Protocol::endpoint, std::error_code >	connect (basic_socket< Protocol > &s, const EndpointSequence &endpoints, ConnectCondition c)
	connect to the first endpoint that is connectable from a sequence of endpoints. More...
template<class Protocol , class EndpointSequence >
stdx::expected< typename Protocol::endpoint, std::error_code >	connect (basic_socket< Protocol > &s, const EndpointSequence &endpoints)
	connect to the first endpoint that is connectable. More...
template<class Protocol , class InputIterator , class ConnectCondition >
stdx::expected< InputIterator, std::error_code >	connect (basic_socket< Protocol > &s, InputIterator first, InputIterator last, ConnectCondition c)
	connect to the first endpoint that is connectable from a range [first, last). More...
template<class Protocol , class InputIterator , class ConnectCondition >
stdx::expected< InputIterator, std::error_code >	connect (basic_socket< Protocol > &s, InputIterator first, InputIterator last)

Variables
template<class T >
constexpr bool	is_const_buffer_sequence_v = is_const_buffer_sequence<T>::value
template<class T >
constexpr bool	is_mutable_buffer_sequence_v
template<class T >
constexpr bool	is_dynamic_buffer_v = is_dynamic_buffer<T>::value
template<class T >
constexpr bool	is_executor_v = is_executor<T>::value
constexpr executor_arg_t	executor_arg = executor_arg_t()
template<class T , class Executor >
constexpr bool	uses_executor_v = uses_executor<T, Executor>::value

Typedef Documentation

associated_allocator_t

template<class T , class ProtoAllocator = std::allocator<void>>

using net::associated_allocator_t = typedef typename associated_allocator<T, ProtoAllocator>::type

associated_executor_t

template<class T , class Executor = system_executor>

using net::associated_executor_t = typedef typename associated_executor<T, Executor>::type

high_resolution_timer

using net::high_resolution_timer = typedef basic_waitable_timer<std::chrono::high_resolution_clock>

io_service_impl_default

using net::io_service_impl_default = typedef linux_epoll_io_service

steady_timer

using net::steady_timer = typedef basic_waitable_timer<std::chrono::steady_clock>

system_timer

using net::system_timer = typedef basic_waitable_timer<std::chrono::system_clock>

Enumeration Type Documentation

fork_event

enum class net::fork_event

strong

Enumerator
prepare
parent
child

io_service_errc

enum class net::io_service_errc

strong

Enumerator
no_fds

socket_errc

enum class net::socket_errc

strong

Enumerator
already_open
not_found

stream_errc

enum class net::stream_errc

strong

Enumerator
eof
not_found

Function Documentation

async_read() [1/2]

template<class AsyncReadStream , class DynamicBuffer , class CompletionCondition , class CompletionToken >

std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, void > net::async_read	(	AsyncReadStream &	stream,
		DynamicBuffer &&	b,
		CompletionCondition	completion_condition,
		CompletionToken &&	token
	)

async_read() [2/2]

template<class AsyncReadStream , class DynamicBuffer , class CompletionToken >

std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, void > net::async_read	(	AsyncReadStream &	stream,
		DynamicBuffer &&	b,
		CompletionToken &&	token
	)

async_write() [1/4]

template<class AsyncWriteStream , class ConstBufferSequence , class CompletionCondition , class CompletionToken >

std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, void > net::async_write	(	AsyncWriteStream &	stream,
		const ConstBufferSequence &	buffers,
		CompletionCondition	cond,
		CompletionToken &&	token
	)

async_write() [2/4]

template<class AsyncWriteStream , class ConstBufferSequence , class CompletionToken >

std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, void > net::async_write	(	AsyncWriteStream &	stream,
		const ConstBufferSequence &	buffers,
		CompletionToken &&	token
	)

async_write() [3/4]

template<class AsyncWriteStream , class DynamicBuffer , class CompletionCondition , class CompletionToken >

std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, void > net::async_write	(	AsyncWriteStream &	stream,
		DynamicBuffer &&	b,
		CompletionCondition	cond,
		CompletionToken &&	token
	)

async_write() [4/4]

template<class AsyncWriteStream , class DynamicBuffer , class CompletionToken >

std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, void > net::async_write	(	AsyncWriteStream &	stream,
		DynamicBuffer &&	b,
		CompletionToken &&	token
	)

buffer() [1/25]

const_buffer net::buffer ( const const_buffer &  b )

inlinenoexcept

buffer() [2/25]

const_buffer net::buffer ( const const_buffer &  b, size_t  n  )

inlinenoexcept

buffer() [3/25]

mutable_buffer net::buffer ( const mutable_buffer &  b )

inlinenoexcept

buffer() [4/25]

mutable_buffer net::buffer ( const mutable_buffer &  b, size_t  n  )

inlinenoexcept

buffer() [5/25]

template<class CharT , class Traits , class Allocator >

const_buffer net::buffer ( const std::basic_string< CharT, Traits, Allocator > &  data )

inlinenoexcept

buffer() [6/25]

template<class CharT , class Traits , class Allocator >

const_buffer net::buffer ( const std::basic_string< CharT, Traits, Allocator > &  data, size_t  n  )

inlinenoexcept

buffer() [7/25]

template<class CharT , class Traits >

const_buffer net::buffer ( const std::basic_string_view< CharT, Traits > &  data )

inlinenoexcept

buffer() [8/25]

template<class T , std::size_t E>

const_buffer net::buffer ( const std::span< T, E > &  data )

inlinenoexcept

buffer() [9/25]

template<class T , std::size_t E>

const_buffer net::buffer ( const std::span< T, E > &  data, size_t  n  )

inlinenoexcept

buffer() [10/25]

template<class T , class Allocator >

const_buffer net::buffer ( const std::vector< T, Allocator > &  data )

inlinenoexcept

buffer() [11/25]

template<class T , class Allocator >

const_buffer net::buffer ( const std::vector< T, Allocator > &  data, size_t  n  )

inlinenoexcept

buffer() [12/25]

template<class T , size_t N>

const_buffer net::buffer ( const T(&)  data[N] )

inlinenoexcept

buffer() [13/25]

template<class T , size_t N>

const_buffer net::buffer ( const T(&)  data[N], size_t  n  )

inlinenoexcept

buffer() [14/25]

const_buffer net::buffer ( const void *  p, size_t  n  )

inlinenoexcept

buffer() [15/25]

template<class T , size_t N>

const_buffer net::buffer ( std::array< const T, N > &  data )

inlinenoexcept

buffer() [16/25]

template<class T , size_t N>

const_buffer net::buffer ( std::array< const T, N > &  data, size_t  n  )

inlinenoexcept

buffer() [17/25]

template<class T , size_t N>

mutable_buffer net::buffer ( std::array< T, N > &  data )

inlinenoexcept

buffer() [18/25]

template<class T , size_t N>

mutable_buffer net::buffer ( std::array< T, N > &  data, size_t  n  )

inlinenoexcept

buffer() [19/25]

template<class CharT , class Traits , class Allocator >

mutable_buffer net::buffer ( std::basic_string< CharT, Traits, Allocator > &  data )

inlinenoexcept

buffer() [20/25]

template<class CharT , class Traits , class Allocator >

mutable_buffer net::buffer ( std::basic_string< CharT, Traits, Allocator > &  data, size_t  n  )

inlinenoexcept

buffer() [21/25]

template<class T , class Allocator >

mutable_buffer net::buffer ( std::vector< T, Allocator > &  data )

inlinenoexcept

buffer() [22/25]

template<class T , class Allocator >

mutable_buffer net::buffer ( std::vector< T, Allocator > &  data, size_t  n  )

inlinenoexcept

buffer() [23/25]

template<class T , size_t N>

mutable_buffer net::buffer ( T(&)  data[N] )

inlinenoexcept

buffer() [24/25]

template<class T , size_t N>

mutable_buffer net::buffer ( T(&)  data[N], size_t  n  )

inlinenoexcept

buffer() [25/25]

mutable_buffer net::buffer ( void *  p, size_t  n  )

inlinenoexcept

buffer_copy() [1/2]

template<class MutableBufferSequence , class ConstBufferSequence >

size_t net::buffer_copy ( const MutableBufferSequence &  dest, const ConstBufferSequence &  src  )

noexcept

buffer_copy() [2/2]

template<class MutableBufferSequence , class ConstBufferSequence >

size_t net::buffer_copy ( const MutableBufferSequence &  dest, const ConstBufferSequence &  src, const size_t  max_size  )

noexcept

copy bytes from a ConstBufferSequence to a MutableBufferSequence.

copies min(max_bytes, buffer_size(src), buffer_size(dest)) bytes

Parameters

dest	buffer-sequence to copy to
src	buffer-sequence to copy from
max_size	max bytes to copy

Returns

bytes transferred from src to dest

see: 16.9 [buffer.copy]

buffer_sequence_begin() [1/4]

template<class C >

auto net::buffer_sequence_begin ( C &  c ) -> decltype(c.begin())

inlinenoexcept

buffer_sequence_begin() [2/4]

template<class C >

auto net::buffer_sequence_begin ( const C &  c ) -> decltype(c.begin())

inlinenoexcept

buffer_sequence_begin() [3/4]

const const_buffer * net::buffer_sequence_begin ( const const_buffer &  b )

inlinenoexcept

buffer_sequence_begin() [4/4]

const mutable_buffer * net::buffer_sequence_begin ( const mutable_buffer &  b )

inlinenoexcept

buffer_sequence_end() [1/4]

template<class C >

auto net::buffer_sequence_end ( C &  c ) -> decltype(c.end())

inlinenoexcept

buffer_sequence_end() [2/4]

template<class C >

auto net::buffer_sequence_end ( const C &  c ) -> decltype(c.end())

inlinenoexcept

buffer_sequence_end() [3/4]

const const_buffer * net::buffer_sequence_end ( const const_buffer &  b )

inlinenoexcept

buffer_sequence_end() [4/4]

const mutable_buffer * net::buffer_sequence_end ( const mutable_buffer &  b )

inlinenoexcept

buffer_size()

template<class ConstBufferSequence >

size_t net::buffer_size ( const ConstBufferSequence &  buffers )

inlinenoexcept

buffer_size< const_buffer >()

template<>

size_t net::buffer_size< const_buffer > ( const const_buffer &  b )

inlinenoexcept

buffer_size< mutable_buffer >()

template<>

size_t net::buffer_size< mutable_buffer > ( const mutable_buffer &  b )

inlinenoexcept

connect() [1/4]

template<class Protocol , class EndpointSequence >

stdx::expected< typename Protocol::endpoint, std::error_code > net::connect	(	basic_socket< Protocol > &	s,
		const EndpointSequence &	endpoints
	)

connect to the first endpoint that is connectable.

Parameters

s	socket that should be connected to an endpoint
endpoints	a sequence of endpoints

Returns

endpoint the connect succeeded for on success, last error-code otherwise

connect() [2/4]

template<class Protocol , class EndpointSequence , class ConnectCondition >

stdx::expected< typename Protocol::endpoint, std::error_code > net::connect	(	basic_socket< Protocol > &	s,
		const EndpointSequence &	endpoints,
		ConnectCondition	c
	)

connect to the first endpoint that is connectable from a sequence of endpoints.

Parameters

s	socket that should be connected to an endpoint
endpoints	a sequence of endpoints
c	ConnectionCondition that must return true if the provided endpoint should be attempted to be connected to

Returns

endpoint the connect succeeded for on success, last error-code otherwise

connect() [3/4]

template<class Protocol , class InputIterator , class ConnectCondition >

stdx::expected< InputIterator, std::error_code > net::connect	(	basic_socket< Protocol > &	s,
		InputIterator	first,
		InputIterator	last
	)

connect() [4/4]

template<class Protocol , class InputIterator , class ConnectCondition >

stdx::expected< InputIterator, std::error_code > net::connect	(	basic_socket< Protocol > &	s,
		InputIterator	first,
		InputIterator	last,
		ConnectCondition	c
	)

connect to the first endpoint that is connectable from a range [first, last).

Parameters

s	socket that should be connected to an endpoint
first	iterator to the first endpoint
last	iterator after to the last endpoint
c	ConnectionCondition that must return true if the provided endpoint should be attempted to be connected to

Returns

endpoint the connect succeeded for on success, last error-code otherwise

defer() [1/3]

template<class CompletionToken >

auto net::defer

(

CompletionToken &&

token

)

defer() [2/3]

template<class Executor , class CompletionToken >

std::enable_if_t< is_executor< Executor >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type > net::defer	(	const Executor &	ex,
		CompletionToken &&	token
	)

queue a function call for later execution.

defer() [3/3]

template<class ExecutionContext , class CompletionToken >

std::enable_if_t< std::is_convertible< ExecutionContext &, execution_context & >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type > net::defer	(	ExecutionContext &	ctx,
		CompletionToken &&	token
	)

queue a function call for later execution.

dispatch() [1/3]

template<class CompletionToken >

auto net::dispatch

(

CompletionToken &&

token

)

dispatch() [2/3]

template<class Executor , class CompletionToken >

std::enable_if_t< is_executor< Executor >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type > net::dispatch	(	const Executor &	ex,
		CompletionToken &&	token
	)

queue a function call for later execution.

dispatch() [3/3]

template<class ExecutionContext , class CompletionToken >

std::enable_if_t< std::is_convertible< ExecutionContext &, execution_context & >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type > net::dispatch	(	ExecutionContext &	ctx,
		CompletionToken &&	token
	)

queue a function call for later execution.

dynamic_buffer() [1/4]

template<class CharT , class Traits , class Allocator >

dynamic_string_buffer< CharT, Traits, Allocator > net::dynamic_buffer ( std::basic_string< CharT, Traits, Allocator > &  str )

noexcept

dynamic_buffer() [2/4]

template<class CharT , class Traits , class Allocator >

dynamic_string_buffer< CharT, Traits, Allocator > net::dynamic_buffer ( std::basic_string< CharT, Traits, Allocator > &  str, size_t  n  )

noexcept

dynamic_buffer() [3/4]

template<class T , class Allocator >

dynamic_vector_buffer< T, Allocator > net::dynamic_buffer ( std::vector< T, Allocator > &  vec )

noexcept

dynamic_buffer() [4/4]

template<class T , class Allocator >

dynamic_vector_buffer< T, Allocator > net::dynamic_buffer ( std::vector< T, Allocator > &  vec, size_t  n  )

noexcept

get_associated_allocator() [1/2]

template<class T >

associated_allocator_t< T > net::get_associated_allocator ( const T &  t )

noexcept

get_associated_allocator() [2/2]

template<class T , class ProtoAllocator >

associated_allocator_t< T > net::get_associated_allocator ( const T &  t, const ProtoAllocator &  a  )

noexcept

get_associated_executor() [1/3]

template<class T >

associated_executor_t< T > net::get_associated_executor ( const T &  t )

noexcept

get_associated_executor() [2/3]

template<class T , class Executor >

associated_executor_t< T, Executor > net::get_associated_executor ( const T &  t, const Executor &  ex  )

noexcept

get_associated_executor() [3/3]

template<class T , class ExecutorContext >

associated_executor_t< T, typename ExecutorContext::executor_type > net::get_associated_executor ( const T &  t, const ExecutorContext &  ctx  )

noexcept

has_service()

template<class Service >

bool net::has_service ( const execution_context &  ctx )

noexcept

io_service_category()

const std::error_category & net::io_service_category ( )

inlinenoexcept

make_error_code() [1/3]

std::error_code net::make_error_code ( net::io_service_errc  e )

inlinenoexcept

make_error_code() [2/3]

std::error_code net::make_error_code ( net::socket_errc  e )

inlinenoexcept

make_error_code() [3/3]

std::error_code net::make_error_code ( net::stream_errc  e )

inlinenoexcept

make_error_condition()

std::error_condition net::make_error_condition ( net::stream_errc  e )

inlinenoexcept

make_service()

template<class Service , class... Args>

Service & net::make_service	(	execution_context &	ctx,
		Args &&...	args
	)

make_work_guard() [1/4]

template<class Executor >

std::enable_if_t< is_executor< Executor >::value, executor_work_guard< Executor > > net::make_work_guard

(

const Executor &

ex

)

make_work_guard() [2/4]

template<class T >

std::enable_if_t<!is_executor< T >::value && !std::is_convertible< T &, execution_context & >::value, executor_work_guard< associated_executor_t< T > > > net::make_work_guard

(

const T &

t

)

make_work_guard() [3/4]

template<class T , class U >

auto net::make_work_guard	(	const T &	t,
		U &&	u
	)		-> decltype(make_work_guard(get_associated_executor(t, std::forward<U>(u))))

make_work_guard() [4/4]

template<class ExecutionContext >

std::enable_if_t< std::is_convertible< ExecutionContext &, execution_context & >::value, executor_work_guard< typename ExecutionContext::executor_type > > net::make_work_guard

(

ExecutionContext &

ctx

)

operator!=() [1/4]

constexpr bool net::operator!= ( const fd_event &  a, const fd_event &  b  )

inlineconstexpr

operator!=() [2/4]

bool net::operator!= ( const io_context::executor_type &  a, const io_context::executor_type &  b  )

inlinenoexcept

operator!=() [3/4]

template<class Executor >

bool net::operator!=	(	const strand< Executor > &	a,
		const strand< Executor > &	b
	)

operator!=() [4/4]

bool net::operator!= ( const system_executor &  , const system_executor &    )

inline

operator+() [1/4]

const_buffer net::operator+ ( const const_buffer &  b, size_t  n  )

inlinenoexcept

operator+() [2/4]

mutable_buffer net::operator+ ( const mutable_buffer &  b, size_t  n  )

inlinenoexcept

operator+() [3/4]

const_buffer net::operator+ ( size_t  n, const const_buffer &  b  )

inlinenoexcept

operator+() [4/4]

mutable_buffer net::operator+ ( size_t  n, const mutable_buffer &  b  )

inlinenoexcept

operator==() [1/4]

constexpr bool net::operator== ( const fd_event &  a, const fd_event &  b  )

inlineconstexpr

operator==() [2/4]

bool net::operator== ( const io_context::executor_type &  a, const io_context::executor_type &  b  )

inlinenoexcept

operator==() [3/4]

template<class Executor >

bool net::operator==	(	const strand< Executor > &	a,
		const strand< Executor > &	b
	)

operator==() [4/4]

bool net::operator== ( const system_executor &  , const system_executor &    )

inline

post() [1/3]

template<class CompletionToken >

auto net::post

(

CompletionToken &&

token

)

queue a function call for later execution.

post() [2/3]

template<class Executor , class CompletionToken >

std::enable_if_t< is_executor< Executor >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type > net::post	(	const Executor &	ex,
		CompletionToken &&	token
	)

queue a function call for later execution.

post() [3/3]

template<class ExecutionContext , class CompletionToken >

std::enable_if_t< std::is_convertible< ExecutionContext &, execution_context & >::value, typename async_result< std::decay_t< CompletionToken >, void()>::return_type > net::post	(	ExecutionContext &	ctx,
		CompletionToken &&	token
	)

queue a function call for later execution.

read() [1/4]

template<class SyncReadStream , class MutableBufferSequence >

std::enable_if_t< is_mutable_buffer_sequence< MutableBufferSequence >::value, stdx::expected< size_t, std::error_code > > net::read	(	SyncReadStream &	stream,
		const MutableBufferSequence &	buffers
	)

read() [2/4]

template<class SyncReadStream , class MutableBufferSequence , class CompletionCondition >

std::enable_if_t< is_mutable_buffer_sequence< MutableBufferSequence >::value, stdx::expected< size_t, std::error_code > > net::read	(	SyncReadStream &	stream,
		const MutableBufferSequence &	buffers,
		CompletionCondition	cond
	)

read() [3/4]

template<class SyncReadStream , class DynamicBuffer >

std::enable_if_t< is_dynamic_buffer< std::decay_t< DynamicBuffer > >::value, stdx::expected< size_t, std::error_code > > net::read	(	SyncReadStream &	stream,
		DynamicBuffer &&	b
	)

read() [4/4]

template<class SyncReadStream , class DynamicBuffer , class CompletionCondition >

std::enable_if_t< is_dynamic_buffer< std::decay_t< DynamicBuffer > >::value, stdx::expected< size_t, std::error_code > > net::read	(	SyncReadStream &	stream,
		DynamicBuffer &&	b,
		CompletionCondition	cond
	)

socket_category()

const std::error_category & net::socket_category ( )

inlinenoexcept

stream_category()

const std::error_category & net::stream_category ( )

inlinenoexcept

use_service()

template<class Service >

Service::key_type & net::use_service

(

execution_context &

ctx

)

write() [1/4]

template<class SyncWriteStream , class ConstBufferSequence >

std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, stdx::expected< size_t, std::error_code > > net::write	(	SyncWriteStream &	stream,
		const ConstBufferSequence &	buffers
	)

write() [2/4]

template<class SyncWriteStream , class ConstBufferSequence , class CompletionCondition >

std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, stdx::expected< size_t, std::error_code > > net::write	(	SyncWriteStream &	stream,
		const ConstBufferSequence &	buffers,
		CompletionCondition	cond
	)

write() [3/4]

template<class SyncWriteStream , class DynamicBuffer >

std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, stdx::expected< size_t, std::error_code > > net::write	(	SyncWriteStream &	stream,
		DynamicBuffer &&	b
	)

write() [4/4]

template<class SyncWriteStream , class DynamicBuffer , class CompletionCondition >

std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, stdx::expected< size_t, std::error_code > > net::write	(	SyncWriteStream &	stream,
		DynamicBuffer &&	b,
		CompletionCondition	cond
	)

Variable Documentation

executor_arg

constexpr executor_arg_t net::executor_arg = executor_arg_t()

constexpr

is_const_buffer_sequence_v

template<class T >

constexpr bool net::is_const_buffer_sequence_v = is_const_buffer_sequence<T>::value

constexpr

is_dynamic_buffer_v

template<class T >

constexpr bool net::is_dynamic_buffer_v = is_dynamic_buffer<T>::value

constexpr

is_executor_v

template<class T >

constexpr bool net::is_executor_v = is_executor<T>::value

constexpr

is_mutable_buffer_sequence_v

template<class T >

constexpr bool net::is_mutable_buffer_sequence_v

constexpr

Initial value:

=
    is_mutable_buffer_sequence<T>::value

uses_executor_v

template<class T , class Executor >

constexpr bool net::uses_executor_v = uses_executor<T, Executor>::value

constexpr