actor-framework
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
caf Namespace Reference

Root namespace of libcaf. More...

Namespaces

 exit_reason
 Contains all predefined exit reasons.
 
 io
 Contains all IO-related classes and functions.
 
 mixin
 Contains mixin classes implementing several actor traits.
 
 net
 Contains all classes and functions related to network protocols.
 
 policy
 Contains policies encapsulating characteristics or algorithms.
 
 telemetry
 Contains classes and functions for collecting telemetry data.
 

Classes

class  abstract_actor
 Base class for all actor implementations. More...
 
class  abstract_blocking_actor
 A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing. More...
 
class  abstract_mailbox
 The base class for all mailbox implementations. More...
 
class  abstract_scheduled_actor
 A cooperatively scheduled, event-based actor implementation. More...
 
class  action
 A functional interface similar to std::function<void()> with dispose semantics. More...
 
class  actor
 Identifies an untyped actor. More...
 
class  actor_addr
 Stores the address of typed as well as untyped actors. More...
 
class  actor_cast_access
 
class  actor_cast_access< actor_control_block *, From, raw_ptr_cast >
 
class  actor_cast_access< To *, From, raw_ptr_cast >
 
class  actor_cast_access< To, From, neutral_cast >
 
class  actor_cast_access< To, From, raw_ptr_cast >
 
class  actor_cast_access< To, From, weak_ptr_downgrade_cast >
 
class  actor_cast_access< To, From, weak_ptr_upgrade_cast >
 
class  actor_clock
 A monotonic clock for scheduling timeouts and delayed messages. More...
 
class  actor_companion
 An 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. More...
 
class  actor_config
 Stores spawn-time settings and flags. More...
 
class  actor_control_block
 Actors are always allocated with a control block that stores its identity as well as strong and weak reference counts to it. More...
 
class  actor_from_state_t
 Helper class for automating the creation of an event-based actor with managed state. More...
 
class  actor_ostream
 Provides support for thread-safe output operations on character streams. More...
 
class  actor_pool
 An actor poool is a lightweight abstraction for a set of workers. More...
 
class  actor_proxy
 Represents an actor running on a remote machine, or different hardware, or in a separate process. More...
 
class  actor_registry
 A registry is used to associate actors to IDs or names. More...
 
class  actor_storage
 
class  actor_system
 Actor environment including scheduler, registry, and optional components such as a middleman. More...
 
class  actor_system_config
 Configures an actor_system on startup. More...
 
class  actor_system_module
 An (optional) component of the actor system. More...
 
struct  actor_traits
 Provides uniform access to properties of actor types. More...
 
struct  actor_traits< typed_actor_view< Sigs... > >
 
struct  allowed_unsafe_message_type
 Template specializations can whitelist individual types for unsafe message passing operations. More...
 
class  anon_mail_t
 Provides a fluent interface for sending anonymous messages to actors. More...
 
class  anon_scheduled_mail_t
 Provides a fluent interface for sending anonymous messages to actors at a specific point in time. More...
 
class  async_mail_base_t
 Provides a fluent interface for sending asynchronous messages to actors. More...
 
class  async_mail_t
 Provides a fluent interface for sending asynchronous messages to actors. More...
 
class  async_scheduled_mail_t
 Provides a fluent interface for sending asynchronous messages to actors at a specific point in time. More...
 
class  attachable
 Callback utility class. More...
 
class  basic_cow_string
 A copy-on-write string implementation that wraps a std::basic_string. More...
 
class  behavior
 Describes the behavior of an actor, i.e., provides a message handler and an optional timeout. More...
 
class  binary_deserializer
 Deserializes C++ objects from sequence of bytes. More...
 
class  binary_serializer
 Serializes C++ objects into a sequence of bytes. More...
 
class  blocking_actor
 A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing. More...
 
struct  blocking_actor_base
 Marker type for blocking actors. More...
 
class  blocking_delayed_response_handle
 Similar to blocking_response_handle, but also holds the disposable for the delayed request message. More...
 
class  blocking_delayed_response_handle< message >
 
class  blocking_mail_t
 Provides a fluent interface for sending asynchronous messages to actors. More...
 
class  blocking_response_handle
 This helper class identifies an expected response message and enables request(...).then(...). More...
 
class  blocking_response_handle< message >
 This helper class identifies an expected response message and enables request(...).then(...). More...
 
struct  blocking_response_handle_state
 Holds state for a blocking response handles. More...
 
class  blocking_scheduled_mail_t
 Provides a fluent interface for sending asynchronous messages to actors at a specific point in time. More...
 
class  byte_address
 Base type for addresses based on a byte representation such as IP or Ethernet addresses. More...
 
class  callback
 Describes a simple callback, usually implemented via lambda expression. More...
 
class  callback< Result(Ts...)>
 
class  callback_impl
 Utility class for wrapping a function object of type F. More...
 
class  callback_impl< F, Result(Ts...)>
 
struct  catch_all
 
class  chunk
 An implicitly shared type for binary data. More...
 
class  chunked_string
 Represents a chunked string as a linked list of string views. More...
 
class  chunked_string_builder
 Builds a chunked string by allocating each chunk on a monotonic buffer. More...
 
class  chunked_string_builder_output_iterator
 An output iterator that appends characters to a linked string chunk builder. More...
 
class  config_option
 Defines a configuration option for the application. More...
 
class  config_option_adder
 Adds config options of the same category to a config_option_set. More...
 
class  config_option_set
 A set of config_option objects that parses CLI arguments into a settings object. More...
 
class  config_value
 A type for config parameters with similar interface to a variant. More...
 
class  config_value_reader
 Extracts objects from a config_value. More...
 
class  config_value_writer
 Serializes an objects into a config_value. More...
 
class  const_typed_message_view
 
class  cow_tuple
 A copy-on-write tuple implementation. More...
 
class  cow_vector
 A copy-on-write vector implementation that wraps a std::vector. More...
 
struct  deep_to_string_t
 Wraps deep_to_string into a function object. More...
 
struct  default_actor_traits
 Default implementation of actor_traits for non-actors (SFINAE-friendly). More...
 
struct  default_actor_traits< T, true >
 Default implementation of actor_traits for regular actors. More...
 
class  default_attachable
 
class  default_type_id_mapper
 Dispatches to query_type_name and query_type_id. More...
 
class  delegated
 Helper class to indicate that a request has been forwarded. More...
 
class  deserializer
 Technology-independent deserialization interface. More...
 
class  dictionary
 Maps strings to values of type V, but unlike std::map<std::string, V> accepts std::string_view for looking up keys efficiently. More...
 
class  disposable
 Represents a disposable resource. More...
 
struct  down_msg
 Sent to all actors monitoring an actor when it is terminated. More...
 
struct  dyn_spawn_class_helper
 
struct  dynamically_typed
 Tag type to indicate that the sender of a message is a dynamically typed actor. More...
 
struct  dynamically_typed_actor_base
 Marker type for dynamically typed actors. More...
 
class  error
 A serializable type for storing error codes with category and optional, human-readable context information. More...
 
class  error_code
 A lightweight wrapper around an error code enum. More...
 
class  event_based_actor
 A cooperatively scheduled, event-based actor implementation. More...
 
class  event_based_delayed_response_handle
 Similar to event_based_response_handle, but also holds the disposable for the delayed request message. More...
 
class  event_based_delayed_response_handle< message >
 
class  event_based_mail_t
 Provides a fluent interface for sending asynchronous messages to actors. More...
 
class  event_based_mtl
 Enables event-based actors to generate messages from a user-defined data exchange format such as JSON and to send the generated messages to another (typed) actor. More...
 
class  event_based_response_handle
 This helper class identifies an expected response message and enables request(...).then(...). More...
 
class  event_based_response_handle< message >
 This helper class identifies an expected response message and enables request(...).then(...). More...
 
struct  event_based_response_handle_state
 Holds state for a event-based response handles. More...
 
class  event_based_scheduled_mail_t
 Provides a fluent interface for sending asynchronous messages to actors at a specific point in time. More...
 
struct  exec_main_helper
 
struct  exec_main_helper< type_list< System & > >
 
struct  exec_main_helper< type_list< System &, const Config & > >
 
struct  exit_msg
 Sent to all links when an actor is terminated. More...
 
class  expected
 Represents the result of a computation which can either complete successfully with an instance of type T or fail with an error. More...
 
class  expected< void >
 The pattern expected<void> shall be used for functions that may generate an error but would otherwise return bool. More...
 
struct  extend
 Allows convenient definition of types using mixins. More...
 
struct  format_string_with_location
 Wraps a format string and its source location. More...
 
class  forwarding_actor_proxy
 Implements a simple proxy forwarding all operations to a manager. More...
 
class  fun_decorator
 
class  fun_decorator< F, T, Bhvr, spawn_mode::function, R, type_list< Ts... > >
 
class  fun_decorator< F, T, Bhvr, spawn_mode::function_with_selfptr, R, type_list< T *, Ts... > >
 
class  function_view
 A function view for an actor hides any messaging from the caller. More...
 
struct  function_view_flattened_result
 
struct  function_view_flattened_result< std::tuple< T > >
 
struct  function_view_result
 
struct  function_view_result< typed_actor< Ts... > >
 
class  function_view_storage
 
class  function_view_storage< message >
 
class  function_view_storage< std::tuple< Ts... > >
 
struct  function_view_storage_catch_all
 
struct  get_or_auto_deduce
 Configures get_or to uses the get_or_deduction_guide. More...
 
struct  get_or_deduction_guide
 Customization point for configuring automatic mappings from default value types to deduced types. More...
 
struct  get_or_deduction_guide< const char * >
 
