libcaf  0.17.1
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.
 
 policy
 Contains policies encapsulating characteristics or algorithms.
 

Classes

class  abstract_actor
 Base class for all actor implementations. More...
 
class  abstract_channel
 Interface for all message receivers. More...
 
class  abstract_composable_behavior
 Marker type that allows CAF to spawn actors from composable states. More...
 
class  abstract_group
 A multicast group. More...
 
class  actor
 Identifies an untyped actor. More...
 
class  actor_addr
 Stores the address of typed as well as untyped actors. More...
 
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 flags and groups. 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_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 atoms (names). More...
 
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...
 
struct  add_param
 Converts T to param<T> unless T is arithmetic, an atom constant, or a stream handshake. More...
 
struct  allowed_unsafe_message_type
 Template specializations can whitelist individual types for unsafe message passing operations. More...
 
class  arraybuf
 A streambuffer abstraction over a fixed array of bytes. More...
 
struct  atom_constant
 Lifts an atom_value to a compile-time constant. More...
 
class  attachable
 Callback utility class. More...
 
class  behavior
 Describes the behavior of an actor, i.e., provides a message handler and an optional timeout. More...
 
class  binary_deserializer
 Implements the deserializer interface with a binary serialization protocol. More...
 
class  blocking_actor
 A thread-mapped or context-switching actor using a blocking receive rather than a behavior-stack based message processing. More...
 
class  buffered_downstream_manager
 Mixin for streams with any number of downstreams. 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_impl
 Utility class for wrapping a function object of type Base. More...
 
class  composable_behavior
 Base type for composable actor states. More...
 
class  composable_behavior_base
 Generates an interface class that provides operator(). More...
 
class  composable_behavior_based_actor
 Implementation class for spawning composable states directly as actors. More...
 
struct  composed_type
 Computes the type for f*g (actor composition). 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...
 
struct  config_value_access
 
struct  config_value_access< dictionary< V > >
 Implements automagic unboxing of dictionary<V> from a homogeneous config_value::dictionary. More...
 
struct  config_value_access< std::tuple< Ts... > >
 Implements automagic unboxing of std::tuple<Ts...> from a heterogeneous config_value::list. More...
 
struct  config_value_access< std::vector< T > >
 Implements automagic unboxing of std::vector<T> from a homogeneous config_value::list. More...
 
class  containerbuf
 A streambuffer abstraction over a contiguous container. More...
 
class  cow_tuple
 A copy-on-write tuple implementation. More...
 
class  data_processor
 A data processor translates an object into a format that can be stored or vice versa. More...
 
struct  deep_to_string_t
 Wrapper to deep_to_string for using the function as an inspector. More...
 
struct  default_downstream_manager
 Selects a downstream manager implementation based on the signature of various handlers. More...
 
struct  default_sum_type_access
 Allows specializing the sum_type_access trait for any type that simply wraps a variant and exposes it with a get_data() member function. 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 string_view for looking up keys efficiently. More...
 
struct  down_msg
 Sent to all actors monitoring an actor when it is terminated. More...
 
class  downstream
 Grants access to an output stream buffer. More...
 
class  downstream_manager
 Manages downstream communication for a stream_manager. More...
 
class  downstream_manager_base
 The default downstream manager base stores outbound paths in an unordered map. More...
 
struct  downstream_msg
 Stream messages that travel downstream, i.e., batches and close messages. More...
 
class  duration
 Time duration consisting of a time_unit and a 64 bit unsigned integer. More...
 
class  empty_type_erased_tuple
 
class  error
 A serializable type for storing error codes with category and optional, human-readable context information. More...
 
class  event_based_actor
 A cooperatively scheduled, event-based actor implementation. More...
 
class  execution_unit
 Identifies an execution unit, e.g., a worker thread of the scheduler. More...
 
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...
 
class  forwarding_actor_proxy
 Implements a simple proxy forwarding all operations to a manager. More...
 
class  function_view
 A function view for an actor hides any messaging from the caller. More...
 
class  fused_downstream_manager
 A downstream manager that delegates to any number of sub-managers. More...
 
struct  group_down_msg
 Sent to all members of a group when it goes offline. More...
 
class  group_module
 Interface for user-defined multicast implementations. More...
 
class  handle
 Base class for IO handles such as accept_handle or connection_handle. More...
 
struct  has_make_error
 Evaluates to true if T is an enum with a free function make_error for converting it to an error. More...
 
struct  has_sum_type_access
 Evaluates to true if T specializes sum_type_access. More...
 
struct  illegal_message_element
 Marker class identifying classes in CAF that are not allowed to be used as message element. More...
 
class  inbound_path
 State for a path to an upstream actor (source). More...
 
class  inbound_stream_slot
 Wraps a stream slot ID for inbound paths with the full type information of the path creation. More...
 
struct  index_mapping
 Marker for representing placeholders at runtime. More...
 
struct  infer_handle_from_class
 Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced. More...
 
struct  infer_handle_from_fun
 Deduces an actor handle type from a function or function object. More...
 
struct  infinite_t
 Represents an infinite amount of timeout for specifying "invalid" timeouts. 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...
 
class  ipv4_endpoint
 An IP endpoint that contains an ::ipv4_address and a port. More...
 
class  ipv6_endpoint
 An IP endpoint that contains an ::ipv6_address and a port. More...
 
struct  is_actor_handle
 Checks whether T is an actor or a typed_actor<...>. More...
 
struct  is_typed_actor
 Evaluates to true if T is a typed_actor<...>. More...
 
class  logger
 Centrally logs events from all actors in an actor system. More...
 
struct  mailbox_category_corrector
 Corrects the message ID for down- and upstream messages to make sure the category for a mailbox_element matches its content. More...
 
class  mailbox_element_vals
 Encapsulates arbitrary data in a message element. More...
 
class  mailbox_element_view
 Provides a view for treating arbitrary data as message element. More...
 
class  make_sink_result
 Returns a stream sink with the slot ID of its first inbound path. More...
 
class  make_source_result
 Returns a stream source with the slot ID of its first outbound path. More...
 
class  make_stage_result
 Returns a stream stage with the slot IDs of its first in- and outbound paths. More...
 
class  memory_managed
 This base enables derived classes to enforce a different allocation strategy than new/delete by providing a virtual protected request_deletion() function and non-public destructor. More...
 
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 createing 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...
 
class  message_view
 Represents an object pointing to a type_erased_tuple that is convertible to a message More...
 
class  monitorable_actor
 Base class for all actor implementations. More...
 
struct  named_actor_config
 Stores a flow-control configuration. More...
 
struct  no_error_t
 Helper class to construct an expected<T> that represents no error. More...
 
struct  no_stages_t
 Convenience tag type for producing empty forwarding stacks. More...
 
class  node_id
 A node ID is an opaque value for representing CAF instances in the network. More...
 
struct  none_t
 Represents "nothing", e.g., for clearing an optional by assigning none. More...
 
struct  open_stream_msg
 Demands the receiver to open a new stream from the sender to the receiver. More...
 
class  optional
 A C++17 compatible optional implementation. More...
 
class  optional< T & >
 Template specialization to allow optional to hold a reference rather than an actual value with minimal overhead. More...
 
