|
Flow-IPC 1.0.2
Flow-IPC project: Public API.
|
| ▼Cipc::session::App | A description of an application in this ipc::session inter-process communication universe |
| Cipc::session::Client_app | An App that is used as a client in at least one client-server IPC split |
| Cipc::session::Server_app | An App that is used as a server in at least one client-server IPC split |
| Cipc::shm::stl::Arena_activator< Arena > | RAII-style class operating a stack-like notion of a the given thread's currently active SHM-aware Arena, so that Stateless_allocator knows which Arena is currently active w/r/t a given code context operating on a SHM-stored container instance |
| Cipc::shm::Arena_to_borrower_allocator_arena< Arena > | Implementation of Arena_to_borrower_allocator_arena_t |
| Cipc::shm::Arena_to_borrower_allocator_arena< classic::Pool_arena > | Implementation of Arena_to_borrower_allocator_arena_t for SHM-classic arenas |
| Cipc::session::shm::Arena_to_shm_session< Arena > | Implementation of Arena_to_shm_session_t |
| Cipc::session::shm::Arena_to_shm_session< ipc::shm::arena_lend::jemalloc::Ipc_arena > | Implementation of Arena_to_shm_session_t for SHM-jemalloc arenas |
| Cipc::session::shm::Arena_to_shm_session< ipc::shm::classic::Pool_arena > | Implementation of Arena_to_shm_session_t for SHM-classic arenas |
| Cipc::util::sync_io::Asio_waitable_native_handle | Useful if using the sync_io pattern within a user event loop built on boost.asio (optionally with flow.async help), an object of this class wraps a non-null Native_handle and allows one to use .async_wait() to perform event waiting on behalf of any sync_io-implementing ipc::transport or ipc::session object |
| Cipc::transport::Bipc_mq_handle | Implements the Persistent_mq_handle concept by thinly wrapping bipc::message_queue, which is boost.interprocess's persistent message queue API |
| Cipc::transport::Blob_receiver | A documentation-only concept defining the behavior of an object capable of reliably/in-order receiving of discrete messages, each containing a binary blob |
| Cipc::transport::sync_io::Blob_receiver | A documentation-only concept: what transport::Blob_receiver is to transport::Native_handle_receiver (namely a degenerate version thereof), this is to sync_io::Native_handle_receiver |
| Cipc::transport::Blob_sender | A documentation-only concept defining the behavior of an object capable of reliably/in-order sending of discrete messages, each containing a binary blob |
| Cipc::transport::sync_io::Blob_sender | A documentation-only concept: what transport::Blob_sender is to transport::Native_handle_sender (namely a degenerate version thereof), this is to sync_io::Native_handle_sender |
| ▼Cipc::transport::Blob_stream_mq_base< Persistent_mq_handle > | Base of Blob_stream_mq_sender and Blob_stream_mq_receiver containing certain static facilities, particularly for post-abort persistent resource cleanup |
| Cipc::transport::Blob_stream_mq_receiver< Persistent_mq_handle > | Implements Blob_receiver concept by using an adopted Persistent_mq_handle MQ handle to an MQ (message queue) of that type, such as a POSIX or bipc MQ |
| Cipc::transport::Blob_stream_mq_sender< Persistent_mq_handle > | Implements Blob_sender concept by using an adopted Persistent_mq_handle MQ handle to an MQ (message queue) of that type, such as a POSIX or bipc MQ |
| Cipc::transport::sync_io::Blob_stream_mq_receiver< Persistent_mq_handle > | Implements sync_io::Blob_receiver concept by using an adopted Persistent_mq_handle MQ handle to an MQ (message queue) of that type, such as a POSIX or bipc MQ |
| Cipc::transport::sync_io::Blob_stream_mq_sender< Persistent_mq_handle > | Implements sync_io::Blob_sender concept by using an adopted Persistent_mq_handle MQ handle to an MQ (message queue) of that type, such as a POSIX or bipc MQ |
| ▼Cipc::transport::struc::shm::Builder_base | Shm::Builder base that contains non-parameterized public items such as tag types and constants |
| Cipc::transport::struc::shm::Builder< Shm_arena > | Implements Struct_builder concept with maximal zero-copy perf by (1) storing the actual user-schema-controlled message using the SHM provider of choice, in SHM, and (2) straightforwardly allocating 1 segment in regular heap and placing the SHM handle there for transmission over IPC |
| Cipc::transport::struc::shm::Capnp_message_builder< Shm_arena > | A capnp::MessageBuilder used by shm::Builder: similar to a MallocMessageBuilder with the GROW_HEURISTICALLY alloc-strategy but allocating via a SHM provider (of template-arg-specific type) in SHM instead of the heap via malloc() |
| Cipc::transport::Channel< Blob_sender, Blob_receiver, Native_handle_sender, Native_handle_receiver > | Peer to a bundle of 1-2 full-duplex pipe(s), one for transmitting unstructured binary blobs; the other for transmitting native handle+blob combos; hence a Blob_sender + Blob_receiver, a Native_handle_sender + Native_handle_receiver, or both |
| Cipc::transport::struc::Channel< Channel_obj, Message_body, Struct_builder_config, Struct_reader_config > | Owning and wrapping a pre-connected transport::Channel peer (an endpoint of an established channel over which unstructured messages and optionally native handles can be transported), this template is the central pillar of the ipc::transport::struc (structured layer), capable of communicating structured capnp-schema-based messages (and native handles) |
| ▼Cipc::transport::Channel< Null_peer, Null_peer, std::conditional_t< SIO, sync_io::Native_socket_stream, Native_socket_stream >, std::conditional_t< SIO, sync_io::Native_socket_stream, Native_socket_stream > > | |
| Cipc::transport::Socket_stream_channel< SIO > | A Channel with a handles pipe only (no blobs pipe) that uses a Unix domain socket connection as the underlying transport for that pipe |
| ▼Cipc::transport::Channel< std::conditional_t< SIO, sync_io::Blob_stream_mq_sender< Persistent_mq_handle >, Blob_stream_mq_sender< Persistent_mq_handle > >, std::conditional_t< SIO, sync_io::Blob_stream_mq_receiver< Persistent_mq_handle >, Blob_stream_mq_receiver< Persistent_mq_handle > >, Null_peer, Null_peer > | |
| Cipc::transport::Mqs_channel< SIO, Persistent_mq_handle, Native_handle_sender, Native_handle_receiver > | A Channel with at least a blobs pipe consisting of two MQs of type Persistent_mq_handle (template arg 1); and possibly a handles pipe as governed by template args 2 and 3 which default to Null_peer (in which case the handles pipe is disabled) |
| ▼Cipc::transport::Channel< std::conditional_t< SIO, sync_io::Blob_stream_mq_sender< Persistent_mq_handle >, Blob_stream_mq_sender< Persistent_mq_handle > >, std::conditional_t< SIO, sync_io::Blob_stream_mq_receiver< Persistent_mq_handle >, Blob_stream_mq_receiver< Persistent_mq_handle > >, std::conditional_t< SIO, sync_io::Native_socket_stream, Native_socket_stream >, std::conditional_t< SIO, sync_io::Native_socket_stream, Native_socket_stream > > | |
| ▼Cipc::transport::Mqs_channel< SIO, Persistent_mq_handle, std::conditional_t< SIO, sync_io::Native_socket_stream, Native_socket_stream >, std::conditional_t< SIO, sync_io::Native_socket_stream, Native_socket_stream > > | |
| Cipc::transport::Mqs_socket_stream_channel< SIO, Persistent_mq_handle > | A Channel with a blobs pipe consisting of 2 MQs of type Persistent_mq_handle (template arg); and a handles pipe over a Unix domain socket connection |
| ▼Cipc::transport::Channel< std::conditional_t< SIO, sync_io::Native_socket_stream, Native_socket_stream >, std::conditional_t< SIO, sync_io::Native_socket_stream, Native_socket_stream >, Null_peer, Null_peer > | |
| Cipc::transport::Socket_stream_channel_of_blobs< SIO > | A Channel with a blobs pipe only (no handles pipe) that uses a Unix domain socket connection as the underlying transport for that pipe |
| ▼Cipc::transport::struc::Channel_base | Channel base that contains non-parameterized public items such as tag types and constants |
| Cipc::transport::struc::sync_io::Channel< Channel_obj, Message_body, Struct_builder_config, Struct_reader_config > | sync_io-pattern counterpart to async-I/O-pattern transport::struc::Channel |
| Cipc::session::sync_io::Client_session_adapter< Session > | sync_io-pattern counterpart to async-I/O-pattern session::Client_session types and all their SHM-aware variations (at least shm::classic::Client_session et al and shm::arena_lend::jemalloc::Client_session et al) |
| Cipc::transport::struc::Heap_fixed_builder::Config | Implements Struct_builder::Config sub-concept |
| Cipc::transport::struc::Heap_reader::Config | Implements Struct_reader::Config sub-concept |
| Cipc::transport::struc::shm::Builder< Shm_arena >::Config | Implements Struct_builder::Config sub-concept |
| Cipc::transport::struc::shm::Reader< Shm_arena >::Config | Implements Struct_reader::Config sub-concept |
| Cipc::transport::struc::Struct_builder::Config | Copy-ctible, copy-assignable, default-ctible type – informally, cheaply copyable and likely an aggregate struct – objects of which store data that Struct_builder main ctor knows how to interpret as knobs controlling its behavior |
| Cipc::transport::struc::Struct_reader::Config | Analogous to Struct_builder::Config but for deserialization |
| Cipc::util::Default_init_allocator< T, Allocator > | Allocator adaptor (useful for, e.g., vector that skips zero-filling) that turns a value-initialization T() into a default-initialization for those types, namely PoDs, for which default-initialization is a no-op |
| Cipc::transport::struc::Heap_fixed_builder | Implements Struct_builder concept by straightforwardly allocating fixed-size segments on-demand in the regular heap and serializing directly inside those segments |
| Cipc::transport::struc::Heap_fixed_builder_capnp_message_builder | A capnp::MessageBuilder used by Heap_fixed_builder: similar to a capnp::MallocMessageBuilder with the FIXED_SIZE alloc-strategy but with framing space around the allocated segment(s) |
| Cipc::transport::struc::Heap_reader | Implements Struct_reader concept by straightforwardly interpreting a serialization by Heap_fixed_builder or any other builder that produces segments directly readable via SegmentArrayMessageReader |
| Cboost::system::is_error_code_enum<::ipc::session::error::Code > | Ummm – it specializes this struct to – look – the end result is boost.system uses this as authorization to make enum Code convertible to Error_code |
| Cboost::system::is_error_code_enum<::ipc::session::shm::arena_lend::jemalloc::error::Code > | Ummm – it specializes this struct to – look – the end result is boost.system uses this as authorization to make enum Code convertible to Error_code |
| Cboost::system::is_error_code_enum<::ipc::shm::classic::error::Code > | Ummm – it specializes this struct to – look – the end result is boost.system uses this as authorization to make enum Code convertible to Error_code |
| Cboost::system::is_error_code_enum<::ipc::transport::error::Code > | Ummm – it specializes this struct to – look – the end result is boost.system uses this as authorization to make enum Code convertible to Error_code |
| Cboost::system::is_error_code_enum<::ipc::transport::struc::error::Code > | Ummm – it specializes this struct to – look – the end result is boost.system uses this as authorization to make enum Code convertible to Error_code |
| Cboost::system::is_error_code_enum<::ipc::transport::struc::shm::error::Code > | Ummm – it specializes this struct to – look – the end result is boost.system uses this as authorization to make enum Code convertible to Error_code |
| Cipc::transport::struc::Msg_in< Message_body, Struct_reader_config > | A structured in-message instance suitable as received and emittable (to user) by struc::Channel |
| Cipc::transport::struc::Msg_out< Message_body, Struct_builder_t > | A structured out-message suitable to be sent via struc::Channel::send() (et al) |
| Cipc::util::Native_handle | A monolayer-thin wrapper around a native handle, a/k/a descriptor a/k/a FD |
| Cipc::transport::Native_handle_receiver | A documentation-only concept defining the behavior of an object capable of reliably/in-order receiving of discrete messages, each containing a native handle, a binary blob, or both |
| Cipc::transport::sync_io::Native_handle_receiver | A documentation-only concept defining the behavior of an object that is the sync_io-pattern counterpart of the async-I/O-pattern-following concept of the same name in our parent namespace: transport::Native_handle_receiver |
| Cipc::transport::Native_handle_sender | A documentation-only concept defining the behavior of an object capable of reliably/in-order sending of discrete messages, each containing a native handle, a binary blob, or both |
| Cipc::transport::sync_io::Native_handle_sender | A documentation-only concept defining the behavior of an object that is the sync_io-pattern counterpart of the async-I/O-pattern-following concept of the same name in our parent namespace: transport::Native_handle_sender |
| Cipc::transport::Native_socket_stream | Implements both Native_handle_sender and Native_handle_receiver concepts by using a stream-oriented Unix domain socket, allowing high-performance but non-zero-copy transmission of discrete messages, each containing a native handle, a binary blob, or both |
| Cipc::transport::sync_io::Native_socket_stream | Implements both sync_io::Native_handle_sender and sync_io::Native_handle_receiver concepts by using a stream-oriented Unix domain socket, allowing high-performance but non-zero-copy transmission of discrete messages, each containing a native handle, a binary blob, or both |
| Cipc::transport::Native_socket_stream_acceptor | A server object that binds to a Shared_name and listens for incoming Native_socket_stream connect attempts to that name; and yields connected-peer sync_io::Native_socket_stream objects, one per counterpart opposing *_connect() |
| Cipc::transport::sync_io::Native_socket_stream_acceptor | sync_io-pattern counterpart to async-I/O-pattern transport::Native_socket_stream_acceptor |
| Cipc::transport::Null_peer | Dummy type for use as a template param to Channel when either the blobs pipe or handles pipe is disabled; as well as to mark a given peer object as not having a counterpart form: a sync_io object shall have its using Sync_io_obj = Null_peer and coversely for async-I/O guys and their Async_io_objs |
| Cipc::transport::struc::Null_session | Value for Struct_builder::Session when no extra information is needed when serializing Struct_builder for subsequent sending to another process |
| Cipc::transport::Persistent_mq_handle | A documentation-only concept defining the behavior of an object representing a light-weight handle to a message queue, capable of receiving/sending discrete messages in non-blocking/blocking/timed-blocking fashion, as well as some support for polling/waiting and interruptions thereof |
| Cipc::shm::classic::Pool_arena | A SHM-classic interface around a single SHM pool with allocation-algorithm services by boost.interprocess, as in bipc::managed_shared_memory, with symmetric read/write semantics, compatible with ipc::shm::stl STL-compliance and SHM-handle borrowing manually or via ipc::session |
| Cipc::transport::Posix_mq_handle | Implements the Persistent_mq_handle concept by wrapping the POSIX message queue API (see man mq_overview) |
| ▼Cipc::util::Process_credentials | A process's credentials (PID, UID, GID as of this writing) |
| Cipc::transport::asio_local_stream_socket::Opt_peer_process_credentials | Gettable (read-only) socket option for use with asio_local_stream_socket::Peer_socket .get_option() in order to get the connected opposing peer process's credentials (PID/UID/GID/etc.) |
| Cipc::transport::Protocol_negotiator | A simple state machine that, assuming the opposide side of a comm pathway uses an equivalent state machine, helps negotiate the protocol version to speak over that pathway, given each side being capable of speaking a range of protocol versions and reporting the highest such version to the other side |
| Cipc::transport::struc::shm::Reader< Shm_arena > | Implements Struct_reader concept by interpreting a serialization by shm::Builder with the same template params |
| Cipc::transport::struc::Channel< Channel_obj, Message_body, Struct_builder_config, Struct_reader_config >::Sync_op_state::Request_result | A successul result of sync_request() |
| Cipc::transport::struc::Channel_base::Serialize_via_app_shm | Similar to Serialize_via_session_shm but assumes per-app-scope SHM-arena (as opposed to per-session-scope) at compile time |
| Cipc::transport::struc::Channel_base::Serialize_via_heap | Tag type for ctor selection: Backing memory for serialization comes from fixed-size segment allocation(s) from regular heap (malloc()); and similarly for deserialization |
| Cipc::transport::struc::Channel_base::Serialize_via_session_shm | Tag type for ctor selection: Backing RAM for serialization comes from a given session::Session's SHM arena (of per-session scope) via exponential-growing-size segment allocation(s) |
| Cipc::session::sync_io::Server_session_adapter< Session > | sync_io-pattern counterpart to async-I/O-pattern session::Server_session types and all their SHM-aware variations (at least shm::classic::Server_session et al and shm::arena_lend::jemalloc::Server_session et al) |
| Cipc::session::Session< Mdt_payload > | A documentation-only concept defining the local side of an IPC conversation (session) with another entity (typically a separate process), also represented by a Session-implementing object, through which one can easily open IPC channels (ipc::transport::Channel), among other IPC features |
| Cipc::session::Session_mv< Session_impl_t > | Implements the Session concept when it is in PEER state |
| Cipc::session::shm::arena_lend::jemalloc::Session_mv< Session_t > | Implements the SHM-related API common to shm::arena_lend::jemalloc::Server_session and shm::arena_lend::jemalloc::Client_session |
| ▼Cipc::session::shm::classic::Session_mv< Session_t > | Implements the SHM-related API common to shm::classic::Server_session and shm::classic::Client_session |
| Cipc::session::shm::classic::Server_session< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | Identical to session::Server_session in every way, except that it makes available two SHM arenas, from the SHM-classic provider (ipc::shm::classic::Pool_arena), symmetrically accessible by the opposing side |
| ▼Cipc::session::Session_mv< Client_session_impl_t > | |
| Cipc::session::Client_session_mv< Client_session_impl_t > | Implements Session concept on the Client_app end: a Session_mv that first achieves PEER state by connecting to an opposing Session_server_mv via Client_session_mv::sync_connect() |
| ▼Cipc::session::Session_mv< Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > > | |
| ▼Cipc::session::Server_session_mv< Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > > | |
| ▼Cipc::session::shm::arena_lend::jemalloc::Session_mv< session::Server_session_mv< Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > > > | |
| Cipc::session::shm::arena_lend::jemalloc::Server_session< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | Identical to session::Server_session in every way, except that it makes available two SHM arenas, from the SHM-jemalloc provider (ipc::shm::arena_lend::jemalloc) |
| ▼Cipc::session::Session_mv< Server_session_impl_t > | |
| Cipc::session::Server_session_mv< Server_session_impl_t > | Implements Session concept on the Server_app end: a Session that is emitted in almost-PEER state by local Session_server accepting a connection by an opposing Client_session_mv::sync_connect() |
| Cipc::session::Session_server< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | To be instantiated typically once in a given process, an object of this type asynchronously listens for Client_app processes each of which wishes to establish a session with this server process; emits resulting Server_session objects locally |
| Cipc::session::shm::arena_lend::jemalloc::Session_server< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | This is to vanilla Session_server what shm::arena_lend::jemalloc::Server_session is to vanilla Server_session: it is the session-server type that starts SHM-enabled sessions with SHM-jemalloc provider (ipc::shm::arena_lend::jemalloc) |
| Cipc::session::shm::classic::Session_server< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | This is to vanilla Session_server what shm::classic::Server_session is to vanilla Server_session: it is the session-server type that starts SHM-enabled sessions with SHM-classic provider (ipc::shm::classic::Pool_arena) |
| Cipc::session::sync_io::Session_server_adapter< Session_server > | sync_io-pattern counterpart to async-I/O-pattern session::Session_server types and all their SHM-aware variations (at least shm::classic::Session_server and shm::arena_lend::jemalloc::Session_server) |
| Cipc::util::Shared_name | String-wrapping abstraction representing a name uniquely distinguishing a kernel-persistent entity from all others in the system, or a fragment of such a name |
| Cipc::shm::stl::Stateless_allocator< T, Arena > | Stateless allocator usable with STL-compliant containers to store (or merely read) them directly in SHM in a given SHM-aware Arena |
| Cipc::transport::struc::Struct_builder | A documentation-only concept defining the behavior of an object capable of zero-copy-serializing, similar to capnp::MessageBuilder but geared to transmission over pipe-like IPC transports |
| Cipc::transport::struc::Struct_reader | A documentation-only concept that is, conceptually, roughly what capnp::MessageReader is to capnp::MessageBuilder, to be used on an in-message serialized by a counterpart Struct_builder, having been transmitted over an IPC transmitter of blobs |
| Cipc::util::Use_counted_object | Simple counter that manually tracks utilization. It is not thread-safe |
1.9.4