struct  get_or_deduction_guide< span< T > >
 
struct  get_or_deduction_guide< std::string_view >
 
class  handle
 Base class for IO handles such as accept_handle or connection_handle. More...
 
class  hashed_node_id
 
struct  ignore_case_t
 Tag type for selecting case-insensitive algorithms. More...
 
struct  illegal_message_element
 Marker class identifying classes in CAF that are not allowed to be used as message element. More...
 
struct  infer_handle_from_behavior
 
struct  infer_handle_from_behavior< typed_behavior< Sigs... > >
 
struct  infer_handle_from_class
 Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced. More...
 
struct  infer_handle_from_class< T, false >
 
struct  infer_handle_from_fun_impl
 
struct  infer_handle_from_fun_impl< behavior, Impl *, true >
 
struct  infer_handle_from_fun_impl< typed_behavior< Sigs... >, Impl *, true >
 
struct  infer_handle_from_fun_impl< typed_behavior< Sigs... >, Impl, false >
 
struct  infer_handle_from_fun_impl< void, Impl *, true >
 
struct  infer_handle_from_fun_trait
 Deduces an actor handle type from a function or function object. More...
 
class  input_range
 
class  input_range_impl
 
struct  inspector_access
 Customization point for adding support for a custom type. More...
 
struct  inspector_access< config_value >
 
struct  inspector_access< cow_tuple< Ts... > >
 
struct  inspector_access< shape_ptr >
 
struct  inspector_access< std::byte >
 
struct  inspector_access< std::chrono::duration< Rep, Period > >
 
struct  inspector_access< std::chrono::time_point< std::chrono::system_clock, Duration > >
 
struct  inspector_access< std::optional< T > >
 
struct  inspector_access< std::unique_ptr< error::data > >
 
struct  inspector_access< std::variant< Ts... > >
 
struct  inspector_access< uri >
 
struct  inspector_access_base
 Provides default implementations for save_field and load_field. More...
 
struct  inspector_access_type
 Wraps tag types for static dispatching. More...
 
class  intrusive_cow_ptr
 An intrusive, reference counting smart pointer implementation with copy-on-write optimization. More...
 
class  intrusive_ptr
 An intrusive, reference counting smart pointer implementation. More...
 
struct  intrusive_ptr_access
 Policy for adding and releasing references in an intrusive_ptr. More...
 
class  ipv4_address
 
class  ipv4_endpoint
 An IP endpoint that contains an ::ipv4_address and a port. More...
 
class  ipv4_subnet
 
class  ipv6_address
 
class  ipv6_endpoint
 An IP endpoint that contains an ::ipv6_address and a port. More...
 
class  ipv6_subnet
 
struct  is_actor_handle
 Checks whether T is an actor or a typed_actor<...>. More...
 
struct  is_actor_handle< actor >
 
struct  is_actor_handle< typed_actor< Ts... > >
 
struct  is_allowed_unsafe_message_type
 
struct  is_allowed_unsafe_message_type< const T & >
 
struct  is_allowed_unsafe_message_type< T & >
 
struct  is_allowed_unsafe_message_type< T && >
 
struct  is_catch_all
 
struct  is_catch_all< catch_all< T > >
 
struct  is_error_code_enum
 Customization point for enabling conversion from an enum type to an error or error_code. More...
 
struct  is_handle
 
struct  is_handle< actor >
 
struct  is_handle< strong_actor_ptr >
 
struct  is_handle< typed_actor< Ts... > >
 
struct  is_illegal_message_element
 
struct  is_result
 
struct  is_result< result< Ts... > >
 
struct  is_timeout_definition
 
struct  is_timeout_definition< timeout_definition< T > >
 
struct  is_timeout_or_catch_all
 
struct  is_timeout_or_catch_all< catch_all< T > >
 
struct  is_timeout_or_catch_all< timeout_definition< T > >
 
struct  is_typed_actor
 Evaluates to true if T is a typed_actor<...>. More...
 
struct  is_typed_actor< typed_actor< Ts... > >
 
struct  is_typed_behavior
 
struct  is_typed_behavior< typed_behavior< Sigs... > >
 
struct  is_typed_behavior< typed_behavior< T > >
 
struct  is_variant_wrapper
 Customization point. More...
 
struct  is_variant_wrapper< config_value >
 
struct  is_variant_wrapper< result< Ts... > >
 
struct  is_variant_wrapper< skippable_result >
 
class  json_array
 Represents a JSON array. More...
 
class  json_builder
 Serializes an inspectable object to a json_value. More...
 
class  json_object
 Represents a JSON object. More...
 
class  json_reader
 Deserializes an inspectable object from a JSON-formatted string. More...
 
class  json_value
 Represents an immutable JSON value. More...
 
class  json_writer
 Serializes an inspectable object to a JSON-formatted string. More...
 
struct  keep_behavior_t
 
struct  lift_void
 
struct  lift_void< void >
 
class  load_inspector
 Base type for inspectors that load objects from some input source. More...
 
class  load_inspector_base
 
class  local_actor
 Base class for actors running on this node, either living in an own thread or cooperatively scheduled. More...
 
class  logger
 Centrally logs events from all actors in an actor system. More...
 
class  mail_cache
 A simple cache for storing mailbox elements for an actor for later reuse. More...
 
class  mailbox_element
 
struct  may_have_timeout
 
struct  may_have_timeout< behavior >
 
struct  may_have_timeout< timeout_definition< F > >
 
class  message
 Describes a fixed-length, copy-on-write, type-erased tuple with elements of any type. More...
 
class  message_builder
 Provides a convenient interface for creating message objects from a series of values using the member function append. More...
 
class  message_handler
 A partial function implementation used to process a message. More...
 
class  message_id
 Bundles various flags along with an optional request ID. More...
 
struct  message_verifier
 
struct  message_verifier< spawn_mode::function, type_list< Ts... > >
 
struct  message_verifier< spawn_mode::function_with_selfptr, type_list< Self *, Ts... > >
 
struct  node_down_msg
 Sent to all actors monitoring a node when CAF loses connection to it. More...
 
class  node_id
 A node ID is an opaque value for representing CAF instances in the network. More...
 
class  node_id_data
 
struct  non_blocking_actor_base
 Marker type for non-blocking actors. More...
 
struct  none_t
 Represents "nothing", e.g., for clearing an optional by assigning none. More...
 
struct  once_t
 Tag type to indicate that an operation should take place only once. More...
 
struct  optional_inspector_access
 Provides inspector access for types that represent optional values. More...
 
struct  optional_inspector_traits
 
struct  optional_inspector_traits< intrusive_cow_ptr< T > >
 
struct  optional_inspector_traits< intrusive_ptr< T > >
 
struct  optional_inspector_traits< std::optional< T > >
 
struct  optional_inspector_traits< std::shared_ptr< T > >
 
struct  optional_inspector_traits< std::unique_ptr< T > >
 
struct  optional_inspector_traits_base
 
struct  others_t
 
struct  parser_state
 Stores all information necessary for implementing an FSM-based parser. More...
 
struct  partial_behavior_init_t
 Tag type for constructing a typed_behavior with an incomplete list of message handlers, delegating to the default handler for all unmatched inputs. More...
 
struct  prohibit_top_level_spawn_marker
 
class  proxy_registry
 Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages. More...
 
class  ref_counted
 Base class for reference counted objects with an atomic reference count. More...
 
struct  repeat_t
 Tag type to indicate that an operation should be repeated. More...
 
class  response_handle
 This helper class identifies an expected response message and enables request(...).then(...). More...
 
class  response_promise
 Enables actors to delay a response message by capturing the context of a request message. More...
 
struct  response_type
 Defines: More...
 
struct  response_type< none_t, Xs... >
 
struct  response_type< type_list< result< Out... >(In...), Fs... >, In... >
 
struct  response_type< type_list< result< Out... >(In...), Fs... >, Xs... >
 
struct  response_type< type_list<>, Xs... >
 
struct  response_type_unbox
 Unboxes Xs and calls response_type. More...
 
struct  response_type_unbox< Ts, message >
 
struct  response_type_unbox< Ts, type_list< Xs... > >
 
class  result
 Wraps the result of a message handler to represent either a value (wrapped into a message), a delegated<Ts...> (indicates that another actor is going to respond), or an error. More...
 
class  result< message >
 
class  result< T >
 
class  result< T0, T1, Ts... >
 
class  result< unit_t >
 
class  result< void >
 
class  result_base
 Base type for all specializations of result. More...
 
class  resumable
 A cooperatively scheduled entity. More...
 
class  save_inspector
 Base type for inspectors that save objects to some output sink. More...
 
class  save_inspector_base
 
class  scheduled_actor
 A cooperatively scheduled, event-based actor implementation. More...
 
class  scheduler
 A coordinator creates the workers, manages delayed sends and the central printer instance for aout. More...
 
class  scoped_actor
 A scoped handle to a blocking actor. More...
 
class  serializer
 Technology-independent serialization interface. More...
 
class  skip_t
 
class  skippable_result
 Similar to result<message>, but also allows to skip a message. More...
 
class  span
 A C++11/14 drop-in replacement for C++20's std::span without support for static extents. More...
 
class  stateful_actor
 An event-based actor with managed state. More...
 
struct  statically_typed
 A statically typed trait type wrapping the given parameter pack of signatures as a type list. More...
 
struct  statically_typed_actor_base
 Marker type for statically typed actors. More...
 
class  stream
 Provides access to a potentially unbound sequence of items emitted by an actor. More...
 
struct  stream_abort_msg
 Informs the sink that a stream has been aborted due to an unrecoverable error. More...
 
struct  stream_ack_msg
 Informs the sink that the source has added it to the flow. More...
 