class  outbound_path
 State for a single path to a sink of a downstream_manager. More...
 
class  outbound_stream_slot
 Wraps a stream slot ID for outbound paths with the full type information of the path creation. More...
 
class  param
 Represents a message handler parameter of type T and guarantees copy-on-write semantics. More...
 
struct  param_decay
 Convenience struct for remove_param<std::decay<T>>. More...
 
class  proxy_registry
 Groups a (distributed) set of actors and allows actors in the same namespace to exchange messages. More...
 
struct  ratio_to_time_unit_helper
 Converts the ratio Num/Denom to a time_unit if the ratio describes seconds, milliseconds, microseconds, or minutes. More...
 
class  raw_event_based_actor
 A cooperatively raw scheduled actor is a dynamically typed actor that does not handle any system messages. More...
 
class  ref_counted
 Base class for reference counted objects with an atomic reference count. More...
 
struct  remove_param
 Unpacks param<T> to T. More...
 
class  response_handle
 This helper class identifies an expected response message and enables request(...).then(...). More...
 
class  response_promise
 A response promise can be used to deliver a uniquely identifiable response message from the server (i.e. More...
 
struct  response_type
 Defines: More...
 
struct  response_type_unbox
 Unboxes Xs and calls response_type. More...
 
class  resumable
 A cooperatively executed task managed by one or more instances of execution_unit. More...
 
class  runtime_settings_map
 Thread-safe container for mapping atoms to arbitrary settings. More...
 
class  scheduled_actor
 A cooperatively scheduled, event-based actor implementation. More...
 
class  scoped_actor
 A scoped handle to a blocking actor. More...
 
class  scoped_execution_unit
 Identifies an execution unit, e.g., a worker thread of the scheduler. More...
 
struct  select_callback
 Utility class for selecting a callback_impl. More...
 
struct  select_config_value_access
 Delegates to config_value_access for all specialized versions. More...
 
struct  select_config_value_access< T, true >
 Catches all non-specialized integer types. More...
 
class  serializer
 Technology-independent serialization interface. More...
 
class  serializer_impl
 Implements the serializer interface with a binary serialization protocol. More...
 
class  skip_t
 
class  span
 A C++11/14 drop-in replacement for C++20's std::span without support for static extents. More...
 
class  spawn_options
 Stores options passed to the spawn function family. More...
 
class  stateful_actor
 An event-based actor with managed state. More...
 
class  stream
 Empty marker type for streaming handshakes. More...
 
class  stream_buffer
 The base class for all stream buffer implementations. More...
 
class  stream_deserializer
 Implements the deserializer interface with a binary serialization protocol. More...
 
struct  stream_finalize_trait
 Dispatches a finalize call to a function taking either one or two arguments. More...
 
struct  stream_finalize_trait< Fun, State, false >
 Specializes the trait for callbacks that only take the state. More...
 
struct  stream_finalize_trait< Fun, State, true >
 Specializes the trait for callbacks that take state and error. More...
 
class  stream_manager
 Manages a single stream with any number of in- and outbound paths. More...
 
class  stream_serializer
 Implements the serializer interface with a binary serialization protocol. More...
 
class  stream_sink_driver
 Identifies an unbound sequence of messages. More...
 
struct  stream_sink_trait
 Defines required type aliases for stream sinks. More...
 
struct  stream_sink_trait< void(State &, const std::vector< In > &)>
 Specializes the trait for batch-wise processing with const references. More...
 
struct  stream_sink_trait< void(State &, In)>
 Specializes the trait for element-wise processing. More...
 
struct  stream_sink_trait< void(State &, std::vector< In > &)>
 Specializes the trait for batch-wise processing. More...
 
struct  stream_sink_trait_base
 Base type for all sink traits. More...
 
struct  stream_slots
 Maps two stream_slot values into a pair for storing sender and receiver slot information. More...
 
class  stream_source_driver
 Identifies an unbound sequence of messages. More...
 
struct  stream_source_trait
 Deduces the output type and the state type for a stream source from its pull implementation. More...
 
class  stream_stage_driver
 Encapsulates user-provided functionality for generating a stream stage. More...
 
struct  stream_stage_trait< void(State &, downstream< Out > &, In)>
 Deduces the input type, output type and the state type for a stream stage from its process implementation. More...
 
class  string_view
 Drop-in replacement for C++17 std::string_view. More...
 
struct  sum_type_access
 Specializing this trait allows users to enable holds_alternative, get, get_if, and visit for any user-defined sum type. More...
 
struct  sum_type_access< variant< Ts... > >
 Enable holds_alternative, get, get_if, and visit for variant. More...
 
class  thread_hook
 Interface to define thread hooks. More...
 
struct  timeout_msg
 Signalizes a timeout event. More...
 
class  type_erased_tuple
 Represents a tuple of type-erased values. More...
 
class  type_erased_value
 Represents a single type-erased value. More...
 
struct  type_erased_value_factory
 
struct  type_nr
 Computes the type number for T. More...
 
class  typed_actor
 Identifies a statically typed actor. More...
 
class  typed_event_based_actor
 A cooperatively scheduled, event-based actor implementation with static type-checking. More...
 
class  typed_response_promise
 A response promise can be used to deliver a uniquely identifiable response message from the server (i.e. More...
 
struct  unbox_message_element
 Unboxes atom constants, i.e., converts atom_constant<V> to V. More...
 
struct  unit_t
 Unit is analogous to void, but can be safely returned, stored, etc. More...
 
struct  upstream_msg
 Stream messages that flow upstream, i.e., acks and drop messages. More...
 
class  uri
 A URI according to RFC 3986. More...
 
class  variant
 A variant represents always a valid value of one of the types Ts.... More...
 
struct  variant_compare_helper
 
struct  variant_reader
 
struct  variant_writer
 
class  weak_intrusive_ptr
 An intrusive, reference counting smart pointer implementation. More...
 

Typedefs

using actor_factory_result = std::pair< strong_actor_ptr, std::set< std::string > >
 
using actor_factory = std::function< actor_factory_result(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 >
 
template<class T >
using is_statically_typed = std::is_base_of< statically_typed_actor_base, T >
 
template<class T >
using is_dynamically_typed = std::is_base_of< dynamically_typed_actor_base, T >
 
using add_atom = atom_constant< atom("add")>
 Used for request operations.
 
using get_atom = atom_constant< atom("get")>
 Used for request operations.
 
using put_atom = atom_constant< atom("put")>
 Used for request operations.
 
using resolve_atom = atom_constant< atom("resolve")>
 Used for signalizing resolved paths.
 
using update_atom = atom_constant< atom("update")>
 Used for signalizing updates, e.g., in a key-value store.
 
using delete_atom = atom_constant< atom("delete")>
 Used for request operations.
 
using ok_atom = atom_constant< atom("ok")>
 Used for response messages.
 
using sys_atom = atom_constant< atom("sys")>
 Used for triggering system-level message handling.
 
using join_atom = atom_constant< atom("join")>
 Used for signaling group subscriptions.
 
using leave_atom = atom_constant< atom("leave")>
 Used for signaling group unsubscriptions.
 
using forward_atom = atom_constant< atom("forward")>
 Used for signaling forwarding paths.
 
using flush_atom = atom_constant< atom("flush")>
 Used for buffer management.
 
using redirect_atom = atom_constant< atom("redirect")>
 Used for I/O redirection.
 
using link_atom = atom_constant< atom("link")>
 Used for link requests over network.
 
using unlink_atom = atom_constant< atom("unlink")>
 Used for removing networked links.
 
using monitor_atom = atom_constant< atom("monitor")>
 Used for monitor requests over network.
 
using demonitor_atom = atom_constant< atom("demonitor")>
 Used for removing networked monitors.
 
using publish_atom = atom_constant< atom("publish")>
 Used for publishing actors at a given port.
 
using publish_udp_atom = atom_constant< atom("pub_udp")>
 Used for publishing actors at a given port.
 
using unpublish_atom = atom_constant< atom("unpublish")>
 Used for removing an actor/port mapping.
 
using unpublish_udp_atom = atom_constant< atom("unpub_udp")>
 Used for removing an actor/port mapping.
 
using subscribe_atom = atom_constant< atom("subscribe")>
 Used for signalizing group membership.
 
using unsubscribe_atom = atom_constant< atom("unsubscrib")>
 Used for withdrawing group membership.
 
using connect_atom = atom_constant< atom("connect")>
 Used for establishing network connections.
 
using contact_atom = atom_constant< atom("contact")>
 Used for contacting a remote UDP endpoint.
 
using open_atom = atom_constant< atom("open")>
 Used for opening ports or files.
 
using close_atom = atom_constant< atom("close")>
 Used for closing ports or files.
 
using spawn_atom = atom_constant< atom("spawn")>
 Used for spawning remote actors.
 
using migrate_atom = atom_constant< atom("migrate")>
 Used for migrating actors to other nodes.
 
using tick_atom = atom_constant< atom("tick")>
 Used for triggering periodic operations.
 
using pending_atom = atom_constant< atom("pending")>
 Used for pending out of order messages.
 
using receive_atom = atom_constant< atom("receive")>
 Used as timeout type for timeout_msg.
 
using stream_atom = atom_constant< atom("stream")>
 Used as timeout type for timeout_msg.
 
using binary_serializer = serializer_impl< std::vector< char > >
 
template<class T >
using signatures_of_t = typename signatures_of< T >::type
 
template<class T >
using select_config_value_access_t = typename select_config_value_access< T >::type
 
template<class T >
using deduce_mpi_t = typename detail::dmfou< typename param_decay< T >::type >::type
 Deduces the message passing interface from a function object.
 
template<class F >
using default_downstream_manager_t = typename default_downstream_manager< F >::type
 
template<class T , class U = void>
using enable_if_has_make_error_t = typename std::enable_if< has_make_error< T >::value, U >::type
 Convenience alias for std::enable_if<has_make_error<T>::value, U>::type.
 
template<class T >
using function_view_flattened_result_t = typename function_view_flattened_result< T >::type
 
using actor_id = uint64_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 stream_slot = uint16_t
 Identifies a single stream path in the same way a TCP port identifies a connection over IP. More...
 
using weak_actor_ptr = weak_intrusive_ptr< actor_control_block >
 
using strong_actor_ptr = intrusive_ptr< actor_control_block >
 
using stream_manager_ptr = intrusive_ptr< stream_manager >
 
using type_erased_value_ptr = std::unique_ptr< type_erased_value >
 
using mailbox_element_ptr = std::unique_ptr< mailbox_element, detail::disposer >
 
template<spawn_mode X>
using spawn_mode_token = std::integral_constant< spawn_mode, X >
 
template<class Found , class Expected >
using interface_mismatch_t = detail::imi< 0, Found, Expected, detail::type_list<> >
 Scans two typed MPI lists for compatibility, returning the index of the first mismatch. More...
 
template<class Lockable >
using unique_lock = std::unique_lock< Lockable >
 
template<class SharedLockable >
using upgrade_lock = shared_lock< SharedLockable >
 
template<class In , class DownstreamManager , class... Ts>
using make_stage_result_t = make_stage_result< In, DownstreamManager, detail::strip_and_convert_t< Ts >... >
 Helper type for defining a make_stage_result from a downstream manager plus additional handshake types. More...
 
template<class T >
using param_t = typename add_param< T >::type
 Convenience alias that wraps T into param<T> unless T is arithmetic, a stream handshake or an atom constant. More...
 
using primitive_variant = variant< int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, float, double, long double, std::string, std::u16string, std::u32string, atom_value, bool >
 
template<class... Is>
using reacts_to = typed_mpi< detail::type_list< Is... >, output_tuple< void > >
 
template<class Ts , class... Xs>
using response_type_t = typename response_type< Ts, Xs... >::type
 Computes the response message for input Xs... from the list of message passing interfaces Ts. 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 rtti_pair = std::pair< uint16_t, const std::type_info * >
 Bundles the type number with its C++ type_info object. More...
 
template<class In >
using stream_sink_ptr = intrusive_ptr< stream_sink< In > >
 
template<class Fun >
using stream_sink_trait_t = stream_sink_trait< typename detail::get_callable_trait< Fun >::fun_sig >
 Derives a sink trait from the signatures of Fun and Fin.
 
template<class DownstreamManager >
using stream_source_ptr = intrusive_ptr< stream_source< DownstreamManager > >
 
template<class Pull >
using stream_source_trait_t = stream_source_trait< typename detail::get_callable_trait< Pull >::fun_sig >
 Convenience alias for extracting the function signature from Pull and passing it to stream_source_trait. More...
 
template<class In , class DownstreamManager >
using stream_stage_ptr = intrusive_ptr< stream_stage< In, DownstreamManager > >
 
template<class Process >
using stream_stage_trait_t = stream_stage_trait< typename detail::get_callable_trait< Process >::fun_sig >
 Convenience alias for extracting the function signature from Process and passing it to stream_stage_trait. More...
 
using charbuf = arraybuf< char >
 
using vectorbuf = containerbuf< std::vector< char > >
 
template<class F , class... Ts>
using sum_type_visit_result_t = typename sum_type_visit_result< detail::decay_t< F >, detail::decay_t< Ts >... >::type
 
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.
 
using sorted_builtin_types = detail::type_list< actor, std::vector< actor >, actor_addr, std::vector< actor_addr >, atom_value, std::vector< char >, config_value, down_msg, downstream_msg, duration, error, exit_msg, group, group_down_msg, int16_t, int32_t, int64_t, int8_t, long double, message, message_id, node_id, open_stream_msg, std::string, std::map< std::string, std::string >, strong_actor_ptr, std::set< std::string >, std::vector< std::string >, timeout_msg, timespan, timestamp, uint16_t, std::u16string, uint32_t, std::u32string, uint64_t, uint8_t, unit_t, upstream_msg, weak_actor_ptr, bool, double, float >
 Compile-time list of all built-in types. More...
 
template<class... Ts>
using is_variant_t = typename is_variant< Ts... >::type
 
template<class F , class... Ts>
using variant_visit_result_t = typename variant_visit_result< detail::decay_t< F >, detail::decay_t< Ts >... >::type
 

Enumerations

enum  atom_value : uint64_t
 The value type of atoms.
 
enum  byte : uint8_t
 A C++11/14 drop-in replacement for C++17's std::byte.
 
enum  time_unit : uint32_t
 SI time units to specify timeouts.
 
enum  exit_reason : uint8_t {
  exit_reason::normal = 0,
  exit_reason::unhandled_exception,
  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 {
  im_success,
  im_skipped,
  im_dropped
}
 
enum  message_priority {
  high = 0,
  normal = 1
}
 Denotes the urgency of asynchronous messages.
 
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::illegal_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::illegal_argument = 15,
  pec::missing_argument,
  pec::illegal_category
}
 PEC stands for "Parser Error Code". More...
 
enum  result_runtime_type {
  rt_value,
  rt_error,
  rt_delegated,
  rt_skip
}
 
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::cannot_add_upstream = 30,
  sec::upstream_already_exists,
  sec::invalid_upstream,
  sec::cannot_add_downstream,
  sec::downstream_already_exists,
  sec::invalid_downstream = 35,
  sec::no_downstream_stages_defined,
  sec::stream_init_failed,
  sec::invalid_stream_state,
  sec::unhandled_stream_error,
  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::remote_lookup_failed
}
 SEC stands for "System Error Code". More...
 
enum  stream_priority {
  stream_priority::very_high,
  stream_priority::high,
  stream_priority::normal,
  stream_priority::low,
  stream_priority::very_low
}
 Categorizes individual streams. More...
 
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...
 

Functions

actor operator * (actor f, actor g)
 Combine f and g so that (f*g)(x) = f(g(x)).
 
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 actor handle what to a different actor handle or raw pointer of type T. More...
 
error load_actor (strong_actor_ptr &storage, execution_unit *, actor_id aid, const node_id &nid)
 
error save_actor (strong_actor_ptr &storage, execution_unit *, actor_id aid, const node_id &nid)
 
template<class Inspector >
auto context_of (Inspector *f) -> decltype(f->context())
 
execution_unitcontext_of (void *)
 
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)
 
template<class Inspector >
Inspector::result_type inspect (Inspector &f, strong_actor_ptr &x)
 
template<class Inspector >
Inspector::result_type 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_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)
 Convenience factory function for creating an actor output stream.
 
