libcaf  0.15.3
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 Ccaf::abstract_channelInterface for all message receivers
 Ccaf::abstract_composable_behaviorMarker type that allows CAF to spawn actors from composable states
 Ccaf::actorIdentifies an untyped actor
 Ccaf::actor_addrStores the address of typed as well as untyped actors
 Ccaf::actor_companionAn co-existing actor 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::actor_configStores spawn-time flags and groups
 Ccaf::actor_control_blockActors are always allocated with a control block that stores its identity as well as strong and weak reference counts to it
 Ccaf::actor_ostreamProvides support for thread-safe output operations on character streams
 Ccaf::actor_registryA registry is used to associate actors to IDs or atoms (names)
 Ccaf::actor_systemActor environment including scheduler, registry, and optional components such as a middleman
 Ccaf::actor_system::moduleAn (optional) component of the actor system
 Ccaf::actor_system_configConfigures an actor_system on startup
 Ccaf::allowed_unsafe_message_type< T >Template specializations can whitelist individual types for unsafe message passing operations
 Ccaf::arraybuf< CharT, Traits >A streambuffer abstraction over a fixed array of bytes
 Ccaf::atom_constant< V >Lifts an atom_value to a compile-time constant
 Ccaf::attachableCallback utility class
 Ccaf::attachable::tokenRepresents a pointer to a value with its subtype as type ID number
 Ccaf::behaviorDescribes the behavior of an actor, i.e., provides a message handler and an optional timeout
 Ccaf::blocking_actorA thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
 Ccaf::blocking_actor::do_receive_helperImplementation helper for blocking_actor::do_receive
 Ccaf::blocking_actor::receive_condRepresents pre- and postconditions for receive loops
 Ccaf::blocking_actor::receive_for_helper< T >Implementation helper for blocking_actor::receive_for
 Ccaf::blocking_actor::receive_while_helperImplementation helper for blocking_actor::receive_while
 Ccaf::callback< Ts >Describes a simple callback, usually implemented via lambda expression
 Ccaf::composable_behavior< TypedActor >Base type for composable actor states
 Ccaf::composable_behavior_base< MPI >Generates an interface class that provides operator()
 Ccaf::composed_type< Xs, Ys, Zs, Rs >Computes the type for f*g (actor composition)
 Ccaf::config_optionHelper class to generate config readers for different input types
 Ccaf::config_option::type_name_visitorReturns a human-readable type name for the visited type
 Ccaf::containerbuf< Container >A streambuffer abstraction over a contiguous container
 Ccaf::continue_helperHelper class to enable users to add continuations when dealing with synchronous sends
 Ccaf::data_processor< Derived >A data processor translates an object into a format that can be stored or vice versa
 Ccaf::delegated< Ts >Helper class to indicate that a request has been forwarded
 Ccaf::down_msgSent to all actors monitoring an actor when it is terminated
 Ccaf::durationTime duration consisting of a time_unit and a 64 bit unsigned integer
 Ccaf::errorA serializable type for storing error codes with category and optional, human-readable context information
 Ccaf::event_based_actorA cooperatively scheduled, event-based actor implementation
 Ccaf::execution_unitIdentifies an execution unit, e.g., a worker thread of the scheduler
 Ccaf::exit_msgSent to all links when an actor is terminated
 Ccaf::expected< T >Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error
 Ccaf::expected< void >The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool
 Ccaf::extend< Base, Derived >Allows convenient definition of types using mixins
 Ccaf::function_view< Actor >A function view for an actor hides any messaging from the caller
 Ccaf::group_down_msgSent to all members of a group when it goes offline
 Ccaf::group_moduleInterface for user-defined multicast implementations
 Ccaf::handle< Subtype, InvalidType, InvalidId >Base class for IO handles such as accept_handle or connection_handle
 Ccaf::has_make_error< T >Evaluates to true if T is an enum with a free function make_error for converting it to an error
 Ccaf::illegal_message_elementMarker class identifying classes in CAF that are not allowed to be used as message element
 Ccaf::index_mappingMarker for representing placeholders at runtime
 Ccaf::infer_handle_from_class< T, bool >Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced
 Ccaf::infer_handle_from_fun< F, Trait >Deduces an actor handle type from a function or function object
 Ccaf::infinite_tRepresents an infinite amount of timeout for specifying "invalid" timeouts
 Ccaf::intrusive_ptr< T >An intrusive, reference counting smart pointer implementation
 Ccaf::io::acceptor_closed_msgSignalizes that a broker acceptor has been closed
 Ccaf::io::acceptor_passivated_msgSignalizes that an acceptor has entered passive mode
 Ccaf::io::broker_servant< Base, Handle, SysMsgType >Base class for scribe and doorman
 Ccaf::io::connection_closed_msgSignalizes that a broker connection has been closed
 Ccaf::io::connection_passivated_msgSignalizes that a connection has entered passive mode
 Ccaf::io::data_transferred_msgSignalizes that a certain amount of bytes has been written
 Ccaf::io::hookInterface to define hooks into the IO layer
 Ccaf::io::network::asio_acceptor< SocketAcceptor >An acceptor is responsible for accepting incoming connections
 Ccaf::io::network::asio_stream< Socket >A stream capable of both reading and writing
 Ccaf::io::network::event_handlerA socket I/O event handler
 Ccaf::io::network::interfacesUtility class bundling access to network interface names and addresses
 Ccaf::io::network::multiplexer::supervisorMakes sure the multipler does not exit its event loop until the destructor of supervisor has been called
 Ccaf::io::new_connection_msgSignalizes a newly accepted connection from a broker
 Ccaf::io::new_data_msgSignalizes newly arrived data for a broker
 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::is_typed_actor< T >Evaluates to true if T is a typed_actor<...>
 Ccaf::mailbox_element_vals< Ts >Encapsulates arbitrary data in a message element
 Ccaf::mailbox_element_view< Ts >Provides a view for treating arbitrary data as message element
 Ccaf::memory_managedThis 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::messageDescribes a fixed-length, copy-on-write, type-erased tuple with elements of any type
 Ccaf::message::cli_argStores the name of a command line option ("<long name>[,<short name>]") along with a description and a callback
 Ccaf::message::cli_resStores the result of message::extract_opts
 Ccaf::message_builderProvides a convenient interface for createing message objects from a series of values using the member function append
 Ccaf::message_handlerA partial function implementation used to process a message
 Ccaf::message_idDenotes whether a message is asynchronous or synchronous
 Ccaf::message_viewRepresents an object pointing to a type_erased_tuple that is convertible to a message
 Ccaf::meta::annotationType tag for all meta annotations in CAF
 Ccaf::mixin::behavior_changer< Base, Subtype >A behavior_changer is an actor that supports self->become(...) and self->unbecome()
 Ccaf::mixin::requester< Base, Subtype >A requester is an actor that supports `self->request(...)
 Ccaf::mixin::sender< Base, Subtype >A sender is an actor that supports self->send(...)
 Ccaf::mixin::subscriber_baseMarker for subscriber
 Ccaf::named_actor_configStores a flow-control configuration
 Ccaf::node_idA node ID consists of a host ID and process ID
 Ccaf::none_tRepresents "nothing", e.g., for clearing an optional by assigning none
 Ccaf::optional< T >A C++17 compatible optional implementation
 Ccaf::optional< T & >Template specialization to allow optional to hold a reference rather than an actual value with minimal overhead
 Ccaf::param< T >Represents a message handler parameter of type T and guarantees copy-on-write semantics
 Ccaf::param_decay< T >Convenience struct for remove_param<std::decay<T>>
 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_policyThis concept class describes a policy for worker and coordinator of the scheduler
 Ccaf::policy::scheduler_policy::coordinator_dataPolicy-specific data fields for the coordinator
 Ccaf::policy::scheduler_policy::worker_dataPolicy-specific data fields for the worker
 Ccaf::policy::unprofiledThis class is intended to be used as a base class for actual polices
 Ccaf::proxy_registryGroups a (distributed) set of actors and allows actors in the same namespace to exchange messages
 Ccaf::proxy_registry::backendResponsible for creating proxy actors
 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::remove_param< T >Unpacks param<T> to T
 Ccaf::response_handle< Self, Output, IsBlocking >This helper class identifies an expected response message and enables request(...).then(...)
 Ccaf::response_promiseA response promise can be used to deliver a uniquely identifiable response message from the server (i.e
 Ccaf::response_type< Ts, Xs >Defines:
 Ccaf::response_type_unbox< Ts, Xs >Unboxes Xs and calls response_type
 Ccaf::resumableA cooperatively executed task managed by one or more instances of execution_unit
 Ccaf::scheduler::test_coordinator::delayed_msgA scheduled message or timeout
 Ccaf::scoped_actorA scoped handle to a blocking actor
 Ccaf::select_callback< F, Args >Utility class for selecting a callback_impl
 Ccaf::spawn_optionsStores options passed to the spawn function family
 Ccaf::stateful_actor< State, Base >An event-based actor with managed state
 Ccaf::timeout_msgSignalizes a timeout event
 Ccaf::type_erased_tupleRepresents a tuple of type-erased values
 Ccaf::type_erased_valueRepresents a single type-erased value
 Ccaf::type_nr< T, IsIntegral >Computes the type number for T
 Ccaf::typed_actor< Sigs >Identifies a statically typed actor
 Ccaf::typed_behavior< Sigs >::unsafe_initEmpty struct tag for constructing from an untyped behavior
 Ccaf::typed_event_based_actor< Sigs >A cooperatively scheduled, event-based actor implementation with static type-checking
 Ccaf::typed_response_promise< Ts >A response promise can be used to deliver a uniquely identifiable response message from the server (i.e
 Ccaf::unbox_message_element< T, IsPlaceholderRes >Unboxes atom constants, i.e., converts atom_constant<V> to V
 Ccaf::unit_tUnit is analogous to void, but can be safely returned, stored, etc
 Ccaf::unsafe_actor_handle_init_tTag type to select the unsafe constructor of actor handles
 Ccaf::variant< Ts >A variant represents always a valid value of one of the types Ts...
 Ccaf::variant_compare_helper< T >
 Ccaf::variant_reader< T >
 Ccaf::variant_writer< T >
 Ccaf::weak_intrusive_ptr< T >An intrusive, reference counting smart pointer implementation
 Ccaf::callback< Ts... >
 Ccaf::composable_behavior_base< Clauses >
 Ccaf::composed_type< detail::type_list< typed_mpi< In, Out >, Xs... >, Ys, detail::type_list< Zs... >, Rs >
 Ccaf::composed_type< detail::type_list< Xs... >, Ys, Ys, detail::type_list< Rs..., typed_mpi< detail::type_list< In... >, output_stream< MapsTo... > > > >
 Ccaf::composed_type< detail::type_list< Xs... >, Ys, Ys, detail::type_list< Rs..., typed_mpi< detail::type_list< In... >, output_tuple< MapsTo... > > > >
 Ccaf::composed_type< detail::type_list< Xs... >, Ys, Ys, Rs >
 Ccaf::data_processor< deserializer >
 Ccaf::data_processor< serializer >
 Ccaf::handle< accept_handle, invalid_accept_handle_t >
 Ccaf::handle< connection_handle, invalid_connection_handle_t >
 Ccaf::intrusive_ptr< abstract_group >
 Ccaf::intrusive_ptr< actor_control_block >
 Ccaf::intrusive_ptr< caf::caf::logger >
 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::mailbox_element_vals< SysMsgType >
 Ccaf::optional< caf::response_promise >
 Ccaf::optional< size_t >
 Ccaf::response_type< detail::type_list< Ts... >, Xs... >
 Ccaf::response_type< Ts, message >
 Ccaf::response_type< Ts, Xs... >
 Ccaf::stateful_actor< basp_broker_state, broker >
 Ccaf::typed_actor< Ts... >
 Ccaf::weak_intrusive_ptr< actor_control_block >