struct  stream_batch_msg
 Transfers items from a source to a sink. More...
 
struct  stream_cancel_msg
 Informs the source that the sender is no longer interest in receiving items from this stream. More...
 
struct  stream_close_msg
 Informs the sink that a stream has reached the end. More...
 
struct  stream_demand_msg
 Asks the source for more data. More...
 
struct  stream_open_msg
 Asks a source to add another sink. More...
 
struct  strong_ref_t
 Tag type to indicate that the system should keep a strong reference to an actor. More...
 
struct  strong_self_ref_t
 Tag type to indicate that the system should keep a strong reference to an actor after passing it the self pointer. More...
 
class  thread_hook
 Interface to define thread hooks. More...
 
struct  timeout_definition
 
class  timeout_definition_builder
 
struct  timeout_msg
 Signals a timeout to an actor. More...
 
struct  type_by_id
 Maps the globally unique ID V to a type (inverse to ::type_id). More...
 
struct  type_id
 Maps the type T to a globally unique ID. More...
 
class  type_id_list
 A list of type IDs, stored in a size-prefix, contiguous memory block. More...
 
class  type_id_mapper
 Translates between human-readable type names and type IDs. More...
 
struct  type_list
 A list of types. More...
 
struct  type_name
 Convenience type that resolves to type_name_by_id<type_id_v<T>>. More...
 
struct  type_name< void >
 Convenience specialization that enables generic code to not treat void manually. More...
 
struct  type_name_by_id
 Maps the globally unique ID V to a type name. More...
 
class  typed_actor
 
class  typed_actor< T1, T2, Ts... >
 Identifies a statically typed actor. More...
 
class  typed_actor< TraitOrSignature >
 Identifies a statically typed actor. More...
 
class  typed_actor_pointer
 
class  typed_actor_pointer< T1, T2, Ts... >
 Provides a view to an actor that implements this messaging interface without knowledge of the actual type. More...
 
class  typed_actor_pointer< TraitOrSignature >
 Provides a view to an actor that implements this messaging interface without knowledge of the actual type. More...
 
class  typed_actor_view
 
class  typed_actor_view< T1, T2, Ts... >
 Decorates a pointer to a scheduled_actor with a statically typed actor interface. More...
 
class  typed_actor_view< TraitOrSignature >
 Decorates a pointer to a scheduled_actor with a statically typed actor interface. More...
 
struct  typed_actor_view_base
 Tag type for typed_actor_view. More...
 
class  typed_behavior
 
class  typed_behavior< T1, T2, Ts... >
 
class  typed_behavior< TraitOrSignature >
 
class  typed_event_based_actor
 
class  typed_event_based_actor< T1, T2, Ts... >
 A cooperatively scheduled, event-based actor implementation with static type-checking. More...
 
class  typed_event_based_actor< TraitOrSignature >
 A cooperatively scheduled, event-based actor implementation with static type-checking. More...
 
class  typed_message_view
 
class  typed_response_promise
 Enables statically typed actors to delay a response message by capturing the context of a request message. More...
 
class  typed_stream
 Provides access to a statically typed, potentially unbound sequence of items emitted by an actor. More...
 
struct  unit_t
 Unit is analogous to void, but can be safely returned, stored, etc. More...
 
struct  unlift_void
 
struct  unlift_void< unit_t >
 
class  unordered_flat_map
 A map abstraction with an unsorted std::vector providing O(n) lookup. More...
 
struct  unsafe_behavior_init_t
 Empty struct tag for constructing a typed behavior from an untyped behavior. More...
 
class  uri
 A URI according to RFC 3986. More...
 
class  uri_builder
 
class  uuid
 A universally unique identifier according to RFC 4122. More...
 
struct  variant_inspector_access
 
struct  variant_inspector_traits
 
struct  variant_inspector_traits< config_value >
 
struct  variant_inspector_traits< shape_ptr >
 
struct  variant_inspector_traits< std::variant< Ts... > >
 
class  weak_intrusive_ptr
 An intrusive, reference counting smart pointer implementation. More...
 
struct  weak_ref_t
 Tag type to indicate that the system should keep a weak reference to an actor. More...
 
struct  weak_self_ref_t
 Tag type to indicate that the system should keep a weak reference to an actor after passing it the self pointer. More...
 

Typedefs

using actor_factory_result = std::pair< strong_actor_ptr, std::set< std::string > >
 
using actor_factory = std::function< actor_factory_result(actor_system &, actor_config &, message &)>
 
using selfptr_mode_token = spawn_mode_token< spawn_mode::function_with_selfptr >
 
using void_mode_token = spawn_mode_token< spawn_mode::function >
 
using byte_buffer = std::vector< std::byte >
 A buffer for storing binary data.
 
using byte_span = span< std::byte >
 Convenience alias for referring to a writable sequence of bytes.
 
using const_byte_span = span< const std::byte >
 Convenience alias for referring to a read-only sequence of bytes.
 
template<class Signature >
using unique_callback_ptr = std::unique_ptr< callback< Signature > >
 Smart pointer type for heap-allocated callbacks with unique ownership.
 
template<class Signature >
using shared_callback_ptr = std::shared_ptr< callback< Signature > >
 Smart pointer type for heap-allocated callbacks with shared ownership.
 
template<class T >
using deduce_mpi_t = typename detail::dmfou< std::decay_t< T > >::type
 Deduces the message passing interface from a function object.
 
template<class T >
using function_view_storage_t = typename function_view_storage< T >::type
 Convenience alias for function_view_storage<T>::type.
 
template<class T >
using function_view_flattened_result_t = typename function_view_flattened_result< T >::type
 
using actor_id = uint64_t
 
using cow_string = basic_cow_string< char >
 
using cow_u16string = basic_cow_string< char16_t >
 
using cow_u32string = basic_cow_string< char32_t >
 
using ip_address = ipv6_address
 An IP address. The address family is IPv6 unless embeds_v4 returns true.
 
using ip_endpoint = ipv6_endpoint
 An IP endpoint that contains an ::ipv6_address and a port.
 
using ip_subnet = ipv6_subnet
 An IP subnetwork. More...
 
using settings = dictionary< config_value >
 
using type_id_t = uint16_t
 Internal representation of a type ID.
 
using weak_actor_ptr = weak_intrusive_ptr< actor_control_block >
 
using strong_actor_ptr = intrusive_ptr< actor_control_block >
 
using mailbox_element_ptr = std::unique_ptr< mailbox_element >
 
using shared_action_ptr = std::shared_ptr< callback< void()> >
 
template<spawn_mode X>
using spawn_mode_token = std::integral_constant< spawn_mode, X >
 
template<class T >
using infer_handle_from_behavior_t = typename infer_handle_from_behavior< T >::type
 Convenience alias for infer_handle_from_behavior<T>::type.
 
template<class Found , class Expected >
using interface_mismatch_t = detail::imi< 0, Found, Expected, type_list<> >
 Scans two typed MPI lists for compatibility, returning the index of the first mismatch. More...
 
using high_message_priority_constant = std::integral_constant< message_priority, message_priority::high >
 
using normal_message_priority_constant = std::integral_constant< message_priority, message_priority::normal >
 
using string_parser_state = parser_state< std::string_view::iterator >
 Specialization for parsers operating on string views.
 
template<class Fs , class... In>
using response_type_t = typename response_type< Fs, In... >::type
 Computes the response message type for input In... from the list of message passing interfaces Fs. More...
 
template<class Handle , class... In>
using delegated_response_type_t = typename response_type< typename Handle::signatures, In... >::delegated_type
 Computes the response message type for input In... from the list of message passing interfaces Fs and returns the corresponding delegated<T>. More...
 
template<class Ts , class Xs >
using response_type_unbox_t = typename response_type_unbox< Ts, Xs >::type
 Computes the response message for input Xs from the list of message passing interfaces Ts. More...
 
using generic_timeout_definition = timeout_definition< std::function< void()> >
 
using timespan = std::chrono::duration< int64_t, std::nano >
 A portable timespan type with nanosecond resolution.
 
using timestamp = std::chrono::time_point< std::chrono::system_clock, timespan >
 A portable timestamp with nanosecond resolution anchored at the UNIX epoch.
 

Enumerations

enum  exit_reason : uint8_t {
  exit_reason::normal = 0, exit_reason::unknown, exit_reason::out_of_workers, exit_reason::user_shutdown,
  exit_reason::kill, exit_reason::remote_link_unreachable, exit_reason::unreachable
}
 This error category represents fail conditions for actors. More...
 
enum  spawn_mode { function, function_with_selfptr, clazz }
 
enum  invoke_message_result { invoke_message_result::consumed, invoke_message_result::skipped, invoke_message_result::dropped }
 Stores the result of a message invocation. More...
 
enum  message_priority { high = 0, normal = 1 }
 
enum  pec : uint8_t {
  pec::success = 0, pec::trailing_character = 1, pec::unexpected_eof, pec::unexpected_character,
  pec::timespan_overflow, pec::fractional_timespan = 5, pec::too_many_characters, pec::invalid_escape_sequence,
  pec::unexpected_newline, pec::integer_overflow, pec::integer_underflow = 10, pec::exponent_underflow,
  pec::exponent_overflow, pec::type_mismatch, pec::not_an_option, pec::invalid_argument = 15,
  pec::missing_argument, pec::invalid_category, pec::invalid_field_name, pec::repeated_field_name,
  pec::missing_field = 20, pec::invalid_range_expression, pec::invalid_state, pec::nested_too_deeply
}
 PEC stands for "Parser Error Code". More...
 