template<class... Sigs>
actor_ostream aout (const typed_actor_pointer< Sigs... > &ptr)
 Convenience factory function for creating an actor output stream.
 
template<class T >
std::string get_mpi_field (const uniform_type_info_map &types)
 
template<class T >
std::string get_rtti_from_mpi (const uniform_type_info_map &types)
 
const settingscontent (const actor_system_config &cfg)
 Returns all user-provided configuration parameters.
 
constexpr timeout_definition_builder after (duration d)
 Returns a generator for timeouts.
 
template<class Rep , class Period >
constexpr timeout_definition_builder after (std::chrono::duration< Rep, Period > d)
 Returns a generator for timeouts.
 
template<size_t Size>
constexpr atom_value atom (char const (&str)[Size])
 Creates an atom from given string literal.
 
template<size_t Size>
constexpr uint64_t atom_uint (char const (&str)[Size])
 Creates an atom from given string literal and return an integer representation of the atom. More...
 
constexpr uint64_t atom_uint (atom_value x)
 Converts an atom to its integer representation.
 
template<atom_value V>
std::string to_string (const atom_constant< V > &)
 
template<class Driver , class... Ts>
Driver::source_ptr_type attach_continuous_stream_source (scheduled_actor *self, Ts &&... xs)
 Creates a new continuous stream source by instantiating the default source implementation with Driver. More...
 
