...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
A context for function object execution.
class execution_context : noncopyable
Name |
Description |
---|---|
Class used to uniquely identify a service. |
|
Base class for all io_context services. |
|
Fork-related event notifications. |
Name |
Description |
---|---|
execution_context [constructor] |
Constructor. |
Notify the execution_context of a fork-related event. |
|
~execution_context [destructor] |
Destructor. |
Name |
Description |
---|---|
Destroys all services in the context. |
|
Shuts down all services in the context. |
Name |
Description |
---|---|
(Deprecated: Use make_service().) Add a service object to the execution_context. |
|
Determine if an execution_context contains a specified service type. |
|
Creates a service object and adds it to the execution_context. |
|
Obtain the service object corresponding to the given type. |
An execution context represents a place where function objects will be executed.
An io_context
is an example
of an execution context.
Class execution_context
implements an
extensible, type-safe, polymorphic set of services, indexed by service type.
Services exist to manage the resources that are shared across an execution context. For example, timers may be implemented in terms of a single timer queue, and this queue would be stored in a service.
Access to the services of an execution_context
is via three function
templates, use_service()
,
add_service()
and has_service()
.
In a call to use_service<Service>()
, the type argument chooses a service,
making available all members of the named type. If Service
is not present in an execution_context
, an object of
type Service
is created and
added to the execution_context
. A C++ program
can check if an execution_context
implements a particular
service with the function template has_service<Service>()
.
Service objects may be explicitly added to an execution_context
using the function
template add_service<Service>()
.
If the Service
is already
present, the service_already_exists
exception
is thrown. If the owner of the service is not the same object as the execution_context
parameter, the invalid_service_owner
exception
is thrown.
Once a service reference is obtained from an execution_context
object by calling
use_service()
,
that reference remains usable as long as the owning execution_context
object exists.
All service implementations have execution_context::service
as a public base class.
Custom services may be implemented by deriving from this class and then added
to an execution_context
using the facilities
described above.
Class execution_context
may be used only
as a base class for concrete execution context types. The io_context
is an example of such a derived type.
On destruction, a class that is derived from execution_context
must perform
execution_context::shutdown()
followed by execution_context::destroy()
.
This destruction sequence permits programs to simplify their resource management
by using shared_ptr<>
.
Where an object's lifetime is tied to the lifetime of a connection (or some
other sequence of asynchronous operations), a shared_ptr
to the object would be bound into the handlers for all asynchronous operations
associated with it. This works as follows:
shared_ptr
references to the objects
are destroyed.
io_context
function stop() is
called to terminate any run() calls as soon as possible. The io_context
destructor calls
shutdown()
and destroy()
to destroy all pending handlers, causing all shared_ptr
references to all connection objects to be destroyed.
Header: boost/asio/execution_context.hpp
Convenience header: boost/asio/execution.hpp