enum  sec : uint8_t {
  sec::none = 0, sec::unexpected_message = 1, sec::unexpected_response, sec::request_receiver_down,
  sec::request_timeout, sec::no_such_group_module = 5, sec::no_actor_published_at_port, sec::unexpected_actor_messaging_interface,
  sec::state_not_serializable, sec::unsupported_sys_key, sec::unsupported_sys_message = 10, sec::disconnect_during_handshake,
  sec::cannot_forward_to_invalid_actor, sec::no_route_to_receiving_node, sec::failed_to_assign_scribe_from_handle, sec::failed_to_assign_doorman_from_handle = 15,
  sec::cannot_close_invalid_port, sec::cannot_connect_to_node, sec::cannot_open_port, sec::network_syscall_failed,
  sec::invalid_argument = 20, sec::invalid_protocol_family, sec::cannot_publish_invalid_actor, sec::cannot_spawn_actor_from_arguments,
  sec::end_of_stream, sec::no_context = 25, sec::unknown_type, sec::no_proxy_registry,
  sec::runtime_error, sec::remote_linking_failed, sec::invalid_stream = 30, sec::cannot_resubscribe_stream,
  sec::stream_aborted, sec::bad_function_call = 40, sec::feature_disabled, sec::cannot_open_file,
  sec::socket_invalid, sec::socket_disconnected, sec::socket_operation_failed = 45, sec::unavailable_or_would_block,
  sec::incompatible_versions, sec::incompatible_application_ids, sec::malformed_message, sec::serializing_basp_payload_failed = 50,
  sec::redundant_connection, sec::remote_lookup_failed, sec::no_tracing_context, sec::all_requests_failed,
  sec::field_invariant_check_failed = 55, sec::field_value_synchronization_failed, sec::invalid_field_type, sec::unsafe_type,
  sec::save_callback_failed, sec::load_callback_failed = 60, sec::conversion_failed, sec::connection_closed,
  sec::type_clash, sec::unsupported_operation, sec::no_such_key = 65, sec::broken_promise,
  sec::connection_timeout, sec::action_reschedule_failed, sec::invalid_observable, sec::too_many_observers = 70,
  sec::disposed, sec::cannot_open_resource, sec::protocol_error, sec::logic_error,
  sec::invalid_delegate = 75, sec::invalid_request, sec::future_timeout, sec::invalid_utf8,
  sec::backpressure_overflow
}
 SEC stands for "System Error Code". More...
 
enum  spawn_options : int {
  no_flags = 0x00, link_flag = 0x01, monitor_flag = 0x02, detach_flag = 0x04,
  hide_flag = 0x08, priority_aware_flag = 0x20, lazy_init_flag = 0x40
}
 Stores options passed to the spawn function family.
 
enum  term {
  term::reset, term::reset_endl, term::black, term::red,
  term::green, term::yellow, term::blue, term::magenta,
  term::cyan, term::white, term::bold_black, term::bold_red,
  term::bold_green, term::bold_yellow, term::bold_blue, term::bold_magenta,
  term::bold_cyan, term::bold_white
}
 Terminal color and font face options. More...
 
enum  thread_owner { thread_owner::scheduler, thread_owner::pool, thread_owner::system, thread_owner::other }
 Denotes the component that launched a CAF thread. More...
 

Functions

CAF_CORE_EXPORT void intrusive_ptr_release (actor_control_block *)
 
bool operator== (const action &lhs, const action &rhs) noexcept
 Checks whether two actions are equal by comparing their pointers.
 
bool operator!= (const action &lhs, const action &rhs) noexcept
 Checks whether two actions are not equal by comparing their pointers.
 
template<class F >
action make_action (F f)
 Convenience function for creating an action from a function object. More...
 
template<class F >
action make_single_shot_action (F f)
 Convenience function for creating an action from a function object. More...
 
bool operator== (const actor &lhs, abstract_actor *rhs)
 
bool operator== (abstract_actor *lhs, const actor &rhs)
 
bool operator!= (const actor &lhs, abstract_actor *rhs)
 
bool operator!= (abstract_actor *lhs, const actor &rhs)
 
bool operator== (const actor_addr &x, std::nullptr_t)
 
bool operator== (std::nullptr_t, const actor_addr &x)
 
bool operator!= (const actor_addr &x, std::nullptr_t)
 
bool operator!= (std::nullptr_t, const actor_addr &x)
 
template<class T , class U >
actor_cast (U &&what)
 Converts the actor handle what to a different actor handle or raw pointer of type T. More...
 
template<class U , class Tag >
auto actor_cast (U &&what, Tag)
 Converts the actor handle what to a different actor handle or raw pointer of type Tag::handle_type. More...
 
std::string to_string (const actor_config &x)
 
bool intrusive_ptr_upgrade_weak (actor_control_block *x)
 
void intrusive_ptr_release_weak (actor_control_block *x)
 
bool operator== (const strong_actor_ptr &x, const abstract_actor *y)
 
bool operator== (const abstract_actor *x, const strong_actor_ptr &y)
 
error_code< secload_actor (strong_actor_ptr &storage, actor_system *sys, actor_id aid, const node_id &nid)
 
error_code< secsave_actor (strong_actor_ptr &storage, actor_id aid, const node_id &nid)
 
std::string to_string (const strong_actor_ptr &x)
 
void append_to_string (std::string &x, const strong_actor_ptr &y)
 
std::string to_string (const weak_actor_ptr &x)
 
void append_to_string (std::string &x, const weak_actor_ptr &y)
 
bool operator!= (const strong_actor_ptr &x, const abstract_actor *y)
 
bool operator!= (const abstract_actor *x, const strong_actor_ptr &y)
 
template<class Inspector >
auto context_of (Inspector *f) -> decltype(f->context())
 
auto context_of (void *)
 
template<class Inspector >
bool inspect (Inspector &f, strong_actor_ptr &x)
 
template<class Inspector >
bool inspect (Inspector &f, weak_actor_ptr &x)
 
template<class F >
actor_factory make_actor_factory (F fun)
 
template<class T , class... Ts>
actor_factory_result dyn_spawn_class (actor_system &sys, actor_config &cfg, message &msg)
 
template<class T , class... Ts>
actor_factory make_actor_factory ()
 
actor_ostream aout (local_actor *self)
 Convenience factory function for creating an actor output stream.
 
actor_ostream aout (scoped_actor &self)
 
template<class... Sigs>
actor_ostream aout (const typed_actor_pointer< Sigs... > &ptr)
 Convenience factory function for creating an actor output stream.
 
const settingscontent (const actor_system_config &cfg)
 Returns all user-provided configuration parameters.
 
template<class Rep , class Period >
constexpr auto after (std::chrono::duration< Rep, Period > d)
 Returns a generator for timeouts.
 
template<class... Args>
auto anon_mail (Args &&... args)
 Entry point for sending an anonymous message to an actor.
 
template<class Trait , class... Args>
auto async_mail (Trait, local_actor *self, Args &&... args)
 Entry point for sending an asynchronous message to an actor.
 
template<class Trait , class... Args>
auto blocking_mail (Trait, abstract_blocking_actor *self, Args &&... args)
 Entry point for sending an event-based message to an actor.
 
template<size_t I, class Result >
decltype(auto) get (caf::blocking_delayed_response_handle< Result > &x)
 
template<size_t I, class Result >
decltype(auto) get (const caf::blocking_delayed_response_handle< Result > &x)
 
template<size_t I, class Result >
decltype(auto) get (caf::blocking_delayed_response_handle< Result > &&x)
 
bool is_valid_utf8 (const_byte_span) noexcept
 Checks whether the byte span is a valid UTF-8 string.
 
std::string_view to_string_view (const_byte_span) noexcept
 Reinterprets the underlying data as a string view.
 
std::string to_string (const chunked_string &str)
 Converts a linked string chunk to a std::string.
 
std::ostream & operator<< (std::ostream &out, const chunked_string &str)
 Prints a chunked string to an output stream.
 
bool operator< (double x, const config_value &y)
 
bool operator<= (double x, const config_value &y)
 
bool operator== (double x, const config_value &y)
 
bool operator> (double x, const config_value &y)
 
bool operator>= (double x, const config_value &y)
 
bool operator< (const config_value &x, double y)
 
bool operator<= (const config_value &x, double y)
 
bool operator== (const config_value &x, double y)
 
bool operator> (const config_value &x, double y)
 
bool operator>= (const config_value &x, double y)
 
bool operator< (const config_value &x, const config_value &y)
 
bool operator<= (const config_value &x, const config_value &y)
 
bool operator== (const config_value &x, const config_value &y)
 
bool operator> (const config_value &x, const config_value &y)
 
bool operator>= (const config_value &x, const config_value &y)
 
std::string to_string (const config_value &x)
 
std::string to_string (const settings &xs)
 
std::ostream & operator<< (std::ostream &out, const config_value &x)
 
template<class T >
expected< T > get_as (const config_value &, inspector_access_type::none)
 
template<class T >
expected< T > get_as (const config_value &, inspector_access_type::unsafe)
 
template<class T >
expected< T > get_as (const config_value &x, inspector_access_type::specialization token)
 
template<class T >
expected< T > get_as (const config_value &x, inspector_access_type::inspect token)
 
template<class T >
expected< T > get_as (const config_value &x, inspector_access_type::builtin_inspect token)
 
template<class T >
expected< T > get_as (const config_value &x, inspector_access_type::builtin)
 
template<class T >
expected< T > get_as (const config_value &x, inspector_access_type::empty)
 
template<class T , size_t... Is>
expected< T > get_as_tuple (const config_value::list &x, std::index_sequence< Is... >)
 
template<class T >
expected< T > get_as (const config_value &x, inspector_access_type::tuple)
 