template<class Init , class Pull , class Done , class Finalize = unit_t, class Trait = stream_source_trait_t<Pull>, class DownstreamManager = broadcast_downstream_manager< typename Trait::output>>
stream_source_ptr< DownstreamManager > attach_continuous_stream_source (scheduled_actor *self, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager >={})
 Creates a new continuous stream source by instantiating the default source implementation with Driver. More...
 
template<class Driver , class... Ts>
Driver::stage_ptr_type attach_continuous_stream_stage (scheduled_actor *self, Ts &&... xs)
 Returns a stream manager (implementing a continuous stage) without in- or outbound path. More...
 
template<class Init , class Fun , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
stream_stage_ptr< typename Trait::input, DownstreamManager > attach_continuous_stream_stage (scheduled_actor *self, Init init, Fun fun, Finalize fin={}, policy::arg< DownstreamManager > token={})
 
template<class Driver , class... Ts>
make_sink_result< typename Driver::input_type > attach_stream_sink (scheduled_actor *self, stream< typename Driver::input_type > in, Ts &&... xs)
 Attaches a new stream sink to self by creating a default stream sink / manager from given callbacks. More...
 
template<class In , class Init , class Fun , class Finalize = unit_t, class Trait = stream_sink_trait_t<Fun>>
make_sink_result< In > attach_stream_sink (scheduled_actor *self, stream< In > in, Init init, Fun fun, Finalize fin={})
 Attaches a new stream sink to self by creating a default stream sink manager from given callbacks. More...
 
template<class Driver , class... Ts, class... CtorArgs>
make_source_result_t< typename Driver::downstream_manager_type, Ts... > attach_stream_source (scheduled_actor *self, std::tuple< Ts... > xs, CtorArgs &&... ctor_args)
 Attaches a new stream source to self by creating a default stream source manager with Driver. More...
 
template<class... Ts, class Init , class Pull , class Done , class Finalize = unit_t, class Trait = stream_source_trait_t<Pull>, class DownstreamManager = broadcast_downstream_manager< typename Trait::output>>
make_source_result_t< DownstreamManager, Ts... > attach_stream_source (scheduled_actor *self, std::tuple< Ts... > xs, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager >={})
 Attaches a new stream source to self by creating a default stream source manager with the default driver. More...
 
template<class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t<!is_actor_handle< Init >::value &&Trait::valid, make_source_result_t< DownstreamManager > > attach_stream_source (scheduled_actor *self, Init init, Pull pull, Done done, Finalize finalize={}, policy::arg< DownstreamManager > token={})
 Attaches a new stream source to self by creating a default stream source manager with the default driver. More...
 
template<class ActorHandle , class... Ts, class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t< is_actor_handle< ActorHandle >::value, make_source_result_t< DownstreamManager > > attach_stream_source (scheduled_actor *self, const ActorHandle &dest, std::tuple< Ts... > xs, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager >={})
 Attaches a new stream source to self by creating a default stream source manager with the default driver and starts sending to dest immediately. More...
 
template<class ActorHandle , class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t< is_actor_handle< ActorHandle >::value &&Trait::valid, make_source_result_t< DownstreamManager > > attach_stream_source (scheduled_actor *self, const ActorHandle &dest, Init init, Pull pull, Done done, Finalize fin={}, policy::arg< DownstreamManager > token={})
 Attaches a new stream source to self by creating a default stream source manager with the default driver and starts sending to dest immediately. More...
 
template<class Driver , class In , class... Ts, class... Us>
make_stage_result_t< In, typename Driver::downstream_manager_type, Ts... > attach_stream_stage (scheduled_actor *self, const stream< In > &in, std::tuple< Ts... > xs, Us &&... ys)
 Attaches a new stream stage to self by creating a default stream stage manager with Driver. More...
 
