...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