►Ciox::popo::BaseClient< PortT, TriggerHandleT > | The BaseClient class contains the common implementation for the different clients |
►Ciox::popo::ClientImpl< Req, Res, BaseClientT > | The ClientImpl class implements the typed client API |
Ciox::popo::Client< Req, Res > | The Client class for the request-response messaging pattern in iceoryx |
►Ciox::popo::UntypedClientImpl< BaseClientT > | The UntypedClientImpl class implements the untyped client API |
Ciox::popo::UntypedClient | |
►Ciox::popo::BasePublisher< port_t > | The BasePublisher class contains the common implementation for the different publisher specializations |
►Ciox::popo::PublisherImpl< T, mepoo::NoUserHeader > | |
Ciox::popo::Publisher< T, H > | The Publisher class for the publish-subscribe messaging pattern in iceoryx |
Ciox::popo::PublisherImpl< T, H, BasePublisherType > | The PublisherImpl class implements the typed publisher API |
►Ciox::popo::UntypedPublisherImpl< BasePublisherType > | The UntypedPublisherImpl class implements the untyped publisher API |
Ciox::popo::UntypedPublisher | For the publish-subscribe messaging pattern in iceoryx |
►Ciox::popo::BaseServer< PortT, TriggerHandleT > | The BaseServer class contains the common implementation for the different server |
►Ciox::popo::ServerImpl< Req, Res, BaseServerT > | The ServerImpl class implements the typed server API |
Ciox::popo::Server< Req, Res > | The Server class for the request-response messaging pattern in iceoryx |
►Ciox::popo::UntypedServerImpl< BaseServerT > | The UntypedServerImpl class implements the untyped server API |
Ciox::popo::UntypedServer | |
►Ciox::popo::BaseSubscriber< port_t > | Base class for all types of subscriber |
►Ciox::popo::SubscriberImpl< T, mepoo::NoUserHeader > | |
Ciox::popo::Subscriber< T, H > | The Subscriber class for the publish-subscribe messaging pattern in iceoryx |
►Ciox::popo::SubscriberImpl< roudi::ServiceRegistry, mepoo::NoUserHeader > | |
Ciox::popo::Subscriber< roudi::ServiceRegistry > | |
Ciox::popo::SubscriberImpl< T, H, BaseSubscriberType > | The SubscriberImpl class implements the typed subscriber API |
►Ciox::popo::UntypedSubscriberImpl< BaseSubscriberType > | The UntypedSubscriberImpl class implements the untyped subscriber API |
Ciox::popo::UntypedSubscriber | For the publish-subscribe messaging pattern in iceoryx |
Ciox::gw::Channel< IceoryxTerminal, ExternalTerminal > | A data structure representing a channel between Iceoryx and an external system |
Ciox::mepoo::ChunkHeader | |
Ciox::popo::ChunkSender< T > | |
Ciox::mepoo::ChunkSettings | |
Ciox::capro::ServiceDescription::ClassHash | |
Ciox::popo::ClientOptions | This struct is used to configure the client |
Ciox::config::CmdLineArgs_t | |
►Ciox::config::CmdLineParser | |
Ciox::config::CmdLineParserConfigFileOption | |
►CConfigParts | |
Ciox::Config< mepoo::SegmentConfig, config::RouDiConfig > | |
Ciox::Config< ConfigParts > | |
Ciox::DefaultChunkDistributorConfig | |
Ciox::DefaultChunkQueueConfig | |
Ciox::roudi::DefaultRouDiMemory | |
Ciox::mepoo::MePooConfig::Entry | |
Ciox::popo::EventBasedTrigger_t | |
Ciox::popo::EventCallback< OriginType, ContextDataType > | |
►Ciox::gw::GatewayBase | Generic gateway for communication events |
Ciox::gw::GatewayGeneric< channel_t, gateway_t > | A reference generic gateway implementation |
Ciox::config::GatewayConfig | Generic configuration for gateways |
Ciox::gw::GatewayDiscovery< Impl_T > | Discover the gateway |
Ciox::roudi::IceOryxRouDiComponents | |
Ciox::popo::ListenerImpl< Capacity > | The Listener is a class which reacts to registered events by executing a corresponding callback concurrently. This is achieved via an encapsulated thread inside this class |
►Ciox::popo::ListenerImpl< MAX_NUMBER_OF_EVENTS_PER_LISTENER > | |
Ciox::popo::Listener | |
►Ciox::roudi::MemoryBlock | The MemoryBlock is a container for general purpose memory. It is used to request some memory from a MemoryProvider, which can be POSIX SHM, the stack or something completely different. To be able to use the container, some functions need to be implemented. For most use cases the GenericMemoryBlock can be used, which is a templated class and implements the most common case |
Ciox::roudi::GenericMemoryBlock< T > | The GenericMemoryBlock is an implementation of a MemoryBlock for a common use case |
Ciox::mepoo::MemoryInfo | Stores properties of the memory to be used when we distinguish between different types of memory on e.g. different devices with different characteristics |
►Ciox::roudi::MemoryProvider | This class creates memory which is requested by the MemoryBlocks. Once the memory is available, this is announced to the blocks, so that they can consume the memory for their needs. When the Memory is release, the blocks will also called to handle this appropriately, e.g. calling the destructor of the underlying type. This class is an interface with some default behavior and needs an implementation for real memory supply, e.g. a PosixShmMemoryProvider |
Ciox::roudi::PosixShmMemoryProvider | Creates the shared memory based on a provided configuration |
Ciox::roudi::MemPoolInfo | Struct for the storage of mempool usage information. This data container is used by the introstpection::MemPoolInfoContainer array to store information on all available memmpools |
Ciox::roudi::MemPoolIntrospectionInfo | Topic for the mempool introspection that a user can subscribe to |
Ciox::mepoo::MePooConfig | |
Ciox::runtime::Node | Class which represents a node |
Ciox::popo::NotificationAttorney | Class which allows accessing private methods to friends of NotificationAttorney. Used for example by the WaitSet. Implements the Client-Attorney Pattern |
Ciox::popo::NotificationCallback< OriginType, ContextDataType > | Struct describes a callback with a user defined type which can be attached to a WaitSet or a Listener |
Ciox::popo::NotificationInfo | NotificationInfo holds the state of a trigger like the pointer to the triggerOrigin, the notification id and the callback |
Ciox::mepoo::NoUserHeader | Helper struct to use as default template parameter when no user-header is used |
Ciox::helper::Optimize< ConfigParts > | |
Ciox::helper::Optimize< FinalArg > | |
Ciox::helper::Optimize< FirstArg, RemainderArgs... > | |
Ciox::runtime::PortConfigInfo | Stores information necessary to create the right type of port on RouDi side. Different types of ports are required if e.g. different types of shared memory are used (e.g. on GPU) |
►Ciox::roudi::PortData | Container for common port data which is related to the subscriber port as well as the publisher port |
Ciox::roudi::PublisherPortData | Container for publisher port introspection data |
Ciox::roudi::PortIntrospectionFieldTopic | Topic for the port introspection that a user can subscribe to |
Ciox::roudi::PortPool | |
Ciox::roudi::PortThroughputData | |
Ciox::roudi::PortThroughputIntrospectionFieldTopic | Topic for the port throughput that a user can subscribe to |
Ciox::runtime::PoshRuntime | The runtime that is needed for each application to communicate with the RouDi daemon |
►CPoshRuntimeImpl | |
Ciox::runtime::PoshRuntimeSingleProcess | |
Ciox::roudi::ProcessIntrospectionData | |
Ciox::roudi::ProcessIntrospectionFieldTopic | Topic for the process introspection that a user can subscribe to |
Ciox::popo::PublisherInterface< T, H > | |
►Ciox::popo::PublisherInterface< T, mepoo::NoUserHeader > | |
Ciox::popo::PublisherImpl< T, mepoo::NoUserHeader > | |
Ciox::popo::PublisherImpl< T, H, BasePublisherType > | The PublisherImpl class implements the typed publisher API |
Ciox::popo::PublisherOptions | This struct is used to configure the publisher |
►Ciox::roudi::RouDiApp | Base class for RouDi daemons |
Ciox::roudi::IceOryxRouDiApp | |
Ciox::config::RouDiConfig | |
►Ciox::roudi::RouDiConfigFileProvider | Base class for a config file provider |
Ciox::config::TomlRouDiConfigFileProvider | |
►Ciox::roudi::RouDiMemoryInterface | |
Ciox::roudi::IceOryxRouDiMemoryManager | |
Ciox::roudi::RouDiMemoryManager | |
►Ciox::popo::RpcBaseHeader | |
Ciox::popo::RequestHeader | |
Ciox::popo::ResponseHeader | |
Ciox::popo::RpcInterface< RpcType, SendErrorEnum > | |
►Ciox::popo::RpcInterface< Request< Req >, ClientSendError > | |
Ciox::popo::ClientImpl< Req, Res, BaseClientT > | The ClientImpl class implements the typed client API |
►Ciox::popo::RpcInterface< Response< Res >, ServerSendError > | |
Ciox::popo::ServerImpl< Req, Res, BaseServerT > | The ServerImpl class implements the typed server API |
Ciox::mepoo::SegmentConfig | |
Ciox::mepoo::SegmentConfig::SegmentEntry | |
Ciox::popo::ServerOptions | This struct is used to configure the server |
Ciox::capro::ServiceDescription | Class for the identification of a communication event including information on the service, the service instance and the event id. A class object can be serialized/deserialized, so it is possible to send the information e.g. over a IPC channel |
Ciox::runtime::ServiceDiscovery | |
Ciox::config::GatewayConfig::ServiceEntry | |
Ciox::helper::SetDefaults< ConfigParts > | |
Ciox::helper::SetDefaults< FinalArg > | |
Ciox::helper::SetDefaults< FirstArg, RemainderArgs... > | |
►CSmartChunk | |
Ciox::popo::Request< T > | The Request class is a mutable abstraction over types which are written to loaned shared memory. These requests are sent to the server via the iceoryx system |
Ciox::popo::Response< T > | The Response class is a mutable abstraction over types which are written to loaned shared memory. These responses are sent to the client via the iceoryx system |
Ciox::popo::Sample< T, H > | The Sample class is a mutable abstraction over types which are written to loaned shared memory. These samples are publishable to the iceoryx system |
Ciox::popo::StateBasedTrigger_t | |
Ciox::popo::SubscriberOptions | This struct is used to configure the subscriber |
Ciox::roudi::SubscriberPortChangingData | |
Ciox::roudi::SubscriberPortChangingIntrospectionFieldTopic | |
Ciox::config::TomlGatewayConfigParser | Methods for parsing gateway configs from toml text files |
Ciox::popo::Trigger | Usually managed by a factory class like a WaitSet and acquired by classes which would like to signal a notification. Multiple Trigger can share a common ConditionVariableData pointer so that multiple Trigger can signal a single instance |
Ciox::popo::TriggerHandle | TriggerHandle is threadsafe without restrictions in a single process. Not qualified for inter process usage. The TriggerHandle is generated by a Notifyable like the WaitSet and handed out to the user when they acquire a trigger. The TriggerHandle corresponds with an internal Trigger and is used to signal an event via the trigger method. When it goes out of scope it cleans up the corresponding trigger in the Notifyable |
Ciox::popo::UserTrigger | An event based trigger which can be used by the application developer directly. If you would like to trigger a WaitSet/Listener through an event of your class you should use the Trigger class |
Ciox::popo::Void | |
Ciox::popo::WaitSet< Capacity > | Logical disjunction of a certain number of Triggers |