libcaf
0.17.1
|
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 | allowed_unsafe_message_type |
Template specializations can whitelist individual types for unsafe message passing operations. 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... | |
struct | select_callback |
Utility class for selecting a callback_impl . More... | |
class | composable_behavior_base |
Generates an interface class that provides operator() . More... | |
class | composable_behavior |
Base type for composable actor states. 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 | 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... | |
struct | config_value_access< std::vector< T > > |
Implements automagic unboxing of std::vector<T> from a homogeneous config_value::list . 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< dictionary< V > > |
Implements automagic unboxing of dictionary<V> from a homogeneous config_value::dictionary . 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 | 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... | |
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... | |
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... | |
struct | infinite_t |
Represents an infinite amount of timeout for specifying "invalid" timeouts. More... | |
class | duration |
Time duration consisting of a time_unit and a 64 bit unsigned integer. 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... | |
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 | no_error_t |
Helper class to construct an expected<T> that represents no error. 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... | |
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 | optional |
A C++17 compatible optional implementation. More... | |
class | param |
Represents a message handler parameter of type T and guarantees copy-on-write semantics. More... | |
class | serializer_impl |
Implements the serializer interface with a binary serialization protocol. More... | |
class | span |
A C++11/14 drop-in replacement for C++20's std::span without support for static extents. More... | |
class | stream |
Empty marker type for streaming handshakes. More... | |
class | weak_intrusive_ptr |
An intrusive, reference counting smart pointer implementation. 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... | |
class | variant |
A variant represents always a valid value of one of the types Ts... . More... | |
class | output_stream |
Empty marker type for type-checking of stream sources and stages. More... | |
class | stateful_actor |
An event-based actor with managed state. More... | |
class | group_module |
Interface for user-defined multicast implementations. 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... | |
struct | index_mapping |
Marker for representing placeholders at runtime. More... | |
struct | infer_handle_from_fun |
Deduces an actor handle type from a function or function object. More... | |
struct | infer_handle_from_class |
Deduces actor for dynamically typed actors, otherwise typed_actor<...> is deduced. 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... | |
struct | unbox_message_element |
Unboxes atom constants, i.e., converts atom_constant<V> to V . More... | |
class | make_sink_result |
Returns a stream sink with the slot ID of its first inbound path. More... | |
struct | 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... | |
struct | type_erased_value_factory |
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_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... | |
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... | |
struct | remove_param |
Unpacks param<T> to T . 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... | |
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... | |
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... | |
class | serializer |
Technology-independent serialization interface. More... | |
class | skip_t |
class | spawn_options |
Stores options passed to the spawn function family. 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_base |
Base type for all sink traits. More... | |
struct | stream_sink_trait |
Defines required type aliases for stream sinks. 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< void(State &, const std::vector< In > &)> |
Specializes the trait for batch-wise processing with const references. More... | |
struct | stream_slots |
Maps two stream_slot values into a pair for storing sender and receiver slot information. More... | |
class | inbound_stream_slot |
Wraps a stream slot ID for inbound paths with the full type information of the path creation. More... | |
class | outbound_stream_slot |
Wraps a stream slot ID for outbound paths with the full type information of the path creation. 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 | stream_buffer |
The base class for all stream buffer implementations. More... | |
class | arraybuf |
A streambuffer abstraction over a fixed array of bytes. More... | |
class | containerbuf |
A streambuffer abstraction over a contiguous container. 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 | has_sum_type_access |
Evaluates to true if T specializes sum_type_access . More... | |
struct | exit_msg |
Sent to all links when an actor is terminated. More... | |
struct | down_msg |
Sent to all actors monitoring an actor when it is terminated. More... | |
struct | group_down_msg |
Sent to all members of a group when it goes offline. More... | |
struct | timeout_msg |
Signalizes a timeout event. More... | |
struct | open_stream_msg |
Demands the receiver to open a new stream from the sender to the receiver. More... | |
class | thread_hook |
Interface to define thread hooks. More... | |
class | type_erased_tuple |
Represents a tuple of type-erased values. More... | |
class | empty_type_erased_tuple |
class | type_erased_value |
Represents a single type-erased value. More... | |
struct | type_nr |
Computes the type number for T . 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... | |
struct | sum_type_access< variant< Ts...> > |
Enable holds_alternative , get , get_if , and visit for variant . More... | |
struct | variant_compare_helper |
struct | variant_reader |
struct | variant_writer |
class | handle |
Base class for IO handles such as accept_handle or connection_handle . 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 std::conditional< std::is_arithmetic< T >::value||is_atom_constant< T >::value, T, param< T > >::type |
Convenience alias that wraps T into param<T> unless T is arithmetic 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 |
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 > | |
T | 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_unit * | context_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 settings & | content (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 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 byte & | operator<<= (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 byte & | operator>>= (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 |
byte & | operator|= (byte &x, byte y) noexcept |
constexpr byte | operator| (byte x, byte y) noexcept |
byte & | operator&= (byte &x, byte y) noexcept |
constexpr byte | operator& (byte x, byte y) noexcept |
byte & | operator^= (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_view > | 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. More... | |
template<class... Ts> | |
config_value | make_config_value_list (Ts &&...xs) |
template<class... Ts> | |
std::string | deep_to_string_as_tuple (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... 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> | |
R | 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<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 > | |
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> | |
T | 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_value & | put (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::dictionary & | put_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 byte > | as_bytes (span< T > xs) |
template<class T > | |
span< byte > | as_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. | |
constexpr deep_to_string_t | deep_to_string = deep_to_string_t{} |
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... | |
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) |
Root namespace of libcaf.
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.
typedef ipv6_subnet caf::ip_subnet |
An IP subnetwork.
The address family is IPv6 unless embeds_v4
returns true.
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.
using caf::param_t = typedef typename std::conditional< std::is_arithmetic<T>::value || is_atom_constant<T>::value, T, param<T> >::type |
Convenience alias that wraps T
into param<T>
unless T
is arithmetic or an atom constant.
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
.
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
.
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.
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.
typedef uint16_t caf::stream_slot |
Identifies a single stream path in the same way a TCP port identifies a connection over IP.
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
.
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
.
|
strong |
This error category represents fail conditions for actors.
|
strong |
PEC stands for "Parser Error Code".
This enum contains error codes used by various CAF parsers.
|
strong |
SEC stands for "System Error Code".
This enum contains error codes for ::actor_system and its modules.
|
strong |
|
strong |
Terminal color and font face options.
T caf::actor_cast | ( | U && | what | ) |
Converts actor handle what
to a different actor handle or raw pointer of type T
.
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
.
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.
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.
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.
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.
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.
span<T> caf::make_span | ( | T * | first, |
size_t | size | ||
) |
Convenience function to make using caf::span
more convenient without the deduction guides.
span<T> caf::make_span | ( | T * | first, |
T * | last | ||
) |
Convenience function to make using caf::span
more convenient without the deduction guides.
timestamp caf::make_timestamp | ( | ) |
Convenience function for returning a timestamp
representing the current system time.
config_value& caf::put | ( | settings & | dict, |
string_view | key, | ||
T && | value | ||
) |
Converts value
to a config_value
and assigns it to key
.
dict | Dictionary of key-value pairs. |
key | Human-readable nested keys in the form category.key . |
value | New value for given key . |
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.
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.
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).
xs | Dictionary of key-value pairs. |
key | Human-readable nested keys in the form category.key . |
value | New value for given key . |
constexpr bool caf::SumType | ( | ) |
Concept for checking whether T
supports the sum type API by specializing sum_type_access
.
constexpr bool caf::SumTypes | ( | ) |
Concept for checking whether all Ts
support the sum type API by specializing sum_type_access
.
constexpr deep_to_string_t caf::deep_to_string = deep_to_string_t{} |
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>
.
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.
|
static |
The number of built-in types.