template<class T >
expected< T > get_as (const config_value &x, inspector_access_type::map)
 
template<class T >
expected< T > get_as (const config_value &x, inspector_access_type::list)
 
template<class... Ts>
config_value make_config_value_list (Ts &&... xs)
 
template<size_t Index, class... Ts>
const auto & get (const_typed_message_view< Ts... > xs)
 
template<class... Ts, size_t... Is>
auto to_tuple (const_typed_message_view< Ts... > xs, std::index_sequence< Is... >)
 
template<class... Ts>
auto to_tuple (const_typed_message_view< Ts... > xs)
 
template<class... Ts>
auto make_const_typed_message_view (const message &msg)
 
template<class... Ts>
std::optional< std::tuple< Ts... > > to_tuple (const message &msg)
 
template<class T >
auto operator== (const cow_vector< T > &xs, const cow_vector< T > &ys) -> decltype(xs.std()==ys.std())
 
template<class T >
auto operator== (const cow_vector< T > &xs, const std::vector< T > &ys) -> decltype(xs.std()==ys)
 
template<class T >
auto operator== (const std::vector< T > &xs, const cow_vector< T > &ys) -> decltype(xs==ys.std())
 
template<class T >
auto operator!= (const cow_vector< T > &xs, const cow_vector< T > &ys) -> decltype(xs.std() !=ys.std())
 
template<class T >
auto operator!= (const cow_vector< T > &xs, const std::vector< T > &ys) -> decltype(xs.std() !=ys)
 
template<class T >
auto operator!= (const std::vector< T > &xs, const cow_vector< T > &ys) -> decltype(xs !=ys.std())
 
template<class T >
std::string deep_to_string (const T &x)
 Unrolls collections such as vectors/maps, decomposes tuples/pairs/arrays, auto-escapes strings and calls to_string for user-defined types via argument-dependent loopkup (ADL). More...
 
template<class... Ts>
std::string deep_to_string_as_tuple (const Ts &... xs)
 Convenience function for deep_to_string(std::forward_as_tuple(xs...)).
 
template<class Inspector , class Enumeration >
bool default_enum_inspect (Inspector &f, Enumeration &x)
 Convenience function for providing a default inspection scaffold for custom enumeration types. More...
 
template<class... Ts>
bool operator== (const delegated< Ts... > &, const delegated< Ts... > &)
 
template<class T >
bool operator== (const dictionary< T > &xs, const dictionary< T > &ys)
 
template<class T >
bool operator!= (const dictionary< T > &xs, const dictionary< T > &ys)
 
template<class T >
bool operator< (const dictionary< T > &xs, const dictionary< T > &ys)
 
template<class T >
bool operator<= (const dictionary< T > &xs, const dictionary< T > &ys)
 
template<class T >
bool operator> (const dictionary< T > &xs, const dictionary< T > &ys)
 
template<class T >
bool operator>= (const dictionary< T > &xs, const dictionary< T > &ys)
 
std::string to_string (const error &x)
 
template<class Enum >
auto to_string (error_code< Enum > x) -> decltype(to_string(x.value()))
 Converts x to a string if Enum provides a to_string function.
 
template<class Trait , class... Args>
auto event_based_mail (Trait, abstract_scheduled_actor *self, Args &&... args)
 Entry point for sending an event-based message to an actor.
 
template<size_t I, class... Results>
decltype(auto) get (caf::event_based_delayed_response_handle< Results... > &x)
 
template<size_t I, class... Results>
decltype(auto) get (const caf::event_based_delayed_response_handle< Results... > &x)
 
template<size_t I, class... Results>
decltype(auto) get (caf::event_based_delayed_response_handle< Results... > &&x)
 
template<class T >
void exec_main_init_meta_objects_single ()
 
template<class... Ts>
void exec_main_init_meta_objects ()
 
template<class T >
void exec_main_load_module (actor_system_config &cfg)
 
template<class... Ts, class F = void (*)(actor_system&)>
int exec_main (F fun, int argc, char **argv)
 
template<class Inspector >
bool inspect (Inspector &f, exit_reason &x)
 
template<class T >
std::string to_string (const expected< T > &x)
 
std::string to_string (const expected< void > &x)
 
template<class Enum , class... Args>
std::enable_if_t< is_error_code_enum_v< Enum >, errorformat_to_error (Enum code, std::string_view fstr, Args &&... args)
 Formats the given arguments into a string and returns an error with the specified code and the formatted string as message. More...
 
template<class T >
config_option make_config_option (std::string_view category, std::string_view name, std::string_view description)
 Creates a config option that synchronizes with storage.
 
template<class T >
config_option make_config_option (T &storage, std::string_view category, std::string_view name, std::string_view description)
 Creates a config option that synchronizes with storage.
 
template<class ProjectIds , uint16_t... Is>
void init_global_meta_objects_impl (std::integer_sequence< uint16_t, Is... >)
 
template<class ProjectIds >
void init_global_meta_objects ()
 Initializes the global meta object table with all types in ProjectIds. More...
 
template<class T >
std::string to_string (const intrusive_ptr< T > &x)
 
CAF_CORE_EXPORT std::string to_string (invoke_message_result)
 
ipv4_address make_ipv4_address (uint8_t oct1, uint8_t oct2, uint8_t oct3, uint8_t oct4)
 
std::string to_string (const ipv4_address &x)
 
error parse (std::string_view str, ipv4_address &dest)
 
std::string to_string (const ipv4_endpoint &ep)
 
std::string to_string (ipv4_subnet x)
 
std::string to_string (ipv6_address x)
 
error parse (std::string_view str, ipv6_address &dest)
 
std::string to_string (const ipv6_endpoint &x)
 
std::string to_string (ipv6_subnet x)
 
std::string to_string (const json_array &arr)
 
bool operator== (const json_array::const_iterator &lhs, const json_array::const_iterator &rhs) noexcept
 
bool operator!= (const json_array::const_iterator &lhs, const json_array::const_iterator &rhs) noexcept
 
bool operator== (const json_array &lhs, const json_array &rhs) noexcept
 
bool operator!= (const json_array &lhs, const json_array &rhs) noexcept
 
std::string to_string (const json_object &obj)
 
bool operator== (const json_object::const_iterator &lhs, const json_object::const_iterator &rhs) noexcept
 
bool operator!= (const json_object::const_iterator &lhs, const json_object::const_iterator &rhs) noexcept
 
bool operator== (const json_object &lhs, const json_object &rhs) noexcept
 
bool operator!= (const json_object &lhs, const json_object &rhs) noexcept
 
std::string to_string (const json_value &val)
 
bool operator== (const json_value &lhs, const json_value &rhs)
 
bool operator!= (const json_value &lhs, const json_value &rhs)
 
std::string_view as_json_type_name (json_writer::type t)
 
mailbox_element_ptr make_mailbox_element (strong_actor_ptr sender, message_id id, message payload)
 
template<class T , class R = infer_handle_from_class_t<T>, class... Ts>
make_actor (actor_id aid, node_id nid, actor_system *sys, Ts &&... xs)
 
config_option make_negated_config_option (bool &storage, std::string_view category, std::string_view name, std::string_view description)
 
std::string to_string (const message &msg)
 
template<class Inspector >
bool inspect (Inspector &f, message_id &x)
 
CAF_CORE_EXPORT std::string to_string (message_priority)
 
template<class Self , class Adapter , class Reader >
auto make_mtl (Self *self, Adapter adapter, Reader *reader)
 Creates an MTL (message translation layer) to enable an actor to exchange messages with non-CAF endpoints over a user-defined data exchange format such as JSON. More...
 
void append_to_string (std::string &str, const node_id &x)
 
std::string to_string (const node_id &x)
 
node_id make_node_id (uri from)
 
node_id make_node_id (uint32_t process_id, const hashed_node_id::host_id_type &host_id)
 
std::optional< node_idmake_node_id (uint32_t process_id, std::string_view host_hash)
 
error parse (std::string_view str, node_id &dest)
 
error parser_state_to_error (pec code, int32_t line, int32_t column)
 Converts the code and the current position of a parser to an error.
 
template<class... Ts>
auto make_result (Ts &&... xs)
 Convenience function for wrapping the parameter pack xs... into a result. More...
 
template<class T >
std::enable_if_t< std::is_same_v< T *, resumable * > > intrusive_ptr_add_ref (const T *ptr)
 
template<class T >
std::enable_if_t< std::is_same_v< T *, resumable * > > intrusive_ptr_release (const T *ptr)
 
skippable_result reflect (scheduled_actor *, message &msg)
 
skippable_result reflect_and_quit (scheduled_actor *ptr, message &msg)
 
skippable_result print_and_drop (scheduled_actor *ptr, message &msg)
 
skippable_result drop (scheduled_actor *, message &)
 
std::string to_string (const scoped_actor &x)
 
template<message_priority Priority = message_priority::normal, class Handle , class T , class... Ts>
void anon_send (const Handle &receiver, T &&arg, Ts &&... args)
 Sends an asynchronous, anonymous message to receiver.
 
template<message_priority Priority = message_priority::normal, class Handle , class T , class... Ts>
disposable delayed_anon_send (const Handle &receiver, actor_clock::duration_type timeout, T &&arg, Ts &&... args)
 Sends an asynchronous, anonymous message to receiver after the timeout.
 
template<message_priority Priority = message_priority::normal, class Handle , class T , class... Ts>
disposable scheduled_anon_send (const Handle &receiver, actor_clock::time_point timeout, T &&arg, Ts &&... args)
 Sends an asynchronous, anonymous message to receiver after the timeout.
 
template<message_priority Priority = message_priority::normal, class Handle >
void anon_send_exit (const Handle &receiver, exit_reason reason)
 Anonymously sends dest an exit message.
 
