|  | Home | Libraries | People | FAQ | More | 
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