MySQL  8.0.27
Source Code Documentation
net Namespace Reference

Namespaces

 impl
 
 ip
 
 socket_option
 

Classes

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

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
 
const const_bufferbuffer_sequence_begin (const const_buffer &b) noexcept
 
const const_bufferbuffer_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_bufferbuffer_sequence_begin (const mutable_buffer &b) noexcept
 
const mutable_bufferbuffer_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 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 , 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< ConstBufferSequence >::value, 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< ConstBufferSequence >::value, 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 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_typeuse_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
 
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

◆ 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 net::fork_event
strong
Enumerator
prepare 
parent 
child 

◆ io_service_errc

enum net::io_service_errc
strong
Enumerator
no_fds 

◆ socket_errc

enum net::socket_errc
strong
Enumerator
already_open 
not_found 

◆ stream_errc

enum 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/2]

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() [2/2]

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/22]

const_buffer net::buffer ( const const_buffer b)
inlinenoexcept

◆ buffer() [2/22]

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

◆ buffer() [3/22]

mutable_buffer net::buffer ( const mutable_buffer b)
inlinenoexcept

◆ buffer() [4/22]

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

◆ buffer() [5/22]

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

◆ buffer() [6/22]

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/22]

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

◆ buffer() [8/22]

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

◆ buffer() [9/22]

template<class T , size_t N>
const_buffer net::buffer ( const T(&)  data[N])
inlinenoexcept

◆ buffer() [10/22]

template<class T , size_t N>
const_buffer net::buffer ( const T(&)  data[N],
size_t  n 
)
inlinenoexcept

◆ buffer() [11/22]

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

◆ buffer() [12/22]

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

◆ buffer() [13/22]

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

◆ buffer() [14/22]

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

◆ buffer() [15/22]

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

◆ buffer() [16/22]

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

◆ buffer() [17/22]

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

◆ buffer() [18/22]

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

◆ buffer() [19/22]

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

◆ buffer() [20/22]

template<class T , size_t N>
mutable_buffer net::buffer ( T(&)  data[N])
inlinenoexcept

◆ buffer() [21/22]

template<class T , size_t N>
mutable_buffer net::buffer ( T(&)  data[N],
size_t  n 
)
inlinenoexcept

◆ buffer() [22/22]

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
destbuffer-sequence to copy to
srcbuffer-sequence to copy from
max_sizemax bytes to copy
Returns
bytes transfered 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
ssocket that should be connected to an endpoint
endpointsa 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
ssocket that should be connected to an endpoint
endpointsa sequence of endpoints
cConnectionCondition 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
ssocket that should be connected to an endpoint
firstiterator to the first endpoint
lastiterator after to the last endpoint
cConnectionCondition 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_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/3]

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

◆ operator!=() [2/3]

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

◆ operator!=() [3/3]

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/3]

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

◆ operator==() [2/3]

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

◆ operator==() [3/3]

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<ConstBufferSequence>::value, 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<ConstBufferSequence>::value, 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:
=
const string value("\"Value\"")

◆ uses_executor_v

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