template<message_priority Priority = message_priority::normal>
void anon_send_exit (const actor_addr &receiver, exit_reason reason)
 Anonymously sends to an exit message.
 
const config_valueget_if (const settings *xs, std::string_view name)
 
expected< std::string > get_or (const settings &xs, std::string_view name, const char *fallback)
 
config_valueput_impl (settings &dict, const std::vector< std::string_view > &path, config_value &value)
 
config_valueput_impl (settings &dict, std::string_view name, config_value &value)
 
config_value::list & put_list (settings &xs, std::string name)
 Inserts a new list named name into the dictionary xs and returns a reference to it. More...
 
config_value::dictionaryput_dictionary (settings &xs, std::string name)
 Inserts a new list named name into the dictionary xs and returns a reference to it. More...
 
template<class T >
auto get_or (const settings &xs, defaults::parameter< T > param)
 Convenience overload for calling get_or(xs, param.name, param.fallback).
 
template<class T >
config_valueput (settings &xs, std::string_view key, T &&value)
 Converts value to a config_value and assigns it to key. More...
 
template<class T >
void put_missing (settings &xs, std::string_view key, T &&value)
 Converts value to a config_value and assigns it to key unless xs already contains key (does nothing in this case). More...
 
template<class T >
auto begin (const span< T > &xs) -> decltype(xs.begin())
 
template<class T >
auto cbegin (const span< T > &xs) -> decltype(xs.cbegin())
 
template<class T >
auto end (const span< T > &xs) -> decltype(xs.end())
 
template<class T >
auto cend (const span< T > &xs) -> decltype(xs.cend())
 
template<class T >
span< const std::byte > as_bytes (span< T > xs)
 
template<class T >
span< std::byte > as_writable_bytes (span< T > xs)
 
template<class T >
auto make_span (T &xs) -> span< std::remove_reference_t< decltype(xs[0])>>
 Convenience function to make using caf::span more convenient without the deduction guides. More...
 
template<class T , size_t N>
span< T > make_span (T(&xs)[N])
 Convenience function to make using caf::span more convenient without the deduction guides. More...
 
template<class T >
span< T > make_span (T *first, size_t size)
 Convenience function to make using caf::span more convenient without the deduction guides. More...
 
template<class T >
span< T > make_span (T *first, T *last)
 Convenience function to make using caf::span more convenient without the deduction guides. More...
 
constexpr spawn_options operator+ (spawn_options x, spawn_options y)
 Concatenates two spawn_options.
 
constexpr bool has_spawn_option (spawn_options haystack, spawn_options needle)
 Checks whether haystack contains needle.
 
constexpr bool has_detach_flag (spawn_options opts)
 Checks whether the detached flag is set in opts.
 
constexpr bool has_priority_aware_flag (spawn_options)
 Checks whether the priority_aware flag is set in opts.
 
constexpr bool has_hide_flag (spawn_options opts)
 Checks whether the hidden flag is set in opts.
 
constexpr bool has_link_flag (spawn_options opts)
 Checks whether the linked flag is set in opts.
 
constexpr bool has_monitor_flag (spawn_options opts)
 Checks whether the monitored flag is set in opts.
 
constexpr bool has_lazy_init_flag (spawn_options opts)
 Checks whether the lazy_init flag is set in opts.
 
void split (std::vector< std::string > &result, std::string_view str, std::string_view delims, bool keep_all)
 
void split (std::vector< std::string_view > &result, std::string_view str, std::string_view delims, bool keep_all)
 
void split (std::vector< std::string > &result, std::string_view str, char delim, bool keep_all)
 
void split (std::vector< std::string_view > &result, std::string_view str, char delim, bool keep_all)
 
std::string_view trim (std::string_view str)
 Drops any leading and trailing whitespaces from str.
 
bool icase_equal (std::string_view x, std::string_view y)
 Checks whether two strings are equal when ignoring upper/lower case.
 
std::pair< std::string_view, std::string_view > split_by (std::string_view str, std::string_view sep)
 Splits a string by a separator into a head and a tail. More...
 
void replace_all (std::string &str, std::string_view what, std::string_view with)
 Replaces all occurrences of what by with in str.
 
bool starts_with (std::string_view str, std::string_view prefix)
 Returns whether str begins with prefix.
 
bool ends_with (std::string_view str, std::string_view suffix)
 Returns whether str ends with suffix.
 
constexpr std::string_view is_any_of (std::string_view arg) noexcept
 
constexpr std::string_view make_string_view (const char *first, const char *last)
 
template<class InputIterator >
std::string join (InputIterator first, InputIterator last, std::string_view glue)
 
template<class Container >
std::string join (const Container &c, std::string_view glue)
 
std::ostream & operator<< (std::ostream &out, term x)
 
constexpr bool is_infinite (timespan value)
 Checks whether value represents an infinite amount of time.
 
timestamp make_timestamp ()
 Convenience function for returning a timestamp representing the current system time. More...
 
std::string timestamp_to_string (timestamp x)
 Prints x in ISO 8601 format, e.g., 2018-11-15T06:25:01.462.
 
expected< timestamptimestamp_from_string (std::string_view str)
 Converts an ISO 8601 formatted timestamp into its native representation.
 
void append_timestamp_to_string (std::string &x, timestamp y)
 Appends the timestamp x in ISO 8601 format, e.g., 2018-11-15T06:25:01.462, to y. More...
 
std::string_view query_type_name (type_id_t type)
 Returns the type name for type or an empty string if type is an invalid ID. More...
 
type_id_t query_type_id (std::string_view name)
 Returns the type for name or invalid_type_id if name is unknown.
 
template<class T >
std::string_view type_name_or_anonymous ()
 Returns type_name_v<T> if available, "anonymous" otherwise.
 
template<class T >
type_id_t type_id_or_invalid ()
 Returns type_id_v<T> if available, invalid_type_id otherwise.
 
std::string to_string (type_id_list xs)
 
type_id_list types_of (const message &msg)
 
template<class... Ts>
type_id_list types_of (const std::tuple< Ts... > &)
 
template<class T >
auto typed_actor_view_flow_access (caf::scheduled_actor *self)
 Utility function to force the type of self to depend on T and to raise a compiler error if the user did not include 'caf/scheduled_actor/flow.hpp'. More...
 
template<class... Fs>
typed_behavior< deduce_mpi_t< Fs >... > make_typed_behavior (Fs... fs)
 Creates a typed behavior from given function objects.
 
template<size_t Index, class... Ts>
auto & get (typed_message_view< Ts... > x)
 
template<class... Ts>
auto make_typed_message_view (message &msg)
 
std::string to_string (const uri &x)
 
std::string to_string (const uri::authority_type &x)
 
error parse (std::string_view str, uri &dest)
 
expected< urimake_uri (std::string_view str)
 
template<class Inspector >
bool inspect (Inspector &f, uri::authority_type &x)
 
template<class Inspector >
bool inspect (Inspector &f, uri::impl_type &x)
 
error parse (std::string_view str, uuid &dest)
 
std::string to_string (const uuid &x)
 
expected< uuidmake_uuid (std::string_view str)
 
template<class... Ts>
bool operator== (const message &x, const std::tuple< Ts... > &y)
 
template<class T >
bool operator== (const message &x, const T &y)
 

Variables

constexpr actor_id invalid_actor_id = 0
 Denotes an ID that is never used by an actor.
 
template<class State >
constexpr auto actor_from_state = actor_from_state_t<State>{}
 A function object that automates the creation of an event-based actor with managed state. More...
 
template<class T >
constexpr bool is_allowed_unsafe_message_type_v = allowed_unsafe_message_type<T>::value
 
template<class >
class nodiscard error_code
 
class nodiscard error
 
template<class T >
constexpr bool is_handle_v = is_handle<T>::value
 Convenience alias for is_handle<T>::value.
 
template<class T >
constexpr bool is_typed_actor_v = is_typed_actor<T>::value
 Convenience alias for is_typed_actor<T>::value.
 
template<class T >
constexpr bool may_have_timeout_v = may_have_timeout<T>::value
 
constexpr once_t once = {}
 Tag to indicate that an operation should take place only once.
 
constexpr others_t others = others_t{}
 
constexpr strong_ref_t strong_ref = {}
 Tag to indicate that the system should keep a weak reference to an actor.
 
constexpr weak_ref_t weak_ref = {}
 Tag to indicate that the system should keep a weak reference to an actor.
 
template<class T >
constexpr bool is_ref_tag = detail::is_ref_tag_oracle<T>::value
 Evaluates to true if T is either strong_ref_t or weak_ref_t.
 
constexpr repeat_t repeat = {}
 Tag to indicate that an operation should be repeated.
 
constexpr strong_self_ref_t strong_self_ref = {}
 Tag to indicate that the system should keep a strong reference to an actor after passing it the self pointer. More...
 
constexpr weak_self_ref_t weak_self_ref = {}
 Tag to indicate that the system should keep a weak reference to an actor after passing it the self pointer. More...
 
template<class T >
constexpr bool is_self_ref_tag = detail::is_self_ref_tag_oracle<T>::value
 Evaluates to true if T is either strong_self_ref_t or weak_self_ref_t. More...
 
constexpr skip_t skip = skip_t{}
 Tells the runtime system to skip a message when used as message handler, i.e., causes the runtime to leave the message in the mailbox of an actor. More...
 
constexpr spawn_options no_spawn_options = spawn_options::no_flags
 Denotes default settings.
 