template<class In , class... Ts, class Init , class Fun , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
make_stage_result_t< In, DownstreamManager, Ts... > attach_stream_stage (scheduled_actor *self, const stream< In > &in, std::tuple< Ts... > xs, Init init, Fun fun, Finalize fin={}, policy::arg< DownstreamManager > token={})
 Attaches a new stream stage to self by creating a default stream stage manager from given callbacks. More...
 
template<class In , class Init , class Fun , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
make_stage_result_t< In, DownstreamManager > attach_stream_stage (scheduled_actor *self, const stream< In > &in, Init init, Fun fun, Finalize fin={}, policy::arg< DownstreamManager > token={})
 Attaches a new stream stage to self by creating a default stream stage manager from given callbacks. More...
 
template<class IntegerType , class = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr IntegerType to_integer (byte x) noexcept
 
template<class IntegerType , class E = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr byteoperator<<= (byte &x, IntegerType shift) noexcept
 
template<class IntegerType , class E = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr byte operator<< (byte x, IntegerType shift) noexcept
 
template<class IntegerType , class E = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr byteoperator>>= (byte &x, IntegerType shift) noexcept
 
template<class IntegerType , class E = detail::enable_if_tt<std::is_integral<IntegerType>>>
constexpr byte operator>> (byte x, IntegerType shift) noexcept
 
byteoperator|= (byte &x, byte y) noexcept
 
constexpr byte operator| (byte x, byte y) noexcept
 
byteoperator&= (byte &x, byte y) noexcept
 
constexpr byte operator & (byte x, byte y) noexcept
 
byteoperator^= (byte &x, byte y) noexcept
 
constexpr byte operator^ (byte x, byte y) noexcept
 
constexpr byte operator~ (byte x) noexcept
 
template<class T >
constexpr bool statically_typed ()
 
template<class ForwardIterator , class Sentinel >
std::pair< ForwardIterator, string_viewfind_by_long_name (const config_option &x, ForwardIterator first, Sentinel last)
 Finds config_option string with a matching long name in (first, last], where each entry is a pointer to a string. More...
 
template<class... Ts>
config_value make_config_value_list (Ts &&... xs)
 
template<class... Ts>
std::string deep_to_string (const Ts &... xs)
 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... Ts>
bool operator== (const delegated< Ts... > &, const delegated< Ts... > &)
 
template<class T >
std::enable_if< std::is_same< error, decltype(std::declval< deserializer & >).apply(std::declval< T & >))) >::value >::type operator & (deserializer &source, T &x)
 
template<class T >
std::enable_if< std::is_same< error, decltype(std::declval< deserializer & >).apply(std::declval< T & >))) >::value, deserializer & >::type operator>> (deserializer &source, T &x)
 
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)
 
template<class T >
const T & get (const downstream_msg &x)
 Allows the testing DSL to unbox downstream_msg automagically.
 
template<class T >
bool is (const downstream_msg &x)
 Allows the testing DSL to check whether downstream_msg holds a T.
 
std::string to_string (time_unit x)
 Relates time_unit.
 
constexpr intmax_t denom_to_unit_index (intmax_t x, intmax_t offset=2)
 
constexpr time_unit denom_to_time_unit (intmax_t x)
 
template<class Inspector >
detail::enable_if_t< Inspector::writes_state, typename Inspector::result_type > inspect (Inspector &f, error::inspect_helper &x)
 
template<class... Ts, class F = void (*)(actor_system&)>
int exec_main (F fun, int argc, char **argv, const char *config_file_name="caf-application.ini")
 
std::string to_string (exit_reason x)
 Returns a string representation of given exit reason.
 
template<class T >
std::string to_string (const expected< T > &x)
 
std::string to_string (const expected< void > &x)
 
template<class T >
config_option make_config_option (string_view category, string_view name, string_view description)
 Creates a config option that synchronizes with storage.
 
template<class T >
config_option make_config_option (T &storage, string_view category, string_view name, string_view description)
 Creates a config option that synchronizes with storage.
 
bool operator== (const index_mapping &x, const index_mapping &y)
 
template<class Inspector >
Inspector::result_type inspect (Inspector &f, index_mapping &x)
 
template<class T >
std::string to_string (const intrusive_ptr< T > &x)
 
std::string to_string (invoke_message_result x)
 
std::string to_string (const ipv4_endpoint &ep)
 
error parse (string_view str, ipv6_address &dest)
 
std::string to_string (const ipv6_endpoint &ep)
 
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, string_view category, string_view name, string_view description)
 
config_option make_us_resolution_config_option (size_t &storage, string_view category, string_view name, string_view description)
 
config_option make_ms_resolution_config_option (size_t &storage, string_view category, string_view name, string_view description)
 
template<class... Ts>
message make_message_from_tuple (std::tuple< Ts... > xs)
 Converts the tuple xs to a message.
 
bool operator< (const match_case_info &x, const match_case_info &y)
 
template<class F >
std::enable_if< !std::is_base_of< match_case, F >::value, std::tuple< trivial_match_case< F > >>::type to_match_case_tuple (F fun)
 
template<class MatchCase >
std::enable_if< std::is_base_of< match_case, MatchCase >::value, std::tuple< const MatchCase & >>::type to_match_case_tuple (const MatchCase &x)
 
template<class... Ts>
const std::tuple< Ts... > & to_match_case_tuple (const std::tuple< Ts... > &x)
 
template<class T , class U >
std::enable_if< std::is_base_of< match_case, T >::value||std::is_base_of< match_case, U >::value >::type operator, (T, U)
 
template<class Inspector >
Inspector::result_type inspect (Inspector &f, named_actor_config &x)
 
template<class Inspector , class T >
std::enable_if< Inspector::reads_state, typename Inspector::result_type >::type inspect (Inspector &f, optional< T > &x)
 
template<class Inspector , class T >
std::enable_if< Inspector::writes_state, typename Inspector::result_type >::type inspect (Inspector &f, optional< T > &x)
 
error make_error (pec code)
 Returns an error object from given error code.
 
error make_error (pec code, size_t line, size_t column)
 Returns an error object from given error code with additional context information for where the parser stopped in the input. More...
 
error make_error (pec code, string_view argument)
 Returns an error object from given error code with additional context information for where the parser stopped in the argument. More...
 
template<class T >
std::enable_if< std::is_same< T *, resumable * >::value >::type intrusive_ptr_add_ref (T *ptr)
 
template<class T >
std::enable_if< std::is_same< T *, resumable * >::value >::type intrusive_ptr_release (T *ptr)
 
std::string to_string (const scoped_actor &x)
 
template<message_priority P = message_priority::normal, class Source = actor, class Dest = actor, class... Ts>
void send_as (const Source &src, const Dest &dest, Ts &&... xs)
 Sends to a message under the identity of from with priority prio.
 
template<message_priority P = message_priority::normal, class Source , class Dest , class... Ts>
void unsafe_send_as (Source *src, const Dest &dest, Ts &&... xs)
 
template<class... Ts>
void unsafe_response (local_actor *self, strong_actor_ptr src, std::vector< strong_actor_ptr > stages, message_id mid, Ts &&... xs)
 
