| ►CAllocator | |
| 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::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::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::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::Blob_stream_mq_base< Mq > | |
| Cipc::transport::sync_io::Blob_stream_mq_receiver< Mq > | |
| Cipc::transport::sync_io::Blob_stream_mq_sender< Mq > | |
| ►Cipc::transport::Blob_stream_mq_base_impl< Persistent_mq_handle > | Internal implementation of Blob_stream_mq_base class template; and common utilities used by Blob_stream_mq_sender_impl and Blob_stream_mq_receiver_impl (static items only as of this writing) |
| Cipc::transport::Blob_stream_mq_receiver_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of Blob_stream_mq_receiver class template |
| Cipc::transport::Blob_stream_mq_sender_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of Blob_stream_mq_sender class template |
| Cipc::transport::sync_io::Blob_stream_mq_receiver_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of sync_io::Blob_stream_mq_receiver class template |
| Cipc::transport::sync_io::Blob_stream_mq_sender_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of sync_io::Blob_stream_mq_sender class template |
| ►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 |
| ►CCapnp_msg_builder_interface | |
| 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::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::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::Session_adapter< Session >::Channel_open_result | Set of result arg values from a successful passive-channel-open from a Session_obj invoking On_channel_func |
| Cipc::session::shm::arena_lend::jemalloc::Client_session_mv< Client_session_impl_t > | |
| Cipc::session::shm::classic::Client_session_mv< Client_session_impl_t > | |
| 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 |
| ►Cboost::asio::posix::descriptor | |
| 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 |
| ►Cboost::system::error_category | |
| Cipc::session::error::Category | The boost.system category for errors returned by the ipc::session module |
| Cipc::session::shm::arena_lend::jemalloc::error::Category | The boost.system category for errors returned by the ipc::session module |
| Cipc::shm::classic::error::Category | The boost.system category for errors returned by the ipc::shm module |
| Cipc::transport::error::Category | The boost.system category for errors returned by the ipc::transport module |
| Cipc::transport::struc::error::Category | The boost.system category for errors returned by the ipc::transport::struc module |
| Cipc::transport::struc::shm::error::Category | The boost.system category for errors returned by the ipc::transport::struc::shm module |
| Cipc::transport::struc::sync_io::Channel< Channel_obj, Message_body, Struct_builder_config, Struct_reader_config >::Expecting_response | Policy for how to act upon receiving a response in-message that indicates its originating out-message is the message associated with this object in Expecting_response_map |
| Cipc::shm::classic::Pool_arena::Handle_in_shm< T > | The data structure stored in SHM corresponding to an original construct()-returned Handle; exactly one of which exists per construct() call invoked from any Pool_arena connected to the underlying pool |
| 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 |
| ►Cflow::log::Log_context | |
| ►Cipc::session::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, session::schema::ShmType::JEMALLOC, true > | |
| ►Cipc::session::shm::arena_lend::jemalloc::Session_impl< session::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, session::schema::ShmType::JEMALLOC, true > > | |
| Cipc::session::shm::arena_lend::jemalloc::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | Core internally-used implementation of shm::arena_lend::jemalloc::Client_session: it is to the latter what its public super-class Client_session_impl is to Client_session |
| ►Cipc::session::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, schema::ShmType::CLASSIC > | |
| ►Cipc::session::shm::classic::Session_impl< session::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, schema::ShmType::CLASSIC > > | |
| Cipc::session::shm::classic::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | Core internally-used implementation of shm::classic::Client_session: it is to the latter what its public super-class Client_session_impl is to Client_session |
| ►Cipc::session::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, session::schema::ShmType::JEMALLOC, transport::struc::shm::Builder_base::S_MAX_SERIALIZATION_SEGMENT_SZ, true > | |
| ►Cipc::session::shm::arena_lend::jemalloc::Session_impl< session::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, session::schema::ShmType::JEMALLOC, transport::struc::shm::Builder_base::S_MAX_SERIALIZATION_SEGMENT_SZ, true > > | |
| Cipc::session::shm::arena_lend::jemalloc::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | Core internally-used implementation of shm::arena_lend::jemalloc::Server_session: it is to the latter what its public super-class Server_session_impl is to Server_session |
| ►Cipc::session::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, schema::ShmType::CLASSIC, transport::struc::shm::Builder_base::S_MAX_SERIALIZATION_SEGMENT_SZ > | |
| ►Cipc::session::shm::classic::Session_impl< session::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, schema::ShmType::CLASSIC, transport::struc::shm::Builder_base::S_MAX_SERIALIZATION_SEGMENT_SZ > > | |
| Cipc::session::shm::classic::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | Core internally-used implementation of shm::classic::Server_session: it is to the latter what its public super-class Server_session_impl is to Server_session |
| ►Cipc::session::Session_server_impl< Session_server< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload >, Server_session< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > > | |
| 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::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< 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::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::session::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, S_SHM_TYPE_OR_NONE, S_GRACEFUL_FINISH_REQUIRED_V > | Internal, non-movable pImpl-lite implementation of Client_session_mv class template |
| Cipc::session::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, S_SHM_TYPE_OR_NONE, S_SHM_MAX_HNDL_SZ, S_GRACEFUL_FINISH_REQUIRED_V > | Internal, non-movable pImpl-lite implementation of Server_session_mv class template |
| Cipc::session::Session_base< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload >::Graceful_finisher | Optional to use by subclasses, this operates a simple state machine that carries out a graceful-session-end handshake procedure |
| Cipc::session::Session_server_impl< Session_server_t, Server_session_t > | Internal class template comprising API/logic common to every Session_server variant, meant to be privately sub-classed and largely forwarded |
| 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::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_stream_mq_receiver_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of Blob_stream_mq_receiver class template |
| Cipc::transport::Blob_stream_mq_sender_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of Blob_stream_mq_sender class template |
| 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::Native_socket_stream::Impl | Internal, non-movable pImpl implementation of Native_socket_stream class |
| 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::Posix_mq_handle | Implements the Persistent_mq_handle concept by wrapping the POSIX message queue API (see man mq_overview) |
| 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::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::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_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 |
| 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::struc::shm::Reader< Shm_arena > | Implements Struct_reader concept by interpreting a serialization by shm::Builder with the same template params |
| 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::transport::sync_io::Async_adapter_receiver< Core_t > | Internal-use type that adapts a given PEER-state sync_io::Native_handle_receiver or sync_io::Blob_receiver core into the async-I/O-pattern Native_handle_receiver or Blob_receiver |
| Cipc::transport::sync_io::Async_adapter_sender< Core_t > | Internal-use type that adapts a given PEER-state sync_io::Native_handle_sender or sync_io::Blob_sender core into the async-I/O-pattern Native_handle_sender or Blob_sender |
| Cipc::transport::sync_io::Blob_stream_mq_receiver_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of sync_io::Blob_stream_mq_receiver class template |
| Cipc::transport::sync_io::Blob_stream_mq_sender_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of sync_io::Blob_stream_mq_sender class template |
| Cipc::transport::sync_io::Native_socket_stream::Impl | Internal, non-movable pImpl implementation of sync_io::Native_socket_stream class |
| Cipc::transport::sync_io::Native_socket_stream_acceptor | sync_io-pattern counterpart to async-I/O-pattern transport::Native_socket_stream_acceptor |
| Cipc::util::sync_io::Timer_event_emitter | An object of this type, used internally to implement sync_io-pattern objects that require timer events, starts a thread dedicated exclusively to running timer waits on the sync_io object's behalf, so that when such a timer fires, it emits a pipe-readable event to be detected by the user's event loop, which it then reports to sync_io object |
| Cipc::session::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, S_SHM_TYPE_OR_NONE, S_GRACEFUL_FINISH_REQUIRED_V >::Master_channel_req | An open-channel/log-in request out-message |
| Cipc::transport::struc::sync_io::Channel< Channel_obj, Message_body, Struct_builder_config, Struct_reader_config >::Msg_in_pipe | Data and policy with respect to receipt of the next/currently-incomplete in-message |
| 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::transport::struc::Msg_out< Message_body, Struct_builder > | |
| Cipc::transport::struc::Msg_out_impl< Message_body, Struct_builder > | Internally used (data-free) addendum on-top of Msg_out which makes the protected API public instead |
| ►Cipc::transport::struc::Msg_out< schema::detail::StructuredMessage, Struct_builder_config::Builder > | |
| Cipc::transport::struc::Msg_mdt_out< Struct_builder_config > | Internally used (data-free) addendum on-top of Msg_out; really an alias to Msg_out<schema::detail::StructuredMessage>, where the latter is the internal-use set of metadata schema, with a convenience public mutating API wrapping around capnp-generated mutator API for things like message ID |
| 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 |
| ►Cboost::noncopyable | |
| Cipc::session::Session_server_impl< Session_server< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload >, Server_session< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > > | |
| ►Cipc::session::Session_base< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload > | Internal type containing data and types common to internal types Server_session_impl and Client_session_impl which are the respective true cores of Server_session and Client_session respectively |
| Cipc::session::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, session::schema::ShmType::JEMALLOC, true > | |
| Cipc::session::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, schema::ShmType::CLASSIC > | |
| Cipc::session::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, session::schema::ShmType::JEMALLOC, transport::struc::shm::Builder_base::S_MAX_SERIALIZATION_SEGMENT_SZ, true > | |
| Cipc::session::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, schema::ShmType::CLASSIC, transport::struc::shm::Builder_base::S_MAX_SERIALIZATION_SEGMENT_SZ > | |
| Cipc::session::Client_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, S_SHM_TYPE_OR_NONE, S_GRACEFUL_FINISH_REQUIRED_V > | Internal, non-movable pImpl-lite implementation of Client_session_mv class template |
| Cipc::session::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, S_SHM_TYPE_OR_NONE, S_SHM_MAX_HNDL_SZ, S_GRACEFUL_FINISH_REQUIRED_V > | Internal, non-movable pImpl-lite implementation of Server_session_mv class template |
| Cipc::session::Session_base< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload >::Graceful_finisher | Optional to use by subclasses, this operates a simple state machine that carries out a graceful-session-end handshake procedure |
| Cipc::session::Session_server_impl< Session_server_t, Server_session_t > | Internal class template comprising API/logic common to every Session_server variant, meant to be privately sub-classed and largely forwarded |
| 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::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::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::Blob_stream_mq_receiver_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of Blob_stream_mq_receiver class template |
| Cipc::transport::Blob_stream_mq_sender_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of Blob_stream_mq_sender class template |
| Cipc::transport::Native_socket_stream::Impl | Internal, non-movable pImpl implementation of Native_socket_stream class |
| 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::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::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 |
| ►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_in_impl< Message_body, Struct_reader_config > | Internally used (data-free) addendum on-top of Msg_in which makes the protected API public instead |
| 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::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::transport::sync_io::Async_adapter_receiver< Core_t > | Internal-use type that adapts a given PEER-state sync_io::Native_handle_receiver or sync_io::Blob_receiver core into the async-I/O-pattern Native_handle_receiver or Blob_receiver |
| Cipc::transport::sync_io::Async_adapter_sender< Core_t > | Internal-use type that adapts a given PEER-state sync_io::Native_handle_sender or sync_io::Blob_sender core into the async-I/O-pattern Native_handle_sender or Blob_sender |
| Cipc::transport::sync_io::Blob_stream_mq_receiver_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of sync_io::Blob_stream_mq_receiver class template |
| Cipc::transport::sync_io::Blob_stream_mq_sender_impl< Persistent_mq_handle > | Internal, non-movable pImpl-lite implementation of sync_io::Blob_stream_mq_sender class template |
| Cipc::transport::sync_io::Native_socket_stream::Impl | Internal, non-movable pImpl implementation of sync_io::Native_socket_stream class |
| Cipc::transport::sync_io::Native_socket_stream_acceptor | sync_io-pattern counterpart to async-I/O-pattern transport::Native_socket_stream_acceptor |
| Cipc::util::sync_io::Timer_event_emitter | An object of this type, used internally to implement sync_io-pattern objects that require timer events, starts a thread dedicated exclusively to running timer waits on the sync_io object's behalf, so that when such a timer fires, it emits a pipe-readable event to be detected by the user's event loop, which it then reports to sync_io object |
| 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::session::Server_session_impl< S_MQ_TYPE_OR_NONE, S_TRANSMIT_NATIVE_HANDLES, Mdt_payload, S_SHM_TYPE_OR_NONE, S_SHM_MAX_HNDL_SZ, S_GRACEFUL_FINISH_REQUIRED_V >::Open_channel_req | An open-channel request out-message |
| 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::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::sync_io::Native_socket_stream::Impl::Rcv_user_request | Identical to sync_io::Async_adapter_receiver::User_request, except we only keep at most 1 of these and thus don't need a Ptr alias inside |
| 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() |
| ►Cflow::util::Scoped_setter | |
| 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::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::shm::arena_lend::jemalloc::Server_session_mv< Server_session_impl_t > | |
| Cipc::session::shm::classic::Server_session_mv< Server_session_impl_t > | |
| ►CServer_session_t | |
| Cipc::session::Server_session_dtl< Server_session_t > | This is the data-less sub-class of Server_session or any more-advanced (e.g., SHM-capable) variant thereof that exposes protected APIs hidden from public user by providing public access to them; this is used internally by Session_server |
| 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::sync_io::Session_adapter< Session > | Internal-use workhorse containing common elements of Client_session_adapter and Server_session_adapter |
| 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::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) |
| ►CSession_impl_t | |
| Cipc::session::shm::arena_lend::jemalloc::Session_impl< Session_impl_t > | Common data and logic for shm::arena_lend::jemalloc::Server_session_impl and shm::arena_lend::jemalloc::Client_session_impl |
| Cipc::session::shm::classic::Session_impl< Session_impl_t > | Common data and logic for shm::classic::Server_session_impl and shm::classic::Client_session_impl |
| Cipc::session::Session_mv< Session_impl_t > | Implements the Session concept when it is in PEER state |
| ►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 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::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) |
| ►CSession_t | |
| 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::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::transport::sync_io::Blob_stream_mq_sender_impl< Persistent_mq_handle >::Snd_low_lvl_payload | Data store representing a payload corresponding to exactly one attempted async write-op, albeit used if and only if we encounter would-block in send_blob() or on_ev_auto_ping_now_timer_fired() or *end_sending() and have to queue (and therefore one-time-copy) data in m_pending_payloads_q |
| Cipc::transport::sync_io::Native_socket_stream::Impl::Snd_low_lvl_payload | Data store representing a payload corresponding to exactly one attempted async write-op, albeit used if and only if we encounter would-block in send_*() or snd_on_ev_auto_ping_now_timer_fired() or *end_sending() and have to queue (and therefore one-time-copy) data in m_snd_pending_payloads_q |
| Cipc::session::Session_server_impl< Session_server_t, Server_session_t >::State | All internal mutable state of Session_server_impl |
| 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::transport::struc::Channel< Channel_obj, Message_body, Struct_builder_config, Struct_reader_config >::Sync_op_state | State in m_sync_op_state, when a sync-op is in fact in progress, meaning m_sync_op_state is not null |
| Cipc::util::Use_counted_object | Simple counter that manually tracks utilization. It is not thread-safe |
| Cipc::transport::Native_socket_stream_acceptor::User_request | Data store representing a deficit user async-accept request that had to be saved due to lacking surplus of finalized peer socket handles |
| Cipc::transport::sync_io::Async_adapter_receiver< Core_t >::User_request | Data store representing a deficit user async-receive request: either one being currently handled by m_sync_io – which can handle one m_sync_io.async_receive_*() at a time, no more – or one queued up behind it, if async_receive_*() was called before the current one could complete |
| Cipc::transport::sync_io::Blob_stream_mq_receiver_impl< Persistent_mq_handle >::User_request | Identical to sync_io::Async_adapter_receiver::User_request, except we only keep at most 1 of these and thus don't need a Ptr alias inside; and we need not worry about transmitting Native_handles |
| CBuilder | |
| CFunction< void()> | |