constexpr spawn_options monitored = spawn_options::monitor_flag
 Causes spawn to call `self->monitor(...) immediately after the new actor was spawned. More...
 
constexpr spawn_options linked = spawn_options::link_flag
 Causes spawn to call `self->link_to(...) immediately after the new actor was spawned. More...
 
constexpr spawn_options detached = spawn_options::detach_flag
 Causes the new actor to opt out of the cooperative scheduling.
 
constexpr spawn_options hidden = spawn_options::hide_flag
 Causes the runtime to ignore the new actor in await_all_actors_done().
 
constexpr spawn_options lazy_init = spawn_options::lazy_init_flag
 Causes the new actor to delay its initialization until a message arrives. More...
 
constexpr ignore_case_t ignore_case = ignore_case_t{}
 Tag for selecting case-insensitive algorithms.
 
constexpr bool token_compress_on = false
 
constexpr type_id_t invalid_type_id = 65535
 Special value equal to the greatest possible value for type_id_t. More...
 
constexpr type_id_t first_custom_type_id = 200
 The first type ID not reserved by CAF and its modules.
 
template<class T >
constexpr bool has_type_id_v = detail::is_complete<type_id<T>>
 Checks whether type_id is specialized for T.
 
constexpr partial_behavior_init_t partial_behavior_init = partial_behavior_init_t{}
 
constexpr unsafe_behavior_init_t unsafe_behavior_init = unsafe_behavior_init_t{}
 Convenience constant for constructing a typed behavior from an untyped behavior. More...
 

Detailed Description

Root namespace of libcaf.

Typedef Documentation

◆ delegated_response_type_t

template<class Handle , class... In>
using caf::delegated_response_type_t = typedef typename response_type<typename Handle::signatures, In...>::delegated_type

Computes the response message type for input In... from the list of message passing interfaces Fs and returns the corresponding delegated<T>.

◆ interface_mismatch_t

template<class Found , class Expected >
using caf::interface_mismatch_t = typedef detail::imi<0, Found, Expected, type_list<> >

Scans two typed MPI lists for compatibility, returning the index of the first mismatch.

Returns the number of elements on a match.

Precondition
len(Found) == len(Expected)

◆ ip_subnet

An IP subnetwork.

The address family is IPv6 unless embeds_v4 returns true.

◆ response_type_t

template<class Fs , class... In>
using caf::response_type_t = typedef typename response_type<Fs, In...>::type

Computes the response message type for input In... from the list of message passing interfaces Fs.

◆ response_type_unbox_t

template<class Ts , class Xs >
using caf::response_type_unbox_t = typedef typename response_type_unbox<Ts, Xs>::type

Computes the response message for input Xs from the list of message passing interfaces Ts.

Enumeration Type Documentation

◆ exit_reason

enum caf::exit_reason : uint8_t
strong

This error category represents fail conditions for actors.

Enumerator
normal 

Indicates that an actor finished execution without error.

unknown 

Indicates that the exit reason for this actor is unknown, i.e., the actor has been terminated and no longer exists.

out_of_workers 

Indicates that an actor pool unexpectedly ran out of workers.

user_shutdown 

Indicates that an actor was forced to shutdown by a user-generated event.

kill 

Indicates that an actor was killed unconditionally.

remote_link_unreachable 

Indicates that an actor finished execution because a connection to a remote link was closed unexpectedly.

unreachable 

Indicates that an actor was killed because it became unreachable.

◆ invoke_message_result

Stores the result of a message invocation.

Enumerator
consumed 

Indicates that the actor consumed the message.

skipped 

Indicates that the actor left the message in the mailbox.

dropped 

Indicates that the actor discarded the message based on meta data.

For example, timeout messages for already received requests usually get dropped without calling any user-defined code.

◆ pec

enum caf::pec : uint8_t
strong

PEC stands for "Parser Error Code".

This enum contains error codes used by various CAF parsers.

Enumerator
success 

Not-an-error.

trailing_character 

Parser succeeded but found trailing character(s).

unexpected_eof 

Parser stopped after reaching the end while still expecting input.

unexpected_character 

Parser stopped after reading an unexpected character.

timespan_overflow 

Parsed integer exceeds the number of available bits of a timespan.

fractional_timespan 

Tried constructing a timespan with from a floating point number.

too_many_characters 

Too many characters for an atom.

invalid_escape_sequence 

Unrecognized character after escaping \.

unexpected_newline 

Misplaced newline, e.g., inside a string.

integer_overflow 

Parsed positive integer exceeds the number of available bits.

integer_underflow 

Parsed negative integer exceeds the number of available bits.

exponent_underflow 

Exponent of parsed double is less than the minimum supported exponent.

exponent_overflow 

Exponent of parsed double is greater than the maximum supported exponent.

type_mismatch 

Parsed type does not match the expected type.

not_an_option 

Stopped at an unrecognized option name.

invalid_argument 

Stopped at an unparsable argument.

missing_argument 

Stopped because an argument was omitted.

invalid_category 

Stopped because the key of a category was taken.

invalid_field_name 

Stopped at an unexpected field name while reading a user-defined type.

repeated_field_name 

Stopped at a repeated field name while reading a user-defined type.

missing_field 

Stopped while reading a user-defined type with one or more missing mandatory fields.

invalid_range_expression 

Parsing a range statement ('n..m' or 'n..m..step') failed.

invalid_state 

Stopped after running into an invalid parser state.

Should never happen and most likely indicates a bug in the implementation.

nested_too_deeply 

Parser stopped after exceeding its maximum supported level of nesting.

◆ sec

enum caf::sec : uint8_t
strong

SEC stands for "System Error Code".

This enum contains error codes for ::actor_system and its modules.

Enumerator
none 

No error.

unexpected_message 

Indicates that an actor dropped an unexpected message.

unexpected_response 

Indicates that a response message did not match the provided handler.

request_receiver_down 

Indicates that the receiver of a request is no longer alive.

request_timeout 

Indicates that a request message timed out.

no_such_group_module 

Indicates that requested group module does not exist.

no_actor_published_at_port 

Unpublishing or connecting failed: no actor bound to given port.

unexpected_actor_messaging_interface 

Connecting failed because a remote actor had an unexpected interface.

state_not_serializable 

Migration failed because the state of an actor is not serializable.

unsupported_sys_key 

An actor received an unsupported key for `('sys', 'get', key)` messages.

unsupported_sys_message 

An actor received an unsupported system message.

disconnect_during_handshake 

A remote node disconnected during CAF handshake.

cannot_forward_to_invalid_actor 

Tried to forward a message via BASP to an invalid actor handle.

no_route_to_receiving_node 

Tried to forward a message via BASP to an unknown node ID.

failed_to_assign_scribe_from_handle 

Middleman could not assign a connection handle to a broker.

failed_to_assign_doorman_from_handle 

Middleman could not assign an acceptor handle to a broker.

cannot_close_invalid_port 

User requested to close port 0 or to close a port not managed by CAF.

cannot_connect_to_node 

Middleman could not connect to a remote node.

cannot_open_port 

Middleman could not open requested port.

network_syscall_failed 

A C system call in the middleman failed.

invalid_argument 

A function received one or more invalid arguments.

invalid_protocol_family 

A network socket reported an invalid network protocol family.

cannot_publish_invalid_actor 

Middleman could not publish an actor because it was invalid.

cannot_spawn_actor_from_arguments 

A remote spawn failed because the provided types did not match.

end_of_stream 

Serialization failed because there was not enough data to read.

no_context 

Serialization failed because no CAF context is available.

unknown_type 

Serialization failed because CAF misses run-time type information.

no_proxy_registry 

Serialization of actors failed because no proxy registry is available.

runtime_error 

An exception was thrown during message handling.

remote_linking_failed 

Linking to a remote actor failed because actor no longer exists.

invalid_stream 

Subscribing to a stream failed because it was invalid.

cannot_resubscribe_stream 

Subscribing to a stream failed because it can only be subscribed to once.

stream_aborted 

A stream was aborted by the hosting actor, usually because it terminated.

bad_function_call 

A function view was called without assigning an actor first.

feature_disabled 

Feature is disabled in the actor system config.

cannot_open_file 

Failed to open file.

socket_invalid 

A socket descriptor argument is invalid.

socket_disconnected 

A socket became disconnected from the remote host (hang up).

socket_operation_failed 

An operation on a socket (e.g. poll) failed.

unavailable_or_would_block 

A resource is temporarily unavailable or would block.

incompatible_versions 

Connection refused because of incompatible CAF versions.

incompatible_application_ids 

Connection refused because of incompatible application IDs.

malformed_message 

Received a malformed message from another node.

serializing_basp_payload_failed 

The middleman closed a connection because it failed to serialize or deserialize a payload.

redundant_connection 

The middleman closed a connection to itself or an already connected node.

remote_lookup_failed 

Resolving a path on a remote node failed.

no_tracing_context 

Serialization failed because actor_system::tracing_context is null.

all_requests_failed 

No request produced a valid result.

field_invariant_check_failed 

Deserialization failed because an invariant got violated after reading the content of a field.

field_value_synchronization_failed 

Deserialization failed because a setter rejected the input.

invalid_field_type 

Deserialization failed because the source announced an invalid type.

unsafe_type 

Serialization failed because a type was flagged as unsafe message type.

save_callback_failed 

Serialization failed because a save callback returned false.

load_callback_failed 

Deserialization failed because a load callback returned false.

conversion_failed 

Converting between two types failed.

connection_closed 

A network connection was closed by the remote side.

type_clash 

An operation failed because run-time type information diverged from the expected type.

unsupported_operation 

An operation failed because the callee does not implement this functionality.

no_such_key 

A key lookup failed.

broken_promise 

An destroyed a response promise without calling deliver or delegate on it.

connection_timeout 