template<message_priority P = message_priority::normal, class Dest = actor, class... Ts>
void anon_send (const Dest &dest, Ts &&... xs)
 Anonymously sends dest a message.
 
template<message_priority P = message_priority::normal, class Dest = actor, class Rep = int, class Period = std::ratio<1>, class... Ts>
detail::enable_if_t<!std::is_same< Dest, group >::value > delayed_anon_send (const Dest &dest, std::chrono::duration< Rep, Period > rtime, Ts &&... xs)
 
template<class Rep = int, class Period = std::ratio<1>, class... Ts>
void delayed_anon_send (const group &dest, std::chrono::duration< Rep, Period > rtime, Ts &&... xs)
 
template<class Dest >
void anon_send_exit (const Dest &dest, exit_reason reason)
 Anonymously sends dest an exit message.
 
void anon_send_exit (const actor_addr &to, exit_reason reason)
 Anonymously sends to an exit message.
 
void anon_send_exit (const weak_actor_ptr &to, exit_reason reason)
 Anonymously sends to an exit message.
 
template<class T >
std::enable_if< std::is_same< error, decltype(std::declval< serializer & >).apply(std::declval< T & >))) >::value >::type operator & (serializer &sink, const T &x)
 
template<class T >
std::enable_if< std::is_same< error, decltype(std::declval< serializer & >).apply(std::declval< T & >))) >::value, serializer & >::type operator<< (serializer &sink, const T &x)
 
template<class T >
get (const settings &xs, string_view name)
 
template<class T , class = typename std::enable_if< !std::is_pointer<T>::value && !std::is_convertible<T, string_view>::value>::type>
get_or (const settings &xs, string_view name, T default_value)
 
std::string get_or (const settings &xs, string_view name, string_view default_value)
 
