Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

▼Ncaf	Root namespace of libcaf
►Nio	Contains all IO-related classes and functions
►Nbasp	Contains all classes and functions for the Binary Actor Sytem Protocol
Cheader	The header of a Binary Actor System Protocol (BASP) message
►Cinstance	Describes a protocol instance managing multiple connections
Ccallee	Provides a callback-based interface for certain BASP events
►Crouting_table	Stores routing information for a single broker participating as BASP peer and provides both direct and indirect paths
Croute	Describes a routing path to a node
►Nnetwork	Contains classes and functions used for network abstraction
Cacceptor	An acceptor is responsible for accepting incoming connections
Cacceptor_manager	An acceptor manager configures an acceptor and provides callbacks for incoming connections as well as for error handling
Casio_multiplexer	A wrapper for the boost::asio multiplexer
Cdefault_socket	Low-level socket type used as default
Cevent_handler	A socket IO event handler
Cinterfaces	Utility class bundling access to network interface names and addresses
Cmanager	A manager configures an IO device and provides callbacks for various IO operations
►Cmultiplexer	Low-level backend for IO multiplexing
Crunnable	Simple wrapper for runnables
Csupervisor	Makes sure the multipler does not exit its event loop until the destructor of supervisor has been called
Cstream	A stream capable of both reading and writing
Cstream_manager	A stream manager configures an IO stream and provides callbacks for incoming data as well as for error handling
Cabstract_broker	A broker mediates between actor systems and other components in the network
Caccept_handle	Generic handle type for managing incoming connections
Cacceptor_closed_msg	Signalizes that a broker acceptor has been closed
Cbasp_broker	A broker implementation for the Binary Actor System Protocol (BASP)
Cbroker	Describes a dynamically typed broker
Cbroker_servant	Base class for scribe and doorman
Cconnection_closed_msg	Signalizes that a broker connection has been closed
Cconnection_handle	Generic handle type for identifying connections
Cdoorman	Manages incoming connections
Chook	Interface to define hooks into the IO layer
Cmiddleman	Manages brokers and network backends
Cnew_connection_msg	Signalizes a newly accepted connection from a broker
Cnew_data_msg	Signalizes newly arrived data for a broker
Cscribe	Manages a stream
►Npolicy	Contains policies encapsulating characteristics or algorithms
Cprofiled	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
►Cscheduler_policy	This concept class describes a policy for worker and coordinator of the scheduler
Ccoordinator_data	Policy-specific data fields for the coordinator
Cworker_data	Policy-specific data fields for the worker
Cwork_sharing
Cwork_stealing	Implements scheduling of actors via work stealing
Cabstract_actor	Base class for all actor implementations
Cabstract_channel	Interface for all message receivers
Cabstract_event_based_actor	Base type for statically and dynamically typed event-based actors
►Cabstract_group	A multicast group
Cmodule	Interface for user-defined multicast implementations
Cabstract_uniform_type_info	Implements all pure virtual functions of uniform_type_info except serialize() and deserialize()
Cactor	Identifies an untyped actor
Cactor_addr	Stores the address of typed as well as untyped actors
Cactor_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
Cactor_exited	Thrown if an actor finished execution
►Cactor_namespace	Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages
Cbackend	The backend of an actor namespace is responsible for creating proxy actors
Cproxy_entry	Ensures that kill_proxy is called for each proxy instance
Cactor_ostream	Provides support for thread-safe output operations on character streams
Cactor_pool	An actor poool is a lightweight abstraction for a set of workers
►Cactor_proxy	Represents an actor running on a remote machine, or different hardware, or in a separate process
Canchor	An anchor points to a proxy instance without sharing ownership to it, i.e., models a weak ptr
Cadvanced_match_case_impl
Canything	Acts as wildcard expression in patterns
Catom_constant	Lifts an atom_value to a compile-time constant
►Cattachable	Callback utility class
Ctoken	Represents a pointer to a value with its subtype as type ID number
Cbehavior	Describes the behavior of an actor, i.e., provides a message handler and an optional timeout
Cbinary_deserializer	Implements the deserializer interface with a binary serialization protocol
Cbinary_serializer	Implements the serializer interface with a binary serialization protocol
Cbind_failure	Thrown to indicate that an actor publishing failed because the requested port could not be used
Cblocking_actor	A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing
Cblocking_response_handle_tag	This tag identifies response handles featuring a blocking API by providing an await member function
Ccaf_exception	Base class for exceptions
Ccallback	Describes a simple callback, usually implemented via lambda expression
Ccallback_impl	Utility class for wrapping a function object of type Base
Cchannel	A handle to instances of abstract_channel
Ccontinue_helper	Helper class to enable users to add continuations when dealing with synchronous sends
Cdelegated	Helper class to indicate that a request has been forwarded
Cdeserializer	Technology-independent deserialization interface
Cdown_msg	Sent to all actors monitoring an actor when it is terminated
Cduration	Time duration consisting of a time_unit and a 64 bit unsigned integer
Cevent_based_actor	A cooperatively scheduled, event-based actor implementation
Cexecution_unit	Identifies an execution unit, e.g., a worker thread of the scheduler
Cexit_msg	Sent to all links when an actor is terminated
Cextend	Allows convenient definition of types using mixins
Cforwarding_actor_proxy	Implements a simple proxy forwarding all operations to a manager
Cgroup_down_msg	Sent to all members of a group when it goes offline
Chandle	Base class for IO handles such as accept_handle or connection_handle
Cillegal_message_element	Marker class identifying classes in CAF that are not allowed to be used as message element
Cintrusive_ptr	An intrusive, reference counting smart pointer impelementation
Cinvalid_node_id_t	Objects of this type identify an invalid node_id
Cis_anything
Cis_same_ish	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
Clocal_actor	Base class for actors running on this node, either living in an own thread or cooperatively scheduled
Cmaybe	Represents a computation returning either T or std::error_condition
Cmemory_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
►Cmessage	Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type
Ccli_arg	Stores the name of a command line option ("<long name>[,<short name>]") along with a description and a callback
Ccli_res	Stores the result of message::extract_opts
Cmessage_builder	Provides a convenient interface for createing message objects from a series of values using the member function append
Cmessage_handler	A partial function implementation used to process a message
Cmessage_id	Denotes whether a message is asynchronous or synchronous
Cnetwork_error	Thrown to indicate that either an actor publishing failed or the middleman was unable to connect to a remote host
Cnode_id	A node ID consists of a host ID and process ID
Cnonblocking_response_handle_tag	This tag identifies response handles featuring a nonblocking API by providing a then member function
Cratio_to_time_unit_helper	Converts the ratio Num/Denom to a time_unit if the ratio describes seconds, milliseconds, microseconds, or minutes
Cref_counted	Base class for reference counted objects with an atomic reference count
Cresponse_handle	This helper class identifies an expected response message and enables sync_send(...).then(...)
Cresponse_promise	A response promise can be used to deliver a uniquely identifiable response message from the server (i.e
Cresumable	A cooperatively executed task managed by one or more instances of execution_unit
Cscoped_actor	A scoped handle to a blocking actor
Cselect_callback	Utility class for selecting a callback_impl
Cserializer	Technology-independent serialization interface
Cskip_message_t	Optional return type for functors used in pattern matching expressions
Cspawn_options	Stores options passed to the spawn function family
Cstateful_actor	An event-based actor with managed state
Csync_exited_msg	Sent whenever a terminated actor receives a synchronous request
Csync_timeout_msg	Sent whenever a timeout occurs during a synchronous send
Ctimeout_msg	Signalizes a timeout event
Ctyped_actor	Identifies a statically typed actor
Ctyped_event_based_actor	A cooperatively scheduled, event-based actor implementation with strong type checking
Cunbox_message_element	Unboxes atom constants, i.e., converts atom_constant<V> to V
Cuniform_type_info	Provides a platform independent type name and a (very primitive) kind of reflection in combination with uniform_value
Cuniform_value_t	Generic container for storing a value with associated type information
Cvariant	A variant represents always a valid value of one of the types Ts...