Disconnected from a BASP node after reaching the connection timeout.

action_reschedule_failed 

Signals that an actor fell behind a periodic action trigger.

After raising this error, an actor_clock stops scheduling the action.

invalid_observable 

Attaching to an observable failed because the target is invalid.

too_many_observers 

Attaching to an observable failed because the target already reached its maximum observer count.

disposed 

Signals that an operation failed because the target has been disposed.

cannot_open_resource 

Failed to open a resource.

protocol_error 

Received malformed data.

logic_error 

Encountered faulty logic in the program.

invalid_delegate 

An actor tried to delegate a message to an invalid actor handle.

invalid_request 

An actor tried to delegate a message to an invalid actor handle.

future_timeout 

Signals that future::get timed out.

invalid_utf8 

Received invalid UTF-8 encoding.

backpressure_overflow 

A downstream operator failed to process inputs on time.

◆ term

enum caf::term
strong

Terminal color and font face options.

Enumerator
reset 

Resets the color to the default color and the font weight to normal.

reset_endl 

Like reset but also prints a newline.

black 

Sets the terminal color to black.

red 

Sets the terminal color to red.

green 

Sets the terminal color to green.

yellow 

Sets the terminal color to yellow.

blue 

Sets the terminal color to blue.

magenta 

Sets the terminal color to magenta.

cyan 

Sets the terminal color to cyan.

white 

Sets the terminal color to white.

bold_black 

Sets the terminal color to black and the font weight to bold.

bold_red 

Sets the terminal color to red and the font weight to bold.

bold_green 

Sets the terminal color to green and the font weight to bold.

bold_yellow 

Sets the terminal color to yellow and the font weight to bold.

bold_blue 

Sets the terminal color to blue and the font weight to bold.

bold_magenta 

Sets the terminal color to magenta and the font weight to bold.

bold_cyan 

Sets the terminal color to cyan and the font weight to bold.

bold_white 

Sets the terminal color to white and the font weight to bold.

◆ thread_owner

enum caf::thread_owner
strong

Denotes the component that launched a CAF thread.

Enumerator
scheduler 

Indicates that the thread belongs to the cooperative scheduler.

pool 

Indicates that the thread belongs to the internal thread pool for detached and blocking actors.

system 

Indicates that the thread runs background activity such as logging for the actor system.

other 

Indicates that the thread has been launched by request of a user without using any of the default mechanisms above.

Function Documentation

◆ actor_cast() [1/2]

template<class T , class U >
T caf::actor_cast ( U &&  what)

Converts the actor handle what to a different actor handle or raw pointer of type T.

◆ actor_cast() [2/2]

template<class U , class Tag >
auto caf::actor_cast ( U &&  what,
Tag   
)

Converts the actor handle what to a different actor handle or raw pointer of type Tag::handle_type.

◆ append_timestamp_to_string()

CAF_CORE_EXPORT void caf::append_timestamp_to_string ( std::string &  x,
timestamp  y 
)

Appends the timestamp x in ISO 8601 format, e.g., 2018-11-15T06:25:01.462, to y.

◆ deep_to_string()

template<class T >
std::string caf::deep_to_string ( const T &  x)

Unrolls collections such as vectors/maps, decomposes tuples/pairs/arrays, auto-escapes strings and calls to_string for user-defined types via argument-dependent loopkup (ADL).

Any user-defined type that does not provide a to_string is mapped to <unprintable>.

◆ default_enum_inspect()

template<class Inspector , class Enumeration >
bool caf::default_enum_inspect ( Inspector &  f,
Enumeration &  x 
)

Convenience function for providing a default inspection scaffold for custom enumeration types.

The enumeration type must provide the following interface based on free functions:

{(cpp)}
enum class Enumeration : ... { ... };
std::string to_string(Enumeration);
bool from_string(string_view, Enumeration&);
bool from_integer(std::underlying_type_t<Enumeration>, Enumeration&);

◆ format_to_error()

template<class Enum , class... Args>
std::enable_if_t<is_error_code_enum_v<Enum>, error> caf::format_to_error ( Enum  code,
std::string_view  fstr,
Args &&...  args 
)

Formats the given arguments into a string and returns an error with the specified code and the formatted string as message.

◆ init_global_meta_objects()

template<class ProjectIds >
void caf::init_global_meta_objects ( )

Initializes the global meta object table with all types in ProjectIds.

Warning
calling this after constructing any ::actor_system is unsafe and causes undefined behavior.

◆ init_global_meta_objects_impl()

template<class ProjectIds , uint16_t... Is>
void caf::init_global_meta_objects_impl ( std::integer_sequence< uint16_t, Is... >  )
Warning
calling this after constructing any ::actor_system is unsafe and causes undefined behavior.

◆ make_action()

template<class F >
action caf::make_action ( f)

Convenience function for creating an action from a function object.

Parameters
fThe body for the action.

◆ make_mtl()

template<class Self , class Adapter , class Reader >
auto caf::make_mtl ( Self *  self,
Adapter  adapter,
Reader *  reader 
)

Creates an MTL (message translation layer) to enable an actor to exchange messages with non-CAF endpoints over a user-defined data exchange format such as JSON.

Parameters
selfPoints to an event-based or blocking actor.
adapterTranslates between internal and external message types.
readerPoints to an object that either implements the interface deserializer directly or that provides a compatible API.

◆ make_result()

template<class... Ts>
auto caf::make_result ( Ts &&...  xs)

Convenience function for wrapping the parameter pack xs... into a result.

◆ make_single_shot_action()

template<class F >
action caf::make_single_shot_action ( f)

Convenience function for creating an action from a function object.

Parameters
fThe body for the action.

◆ make_span() [1/4]

template<class T >
auto caf::make_span ( T &  xs) -> span<std::remove_reference_t<decltype(xs[0])>>

Convenience function to make using caf::span more convenient without the deduction guides.

◆ make_span() [2/4]

template<class T , size_t N>
span<T> caf::make_span ( T(&)  xs[N])

Convenience function to make using caf::span more convenient without the deduction guides.

◆ make_span() [3/4]

template<class T >
span<T> caf::make_span ( T *  first,
size_t  size 
)

Convenience function to make using caf::span more convenient without the deduction guides.

◆ make_span() [4/4]

template<class T >
span<T> caf::make_span ( T *  first,
T *  last 
)

Convenience function to make using caf::span more convenient without the deduction guides.

◆ make_timestamp()

CAF_CORE_EXPORT timestamp caf::make_timestamp ( )

Convenience function for returning a timestamp representing the current system time.

◆ put()

template<class T >
config_value& caf::put ( settings xs,
std::string_view  key,
T &&  value 
)

Converts value to a config_value and assigns it to key.

Parameters
xsDictionary of key-value pairs.
keyHuman-readable nested keys in the form category.key.
valueNew value for given key.

◆ put_dictionary()

CAF_CORE_EXPORT config_value::dictionary & caf::put_dictionary ( settings xs,
std::string  name 
)

Inserts a new list named name into the dictionary xs and returns a reference to it.

Overrides existing entries with the same name.

◆ put_list()

CAF_CORE_EXPORT config_value::list & caf::put_list ( settings xs,
std::string  name 
)

Inserts a new list named name into the dictionary xs and returns a reference to it.

Overrides existing entries with the same name.

◆ put_missing()

template<class T >
void caf::put_missing ( settings xs,
std::string_view  key,
T &&  value 
)

Converts value to a config_value and assigns it to key unless xs already contains key (does nothing in this case).

Parameters
xsDictionary of key-value pairs.
keyHuman-readable nested keys in the form category.key.
valueNew value for given key.

◆ query_type_name()

CAF_CORE_EXPORT std::string_view caf::query_type_name ( type_id_t  type)

Returns the type name for type or an empty string if type is an invalid ID.

◆ split_by()

CAF_CORE_EXPORT std::pair< std::string_view, std::string_view > caf::split_by ( std::string_view  str,
std::string_view  sep 
)

Splits a string by a separator into a head and a tail.

If sep was not found, the tail is empty.

◆ typed_actor_view_flow_access()

template<class T >
auto caf::typed_actor_view_flow_access ( caf::scheduled_actor self)

Utility function to force the type of self to depend on T and to raise a compiler error if the user did not include 'caf/scheduled_actor/flow.hpp'.

The function itself does nothing and simply returns self.

Variable Documentation

◆ actor_from_state

template<class State >
constexpr auto caf::actor_from_state = actor_from_state_t<State>{}
inline

A function object that automates the creation of an event-based actor with managed state.

◆ invalid_type_id

constexpr type_id_t caf::invalid_type_id = 65535

Special value equal to the greatest possible value for type_id_t.

Generally indicates that no type ID for a given type exists.

◆ is_self_ref_tag

template<class T >
constexpr bool caf::is_self_ref_tag = detail::is_self_ref_tag_oracle<T>::value
inline

Evaluates to true if T is either strong_self_ref_t or weak_self_ref_t.

◆ skip

constexpr skip_t caf::skip = skip_t{}

Tells the runtime system to skip a message when used as message handler, i.e., causes the runtime to leave the message in the mailbox of an actor.

◆ strong_self_ref

constexpr strong_self_ref_t caf::strong_self_ref = {}
inline

Tag to indicate that the system should keep a strong reference to an actor after passing it the self pointer.

◆ unsafe_behavior_init

constexpr unsafe_behavior_init_t caf::unsafe_behavior_init = unsafe_behavior_init_t{}

Convenience constant for constructing a typed behavior from an untyped behavior.

◆ weak_self_ref

constexpr weak_self_ref_t caf::weak_self_ref = {}
inline

Tag to indicate that the system should keep a weak reference to an actor after passing it the self pointer.