template<class T >
config_valueput (settings &dict, 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, 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...
 
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 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 byteas_bytes (span< T > xs)
 
template<class T >
span< byteas_writable_bytes (span< T > xs)
 
template<class T >
auto make_span (T &xs) -> span< detail::remove_reference_t< decltype(xs[0])>>
 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...
 
attachable_ptr make_stream_aborter (actor_addr observed, actor_addr observer, stream_slot slot, stream_aborter::mode m)
 
string_view is_any_of (string_view arg)
 
void split (std::vector< std::string > &result, string_view str, string_view delims, bool keep_all=true)
 
void split (std::vector< string_view > &result, string_view str, string_view delims, bool keep_all=true)
 
void split (std::vector< std::string > &result, string_view str, char delim, bool keep_all=true)
 
void split (std::vector< string_view > &result, string_view str, char delim, bool keep_all=true)
 
template<class InputIterator >
std::string join (InputIterator first, InputIterator last, string_view glue)
 
template<class Container >
std::string join (const Container &c, string_view glue)
 
void replace_all (std::string &str, string_view what, string_view with)
 Replaces all occurrences of what by with in str.
 
bool starts_with (string_view str, string_view prefix)
 Returns whether str begins with prefix.
 
bool ends_with (string_view str, string_view suffix)
 Returns whether str ends with suffix.
 
template<class T >
constexpr bool SumType ()
 Concept for checking whether T supports the sum type API by specializing sum_type_access. More...
 
template<class... Ts>
constexpr bool SumTypes ()
 Concept for checking whether all Ts support the sum type API by specializing sum_type_access. More...
 
template<class Trait , class T >
constexpr sum_type_token< T, sum_type_index< Trait, T >::value > make_sum_type_token ()
 
template<class T , int Pos>
constexpr std::integral_constant< int, Pos > pos (sum_type_token< T, Pos >)
 
std::ostream & operator<< (std::ostream &out, term x)
 
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.
 
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...
 
template<class T , class E = typename std::enable_if< detail::is_inspectable< detail::stringification_inspector, T >::value >::type>
std::string to_string (const T &x)
 
template<class... Ts>
constexpr uint32_t make_type_token ()
 
constexpr uint32_t add_to_type_token (uint32_t token, uint16_t tnr)
 
template<class T >
constexpr uint32_t make_type_token_from_list ()
 
template<class... Xs, class... Ts>
detail::mpi_splice< typed_actor, detail::type_list< Xs... >, typename Ts::signatures... >::type splice (const typed_actor< Xs... > &x, const Ts &... xs)
 
template<class T >
const T & get (const upstream_msg &x)
 Allows the testing DSL to unbox upstream_msg automagically.
 
template<class T >
bool is (const upstream_msg &x)
 Allows the testing DSL to check whether upstream_msg holds a T.
 
template<class Inspector >
Inspector::result_type inspect (Inspector &f, uri::authority_type &x)
 

Variables

constexpr actor_id invalid_actor_id = 0
 Denotes an ID that is never used by an actor.
 
static constexpr infinite_t infinite = infinite_t{}
 
constexpr invalid_stream_t invalid_stream = invalid_stream_t{}
 
constexpr no_stages_t no_stages = no_stages_t{}
 Convenience tag for producing empty forwarding stacks.
 
static constexpr none_t none = none_t{}
 
constexpr others_t others = others_t{}
 
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...
 
static constexpr size_t stream_priorities = 5
 Stores the number of stream_priority classes.
 
constexpr stream_slot invalid_stream_slot = 0
 Identifies an invalid slot.
 
constexpr bool token_compress_on = false
 
static constexpr size_t type_nrs
 The number of built-in types. More...
 
const char * numbered_type_names []
 List of all type names, indexed via type_nr.
 
static constexpr unit_t unit = unit_t{}
 
constexpr size_t variant_npos = static_cast<size_t>(-1)
 

Detailed Description

Root namespace of libcaf.

Typedef Documentation

◆ interface_mismatch_t

template<class Found , class Expected >
using caf::interface_mismatch_t = typedef detail::imi<0, Found, Expected, detail::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

typedef ipv6_subnet caf::ip_subnet

An IP subnetwork.

The address family is IPv6 unless embeds_v4 returns true.

◆ make_stage_result_t

template<class In , class DownstreamManager , class... Ts>
using caf::make_stage_result_t = typedef make_stage_result<In, DownstreamManager, detail::strip_and_convert_t<Ts>...>

Helper type for defining a make_stage_result from a downstream manager plus additional handshake types.

Hardwires message as result type.

◆ param_t

template<class T >
using caf::param_t = typedef typename add_param<T>::type

Convenience alias that wraps T into param<T> unless T is arithmetic, a stream handshake or an atom constant.

◆ response_type_t

template<class Ts , class... Xs>
using caf::response_type_t = typedef typename response_type<Ts, Xs...>::type

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

◆ 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.

◆ rtti_pair

using caf::rtti_pair = typedef std::pair<uint16_t, const std::type_info*>

Bundles the type number with its C++ type_info object.

The type number is non-zero for builtin types and the pointer to the type_info object is non-null for custom types.

◆ sorted_builtin_types

using caf::sorted_builtin_types = typedef detail::type_list< actor, std::vector<actor>, actor_addr, std::vector<actor_addr>, atom_value, std::vector<char>, config_value, down_msg, downstream_msg, duration, error, exit_msg, group, group_down_msg, int16_t, int32_t, int64_t, int8_t, long double, message, message_id, node_id, open_stream_msg, std::string, std::map<std::string, std::string>, strong_actor_ptr, std::set<std::string>, std::vector<std::string>, timeout_msg, timespan, timestamp, uint16_t, std::u16string, uint32_t, std::u32string, uint64_t, uint8_t, unit_t, upstream_msg, weak_actor_ptr, bool, double, float >

Compile-time list of all built-in types.

Warning
Types are sorted by uniform name.

◆ stream_slot

typedef uint16_t caf::stream_slot

Identifies a single stream path in the same way a TCP port identifies a connection over IP.

◆ stream_source_trait_t

template<class Pull >
using caf::stream_source_trait_t = typedef stream_source_trait<typename detail::get_callable_trait<Pull>::fun_sig>

Convenience alias for extracting the function signature from Pull and passing it to stream_source_trait.

◆ stream_stage_trait_t

template<class Process >
using caf::stream_stage_trait_t = typedef stream_stage_trait<typename detail::get_callable_trait<Process>::fun_sig>

Convenience alias for extracting the function signature from Process and passing it to stream_stage_trait.

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.

unhandled_exception 

Indicates that an actor died because of an unhandled exception.

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 finishied execution because a connection to a remote link was closed unexpectedly.

unreachable 

Indicates that an actor was killed because it became unreachable.

◆ 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.

illegal_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.

illegal_argument 

Stopped at an unparseable argument.

missing_argument 

Stopped because an argument was omitted.

illegal_category 

Stopped because the key of a category was taken.

◆ 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.

cannot_add_upstream 

Adding an upstream to a stream failed.

upstream_already_exists 

Adding an upstream to a stream failed because it already exists.

invalid_upstream 

Unable to process upstream messages because upstream is invalid.

cannot_add_downstream 

Adding a downstream to a stream failed.

downstream_already_exists 

Adding a downstream to a stream failed because it already exists.

invalid_downstream 

Unable to process downstream messages because downstream is invalid.

no_downstream_stages_defined 

Cannot start streaming without next stage.

stream_init_failed 

Actor failed to initialize state after receiving a stream handshake.

invalid_stream_state 

Unable to process a stream since due to missing state.

unhandled_stream_error 

Stream aborted due to unexpected error.

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.

remote_lookup_failed 

Resolving a path on a remote node failed.

◆ stream_priority

enum caf::stream_priority
strong

Categorizes individual streams.

Enumerator
very_high 

Denotes soft-realtime traffic.

high 

Denotes time-sensitive traffic.

normal 

Denotes traffic with moderate timing requirements.

low 

Denotes uncritical traffic without timing requirements.

very_low 

Denotes best-effort traffic.

◆ 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.

Function Documentation

◆ actor_cast()

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

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

◆ append_timestamp_to_string()

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.

◆ atom_uint()

template<size_t Size>
constexpr uint64_t caf::atom_uint ( char const (&)  str[Size])

Creates an atom from given string literal and return an integer representation of the atom.

◆ attach_continuous_stream_source() [1/2]

template<class Driver , class... Ts>
Driver::source_ptr_type caf::attach_continuous_stream_source ( scheduled_actor self,
Ts &&...  xs 
)

Creates a new continuous stream source by instantiating the default source implementation with Driver.

The returned manager is not connected to any slot and thus not stored by the actor automatically.

Parameters
selfPoints to the hosting actor.
initFunction object for initializing the state of the source.
pullGenerator function object for producing downstream messages.
donePredicate returning true when generator is done.
finCleanup handler.
Returns
The new stream_manager.

◆ attach_continuous_stream_source() [2/2]

template<class Init , class Pull , class Done , class Finalize = unit_t, class Trait = stream_source_trait_t<Pull>, class DownstreamManager = broadcast_downstream_manager< typename Trait::output>>
stream_source_ptr<DownstreamManager> caf::attach_continuous_stream_source ( scheduled_actor self,
Init  init,
Pull  pull,
Done  done,
Finalize  fin = {},
policy::arg< DownstreamManager >  = {} 
)

Creates a new continuous stream source by instantiating the default source implementation with Driver.

The returned manager is not connected to any slot and thus not stored by the actor automatically.

Parameters
selfPoints to the hosting actor.
initFunction object for initializing the state of the source.
pullGenerator function object for producing downstream messages.
donePredicate returning true when generator is done.
finCleanup handler.
Returns
The new stream_manager.

◆ attach_continuous_stream_stage() [1/2]

template<class Driver , class... Ts>
Driver::stage_ptr_type caf::attach_continuous_stream_stage ( scheduled_actor self,
Ts &&...  xs 
)

Returns a stream manager (implementing a continuous stage) without in- or outbound path.

The returned manager is not connected to any slot and thus not stored by the actor automatically.

Parameters
selfPoints to the hosting actor.
xsUser-defined arguments for the downstream handshake.
Returns
The new stream_manager.

◆ attach_continuous_stream_stage() [2/2]

template<class Init , class Fun , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
stream_stage_ptr<typename Trait::input, DownstreamManager> caf::attach_continuous_stream_stage ( scheduled_actor self,
Init  init,
Fun  fun,
Finalize  fin = {},
policy::arg< DownstreamManager >  token = {} 
)
Parameters
selfPoints to the hosting actor.
initFunction object for initializing the state of the stage.
funProcessing function.
finOptional cleanup handler.
tokenPolicy token for selecting a downstream manager implementation.

◆ attach_stream_sink() [1/2]

template<class Driver , class... Ts>
make_sink_result<typename Driver::input_type> caf::attach_stream_sink ( scheduled_actor self,
stream< typename Driver::input_type >  in,
Ts &&...  xs 
)

Attaches a new stream sink to self by creating a default stream sink / manager from given callbacks.

Parameters
selfPoints to the hosting actor.
xsAdditional constructor arguments for Driver.
Returns
The new stream_manager, an inbound slot, and an outbound slot.

◆ attach_stream_sink() [2/2]

template<class In , class Init , class Fun , class Finalize = unit_t, class Trait = stream_sink_trait_t<Fun>>
make_sink_result<In> caf::attach_stream_sink ( scheduled_actor self,
stream< In >  in,
Init  init,
Fun  fun,
Finalize  fin = {} 
)

Attaches a new stream sink to self by creating a default stream sink manager from given callbacks.

Parameters
selfPoints to the hosting actor.
inStream handshake from upstream path.
initFunction object for initializing the state of the sink.
funProcessing function.
finOptional cleanup handler.
Returns
The new stream_manager and the inbound slot.

◆ attach_stream_source() [1/5]

template<class Driver , class... Ts, class... CtorArgs>
make_source_result_t<typename Driver::downstream_manager_type, Ts...> caf::attach_stream_source ( scheduled_actor self,
std::tuple< Ts... >  xs,
CtorArgs &&...  ctor_args 
)

Attaches a new stream source to self by creating a default stream source manager with Driver.

Parameters
selfPoints to the hosting actor.
xsUser-defined arguments for the stream handshake.
initFunction object for initializing the state of the source.
pullFunction object for generating downstream messages.
donePredicate returning true when generator is done.
finOptional cleanup handler.
Returns
The allocated stream_manager and the output slot.

◆ attach_stream_source() [2/5]

template<class... Ts, class Init , class Pull , class Done , class Finalize = unit_t, class Trait = stream_source_trait_t<Pull>, class DownstreamManager = broadcast_downstream_manager< typename Trait::output>>
make_source_result_t<DownstreamManager, Ts...> caf::attach_stream_source ( scheduled_actor self,
std::tuple< Ts... >  xs,
Init  init,
Pull  pull,
Done  done,
Finalize  fin = {},
policy::arg< DownstreamManager >  = {} 
)

Attaches a new stream source to self by creating a default stream source manager with the default driver.

Parameters
selfPoints to the hosting actor.
xsUser-defined arguments for the stream handshake.
initFunction object for initializing the state of the source.
pullGenerator function object for producing downstream messages.
donePredicate returning true when generator is done.
finCleanup handler.
Returns
The allocated stream_manager and the output slot.

◆ attach_stream_source() [3/5]

template<class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t<!is_actor_handle<Init>::value && Trait::valid, make_source_result_t<DownstreamManager> > caf::attach_stream_source ( scheduled_actor self,
Init  init,
Pull  pull,
Done  done,
Finalize  finalize = {},
policy::arg< DownstreamManager >  token = {} 
)

Attaches a new stream source to self by creating a default stream source manager with the default driver.

Parameters
selfPoints to the hosting actor.
initFunction object for initializing the state of the source.
pullGenerator function object for producing downstream messages.
donePredicate returning true when generator is done.
finCleanup handler.
Returns
The allocated stream_manager and the output slot.

◆ attach_stream_source() [4/5]

template<class ActorHandle , class... Ts, class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t<is_actor_handle<ActorHandle>::value, make_source_result_t<DownstreamManager> > caf::attach_stream_source ( scheduled_actor self,
const ActorHandle &  dest,
std::tuple< Ts... >  xs,
Init  init,
Pull  pull,
Done  done,
Finalize  fin = {},
policy::arg< DownstreamManager >  = {} 
)

Attaches a new stream source to self by creating a default stream source manager with the default driver and starts sending to dest immediately.

Parameters
selfPoints to the hosting actor.
destHandle to the next stage in the pipeline.
xsUser-defined arguments for the stream handshake.
initFunction object for initializing the state of the source.
pullGenerator function object for producing downstream messages.
donePredicate returning true when generator is done.
finCleanup handler.
Returns
The allocated stream_manager and the output slot.

◆ attach_stream_source() [5/5]

template<class ActorHandle , class Init , class Pull , class Done , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Pull>, class Trait = stream_source_trait_t<Pull>>
detail::enable_if_t<is_actor_handle<ActorHandle>::value && Trait::valid, make_source_result_t<DownstreamManager> > caf::attach_stream_source ( scheduled_actor self,
const ActorHandle &  dest,
Init  init,
Pull  pull,
Done  done,
Finalize  fin = {},
policy::arg< DownstreamManager >  token = {} 
)

Attaches a new stream source to self by creating a default stream source manager with the default driver and starts sending to dest immediately.

Parameters
selfPoints to the hosting actor.
destHandle to the next stage in the pipeline.
initFunction object for initializing the state of the source.
pullGenerator function object for producing downstream messages.
donePredicate returning true when generator is done.
finCleanup handler.
Returns
The allocated stream_manager and the output slot.

◆ attach_stream_stage() [1/3]

template<class Driver , class In , class... Ts, class... Us>
make_stage_result_t<In, typename Driver::downstream_manager_type, Ts...> caf::attach_stream_stage ( scheduled_actor self,
const stream< In > &  in,
std::tuple< Ts... >  xs,
Us &&...  ys 
)

Attaches a new stream stage to self by creating a default stream stage manager with Driver.

Parameters
selfPoints to the hosting actor.
inStream handshake from upstream path.
xsUser-defined arguments for the downstream handshake.
ysAdditional constructor arguments for Driver.
Returns
The new stream_manager, an inbound slot, and an outbound slot.

◆ attach_stream_stage() [2/3]

template<class In , class... Ts, class Init , class Fun , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
make_stage_result_t<In, DownstreamManager, Ts...> caf::attach_stream_stage ( scheduled_actor self,
const stream< In > &  in,
std::tuple< Ts... >  xs,
Init  init,
Fun  fun,
Finalize  fin = {},
policy::arg< DownstreamManager >  token = {} 
)

Attaches a new stream stage to self by creating a default stream stage manager from given callbacks.

Parameters
selfPoints to the hosting actor.
inStream handshake from upstream path.
xsUser-defined arguments for the downstream handshake.
initFunction object for initializing the state of the stage.
funProcessing function.
finOptional cleanup handler.
tokenPolicy token for selecting a downstream manager implementation.
Returns
The new stream_manager, an inbound slot, and an outbound slot.

◆ attach_stream_stage() [3/3]

template<class In , class Init , class Fun , class Finalize = unit_t, class DownstreamManager = default_downstream_manager_t<Fun>, class Trait = stream_stage_trait_t<Fun>>
make_stage_result_t<In, DownstreamManager> caf::attach_stream_stage ( scheduled_actor self,
const stream< In > &  in,
Init  init,
Fun  fun,
Finalize  fin = {},
policy::arg< DownstreamManager >  token = {} 
)

Attaches a new stream stage to self by creating a default stream stage manager from given callbacks.

Parameters
selfPoints to the hosting actor.
inStream handshake from upstream path.
initFunction object for initializing the state of the stage.
funProcessing function.
finOptional cleanup handler.
tokenPolicy token for selecting a downstream manager implementation.
Returns
The new stream_manager, an inbound slot, and an outbound slot.

◆ deep_to_string()

template<class... Ts>
std::string caf::deep_to_string ( const Ts &...  xs)

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>.

◆ find_by_long_name()

template<class ForwardIterator , class Sentinel >
std::pair<ForwardIterator, string_view> caf::find_by_long_name ( const config_option x,
ForwardIterator  first,
Sentinel  last 
)

Finds config_option string with a matching long name in (first, last], where each entry is a pointer to a string.

Returns a ForwardIterator to the match and a caf::string_view of the option value if the entry is found and a ForwardIterator to last with an empty string_view otherwise.

◆ make_error() [1/2]

error caf::make_error ( pec  code,
size_t  line,
size_t  column 
)

Returns an error object from given error code with additional context information for where the parser stopped in the input.

◆ make_error() [2/2]

error caf::make_error ( pec  code,
string_view  argument 
)

Returns an error object from given error code with additional context information for where the parser stopped in the argument.

◆ make_span() [1/3]

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

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

◆ make_span() [2/3]

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() [3/3]

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()

timestamp caf::make_timestamp ( )

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

◆ put()

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

Converts value to a config_value and assigns it to key.

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

◆ put_dictionary()

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()

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,
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.

◆ SumType()

template<class T >
constexpr bool caf::SumType ( )

Concept for checking whether T supports the sum type API by specializing sum_type_access.

◆ SumTypes()

template<class... Ts>
constexpr bool caf::SumTypes ( )

Concept for checking whether all Ts support the sum type API by specializing sum_type_access.

Variable Documentation

◆ 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.

◆ type_nrs

constexpr size_t caf::type_nrs
static
Initial value:
= detail::tl_size<sorted_builtin_types>::value
+ 1

The number of built-in types.