| ►Ccaf::abstract_event_based_actor< behavior, false, abstract_broker > | |
| Ccaf::io::broker | Describes a dynamically typed broker |
| Ccaf::abstract_event_based_actor< BehaviorType, HasSyncSend, Base > | Base type for statically and dynamically typed event-based actors |
| Ccaf::abstract_group::module | Interface for user-defined multicast implementations |
| Ccaf::actor | Identifies an untyped actor |
| Ccaf::actor_addr | Stores the address of typed as well as untyped actors |
| Ccaf::actor_namespace | Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages |
| Ccaf::actor_namespace::backend | The backend of an actor namespace is responsible for creating proxy actors |
| Ccaf::actor_namespace::proxy_entry | Ensures that kill_proxy is called for each proxy instance |
| Ccaf::actor_ostream | Provides support for thread-safe output operations on character streams |
| Ccaf::advanced_match_case_impl< F, Tuple, Pattern, Projections > | |
| Ccaf::anything | Acts as wildcard expression in patterns |
| Ccaf::atom_constant< V > | Lifts an atom_value to a compile-time constant |
| Ccaf::attachable | Callback utility class |
| Ccaf::attachable::token | Represents a pointer to a value with its subtype as type ID number |
| Ccaf::behavior | Describes the behavior of an actor, i.e., provides a message handler and an optional timeout |
| Ccaf::blocking_response_handle_tag | This tag identifies response handles featuring a blocking API by providing an await member function |
| Ccaf::callback< Ts > | Describes a simple callback, usually implemented via lambda expression |
| Ccaf::channel | A handle to instances of abstract_channel |
| Ccaf::continue_helper | Helper class to enable users to add continuations when dealing with synchronous sends |
| Ccaf::delegated< Ts > | Helper class to indicate that a request has been forwarded |
| ►Ccaf::deserializer | Technology-independent deserialization interface |
| Ccaf::binary_deserializer | Implements the deserializer interface with a binary serialization protocol |
| Ccaf::down_msg | Sent to all actors monitoring an actor when it is terminated |
| Ccaf::duration | Time duration consisting of a time_unit and a 64 bit unsigned integer |
| Ccaf::execution_unit | Identifies an execution unit, e.g., a worker thread of the scheduler |
| Ccaf::exit_msg | Sent to all links when an actor is terminated |
| Ccaf::extend< Base, Derived > | Allows convenient definition of types using mixins |
| Ccaf::group_down_msg | Sent to all members of a group when it goes offline |
| Ccaf::handle< Subtype, InvalidType, InvalidId > | Base class for IO handles such as accept_handle or connection_handle |
| Ccaf::illegal_message_element | Marker class identifying classes in CAF that are not allowed to be used as message element |
| Ccaf::intrusive_ptr< T > | An intrusive, reference counting smart pointer impelementation |
| Ccaf::invalid_node_id_t | Objects of this type identify an invalid node_id |
| Ccaf::io::acceptor_closed_msg | Signalizes that a broker acceptor has been closed |
| Ccaf::io::basp::header | The header of a Binary Actor System Protocol (BASP) message |
| Ccaf::io::basp::instance | Describes a protocol instance managing multiple connections |
| Ccaf::io::basp::instance::callee | Provides a callback-based interface for certain BASP events |
| Ccaf::io::basp::routing_table | Stores routing information for a single broker participating as BASP peer and provides both direct and indirect paths |
| Ccaf::io::basp::routing_table::route | Describes a routing path to a node |
| ►Ccaf::io::broker_servant< Base, Handle, SysMsgType > | Base class for scribe and doorman |
| Ccaf::io::doorman | Manages incoming connections |
| Ccaf::io::scribe | Manages a stream |
| Ccaf::io::connection_closed_msg | Signalizes that a broker connection has been closed |
| Ccaf::io::hook | Interface to define hooks into the IO layer |
| Ccaf::io::middleman | Manages brokers and network backends |
| Ccaf::io::network::default_socket | Low-level socket type used as default |
| ►Ccaf::io::network::event_handler | A socket IO event handler |
| Ccaf::io::network::acceptor< SocketAcceptor > | An acceptor is responsible for accepting incoming connections |
| Ccaf::io::network::stream< Socket > | A stream capable of both reading and writing |
| Ccaf::io::network::interfaces | Utility class bundling access to network interface names and addresses |
| ►Ccaf::io::network::multiplexer | Low-level backend for IO multiplexing |
| Ccaf::io::network::asio_multiplexer | A wrapper for the boost::asio multiplexer |
| Ccaf::io::network::multiplexer::supervisor | Makes sure the multipler does not exit its event loop until the destructor of supervisor has been called |
| Ccaf::io::new_connection_msg | Signalizes a newly accepted connection from a broker |
| Ccaf::io::new_data_msg | Signalizes newly arrived data for a broker |
| Ccaf::is_anything< T > | |
| Ccaf::is_same_ish< T, U > | Compares T to U und evaluates to true_type if either `T == U or if T and U are both integral types of the same size and signedness |
| Ccaf::maybe< T > | Represents a computation returning either T or std::error_condition |
| ►Ccaf::memory_managed | This base enables derived classes to enforce a different allocation strategy than new/delete by providing a virtual protected request_deletion() function and non-public destructor |
| ►Ccaf::ref_counted | Base class for reference counted objects with an atomic reference count |
| ►Ccaf::abstract_channel | Interface for all message receivers |
| ►Ccaf::abstract_actor | Base class for all actor implementations |
| Ccaf::actor_pool | An actor poool is a lightweight abstraction for a set of workers |
| ►Ccaf::actor_proxy | Represents an actor running on a remote machine, or different hardware, or in a separate process |
| Ccaf::forwarding_actor_proxy | Implements a simple proxy forwarding all operations to a manager |
| ►Ccaf::local_actor | Base class for actors running on this node, either living in an own thread or cooperatively scheduled |
| ►Ccaf::abstract_event_based_actor< behavior, true > | |
| Ccaf::actor_companion | An co-existing forwarding all messages through a user-defined callback to another object, thus serving as gateway to allow any object to interact with other actors |
| Ccaf::event_based_actor | A cooperatively scheduled, event-based actor implementation |
| ►Ccaf::abstract_event_based_actor< typed_behavior< Sigs...>, true > | |
| Ccaf::typed_event_based_actor< Sigs > | A cooperatively scheduled, event-based actor implementation with strong type checking |
| Ccaf::actor_companion | An co-existing forwarding all messages through a user-defined callback to another object, thus serving as gateway to allow any object to interact with other actors |
| Ccaf::blocking_actor | A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing |
| Ccaf::event_based_actor | A cooperatively scheduled, event-based actor implementation |
| ►Ccaf::io::abstract_broker | A broker mediates between actor systems and other components in the network |
| Ccaf::io::broker | Describes a dynamically typed broker |
| Ccaf::typed_event_based_actor< Sigs > | A cooperatively scheduled, event-based actor implementation with strong type checking |
| Ccaf::abstract_group | A multicast group |
| Ccaf::actor_proxy::anchor | An anchor points to a proxy instance without sharing ownership to it, i.e., models a weak ptr |
| ►Ccaf::io::network::manager | A manager configures an IO device and provides callbacks for various IO operations |
| Ccaf::io::network::acceptor_manager | An acceptor manager configures an acceptor and provides callbacks for incoming connections as well as for error handling |
| Ccaf::io::network::stream_manager | A stream manager configures an IO stream and provides callbacks for incoming data as well as for error handling |
| Ccaf::io::network::multiplexer::runnable | Simple wrapper for runnables |
| Ccaf::message | Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type |
| Ccaf::message::cli_arg | Stores the name of a command line option ("<long name>[,<short name>]") along with a description and a callback |
| Ccaf::message::cli_res | Stores the result of message::extract_opts |
| Ccaf::message_builder | Provides a convenient interface for createing message objects from a series of values using the member function append |
| Ccaf::message_handler | A partial function implementation used to process a message |
| Ccaf::message_id | Denotes whether a message is asynchronous or synchronous |
| Ccaf::node_id | A node ID consists of a host ID and process ID |
| Ccaf::nonblocking_response_handle_tag | This tag identifies response handles featuring a nonblocking API by providing a then member function |
| Ccaf::policy::profiled< Policy > | An enhancement of CAF's scheduling policy which records fine-grained resource utiliziation for worker threads and actors in the parent coordinator of the workers |
| ►Ccaf::policy::scheduler_policy | This concept class describes a policy for worker and coordinator of the scheduler |
| Ccaf::policy::work_sharing | |
| Ccaf::policy::work_stealing | Implements scheduling of actors via work stealing |
| Ccaf::policy::scheduler_policy::coordinator_data | Policy-specific data fields for the coordinator |
| Ccaf::policy::scheduler_policy::worker_data | Policy-specific data fields for the worker |
| Ccaf::ratio_to_time_unit_helper< Num, Denom > | Converts the ratio Num/Denom to a time_unit if the ratio describes seconds, milliseconds, microseconds, or minutes |
| Ccaf::response_handle< Self, ResultOptPairOrMessage, Tag > | This helper class identifies an expected response message and enables sync_send(...).then(...) |
| Ccaf::response_promise | A response promise can be used to deliver a uniquely identifiable response message from the server (i.e |
| ►Ccaf::resumable | A cooperatively executed task managed by one or more instances of execution_unit |
| Ccaf::local_actor | Base class for actors running on this node, either living in an own thread or cooperatively scheduled |
| Ccaf::scoped_actor | A scoped handle to a blocking actor |
| Ccaf::select_callback< F, Args > | Utility class for selecting a callback_impl |
| ►Ccaf::serializer | Technology-independent serialization interface |
| Ccaf::binary_serializer | Implements the serializer interface with a binary serialization protocol |
| Ccaf::skip_message_t | Optional return type for functors used in pattern matching expressions |
| Ccaf::spawn_options | Stores options passed to the spawn function family |
| Ccaf::stateful_actor< State, Base > | An event-based actor with managed state |
| Ccaf::sync_exited_msg | Sent whenever a terminated actor receives a synchronous request |
| Ccaf::sync_timeout_msg | Sent whenever a timeout occurs during a synchronous send |
| Ccaf::timeout_msg | Signalizes a timeout event |
| Ccaf::typed_actor< Sigs > | Identifies a statically typed actor |
| Ccaf::unbox_message_element< T > | Unboxes atom constants, i.e., converts atom_constant<V> to V |
| ►Ccaf::uniform_type_info | Provides a platform independent type name and a (very primitive) kind of reflection in combination with uniform_value |
| Ccaf::abstract_uniform_type_info< T > | Implements all pure virtual functions of uniform_type_info except serialize() and deserialize() |
| Ccaf::uniform_value_t | Generic container for storing a value with associated type information |
| Ccaf::variant< Ts > | A variant represents always a valid value of one of the types Ts... |
| ►Ccaf::callback< Ts...> | |
| Ccaf::callback_impl< F, Ts > | Utility class for wrapping a function object of type Base |
| ►Ccaf::handle< accept_handle, invalid_accept_handle_t > | |
| Ccaf::io::accept_handle | Generic handle type for managing incoming connections |
| ►Ccaf::handle< connection_handle, invalid_connection_handle_t > | |
| Ccaf::io::connection_handle | Generic handle type for identifying connections |
| Ccaf::intrusive_ptr< abstract_actor > | |
| Ccaf::intrusive_ptr< abstract_channel > | |
| Ccaf::intrusive_ptr< abstract_group > | |
| Ccaf::intrusive_ptr< anchor > | |
| Ccaf::intrusive_ptr< caf::blocking_actor > | |
| Ccaf::intrusive_ptr< caf::io::doorman > | |
| Ccaf::intrusive_ptr< caf::io::scribe > | |
| Ccaf::intrusive_ptr< caf::ref_counted > | |
| Ccaf::intrusive_ptr< data > | |
| Ccaf::intrusive_ptr< detail::behavior_impl > | |
| Ccaf::intrusive_ptr< manager_type > | |
| Ccaf::intrusive_ptr< stream_manager > | |
| Ccaf::maybe< caf::response_promise > | |
| ►Ccaf::stateful_actor< basp_broker_state, broker > | |
| Ccaf::io::basp_broker | A broker implementation for the Binary Actor System Protocol (BASP) |
| ►Cstd::exception | STL class |
| ►Ccaf::caf_exception | Base class for exceptions |
| Ccaf::actor_exited | Thrown if an actor finished execution |
| ►Ccaf::network_error | Thrown to indicate that either an actor publishing failed or the middleman was unable to connect to a remote host |
| Ccaf::bind_failure | Thrown to indicate that an actor publishing failed because the requested port could not be used |
1.8.9.1
