MySQL 8.3.0
Source Code Documentation
executor.h File Reference
#include <algorithm>
#include <condition_variable>
#include <functional>
#include <list>
#include <memory>
#include <mutex>
#include <queue>
#include <stdexcept>
#include <thread>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <utility>
#include "my_compiler.h"
#include "mysql/harness/net_ts/impl/callstack.h"
#include "mysql/harness/net_ts/netfwd.h"

Go to the source code of this file.

Classes

class  net::async_result< CompletionToken, Signature >
 
class  net::async_completion< CompletionToken, Signature >
 
struct  net::associated_allocator_impl< T, ProtoAllocator, typename >
 
struct  net::associated_allocator_impl< T, ProtoAllocator, std::void_t< typename T::allocator_type > >
 
struct  net::associated_allocator< T, ProtoAllocator >
 
class  net::service_already_exists
 
class  net::execution_context
 
struct  net::execution_context::ServicePtr
 
class  net::execution_context::service
 
struct  net::impl::is_executor< T, class >
 
struct  net::impl::is_executor< T, decltype(executor_requirements< T >())>
 
struct  net::is_executor< T >
 
struct  net::executor_arg_t
 
struct  net::impl::uses_executor< T, Executor, typename >
 
struct  net::impl::uses_executor< T, Executor, std::void_t< typename T::executor_type > >
 
struct  net::uses_executor< T, Executor >
 
struct  net::associated_executor_impl< T, Executor, typename >
 
struct  net::associated_executor_impl< T, Executor, std::void_t< typename T::executor_type > >
 
struct  net::associated_executor< T, Executor >
 
class  net::executor_work_guard< Executor >
 
class  net::system_executor
 
class  net::system_context
 
struct  net::system_context::__tag
 
class  net::impl::Dispatcher< CompletionHandler >
 function object for net::dispatch(), net::post(), net::defer(). More...
 
class  net::strand< Executor >
 

Namespaces

namespace  net
 
namespace  net::impl
 

Typedefs

template<class T , class ProtoAllocator = std::allocator<void>>
using net::associated_allocator_t = typename associated_allocator< T, ProtoAllocator >::type
 
template<class T , class Executor = system_executor>
using net::associated_executor_t = typename associated_executor< T, Executor >::type
 

Enumerations

enum class  net::fork_event { net::prepare , net::parent , net::child }
 

Functions

template<class T >
associated_allocator_t< T > net::get_associated_allocator (const T &t) noexcept
 
template<class T , class ProtoAllocator >
associated_allocator_t< T > net::get_associated_allocator (const T &t, const ProtoAllocator &a) noexcept
 
template<class Service >
Service::key_type & net::use_service (execution_context &ctx)
 
template<class Service , class... Args>
Service & net::make_service (execution_context &ctx, Args &&... args)
 
template<class Service >
bool net::has_service (const execution_context &ctx) noexcept
 
template<class T , typename U = std::remove_const_t<T>>
auto net::impl::executor_requirements (U *__x=nullptr, const U *__const_x=nullptr, void(*f)()=nullptr, const std::allocator< int > &a={}) -> std::enable_if_t< std::conjunction< std::is_copy_constructible< T >, std::is_same< decltype(*__const_x== *__const_x), bool >, std::is_same< decltype(*__const_x != *__const_x), bool >, std::is_void< decltype(__x->on_work_started())>, std::is_void< decltype(__x->on_work_finished())>, std::is_void< decltype(__x->dispatch(std::move(f), a))>, std::is_void< decltype(__x->post(std::move(f), a))>, std::is_void< decltype(__x->defer(std::move(f), a))> >::value, std::void_t< decltype(__x->context()), void()> >
 
template<class T >
associated_executor_t< T > net::get_associated_executor (const T &t) noexcept
 
template<class T , class Executor >
associated_executor_t< T, Executor > net::get_associated_executor (const T &t, const Executor &ex) noexcept
 
template<class T , class ExecutorContext >
associated_executor_t< T, typename ExecutorContext::executor_type > net::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 > > net::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 > > net::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 > > > net::make_work_guard (const T &t)
 
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))))
 
bool net::operator== (const system_executor &, const system_executor &)
 
bool net::operator!= (const system_executor &, const system_executor &)
 
template<class CompletionHandler >
Dispatcher< CompletionHandler > net::impl::make_dispatcher (CompletionHandler &handler)
 
template<class CompletionToken >
auto net::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 > net::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 > net::dispatch (ExecutionContext &ctx, CompletionToken &&token)
 queue a function call for later execution. More...
 
template<class CompletionToken >
auto net::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 > net::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 > net::post (ExecutionContext &ctx, CompletionToken &&token)
 queue a function call for later execution. More...
 
template<class CompletionToken >
auto net::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 > net::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 > net::defer (ExecutionContext &ctx, CompletionToken &&token)
 queue a function call for later execution. More...
 
template<class Executor >
bool net::operator== (const strand< Executor > &a, const strand< Executor > &b)
 
template<class Executor >
bool net::operator!= (const strand< Executor > &a, const strand< Executor > &b)
 

Variables

template<class T >
constexpr bool net::is_executor_v = is_executor<T>::value
 
constexpr executor_arg_t net::executor_arg = executor_arg_t()
 
template<class T , class Executor >
constexpr bool net::uses_executor_v = uses_executor<T, Executor>::value