iox::popo🔗
Namespaces🔗
| Name |
|---|
| iox::popo::internal |
Classes🔗
| Name | |
|---|---|
| class | iox::popo::ApplicationPort |
| struct | iox::popo::ApplicationPortData |
| class | iox::popo::BasePort this class is the base for all ports. it is constructed from a member pointer and is only movable. only movable rational: a port has only one member, a pointer to its data. if a port is copied then both ports would work on the same data even though these are two independent copies. this would case a weird shared state, race conditions and so on |
| struct | iox::popo::BasePortData Defines different base port data. |
| class | iox::popo::BasePublisher The BasePublisher class contains the common implementation for the different publisher specializations. |
| class | iox::popo::BaseSubscriber base class for all types of subscriber |
| class | iox::popo::ChunkDistributor The ChunkDistributor is the low layer building block to send SharedChunks to a dynamic number of ChunkQueus. Together with the ChunkQueuePusher, the ChunkDistributor builds the infrastructure to exchange memory chunks between different data producers and consumers that could be located in different processes. Besides a modifiable container of ChunkQueues to which a SharedChunk can be deliverd, it holds a configurable history of last sent chunks. This allows to provide a newly added queue a number of last chunks to start from. This is needed for functionality known as latched topic in ROS or field in ara::com. A ChunkDistributor is used to build elements of higher abstraction layers that also do memory managemet and provide an API towards the real user. |
| struct | iox::popo::ChunkDistributorData |
| struct | iox::popo::ChunkQueueData |
| class | iox::popo::ChunkQueuePopper The ChunkQueuePopper is the low layer building block to receive SharedChunks. It follows a first-in-first-out principle. Together with the ChunkDistributor and the ChunkQueuePusher, the ChunkQueuePopper builds the infrastructure to exchange memory chunks between different data producers and consumers that could be located in different processes. A ChunkQueuePopper is used to build elements of higher abstraction layers that also do memory managemet and provide an API towards the real user. |
| class | iox::popo::ChunkQueuePusher The ChunkQueuePusher is the low layer building block to push SharedChunks in a chunk queue. Together with the ChunkDistributor and ChunkQueuePopper the ChunkQueuePusher builds the infrastructure to exchange memory chunks between different data producers and consumers that could be located in different processes. A ChunkQueuePusher is the part of the chunk queue that is knwon by the ChunkDistributor. |
| class | iox::popo::ChunkReceiver The ChunkReceiver is a building block of the shared memory communication infrastructure. It extends the functionality of a ChunkQueuePopper with the abililty to pass chunks to the user side (user process). Together with the ChunkSender, they are the next abstraction layer on top of ChunkDistributor and ChunkQueuePopper. The ChunkRceiver holds the ownership of the SharedChunks and does a bookkeeping which chunks are currently passed to the user side. |
| struct | iox::popo::ChunkReceiverData |
| class | iox::popo::ChunkSender The ChunkSender is a building block of the shared memory communication infrastructure. It extends the functionality of a ChunkDistributor with the abililty to allocate and free memory chunks. For getting chunks of memory the MemoryManger is used. Together with the ChunkReceiver, they are the next abstraction layer on top of ChunkDistributor and ChunkQueuePopper. The ChunkSender holds the ownership of the SharedChunks and does a bookkeeping which chunks are currently passed to the user side. |
| struct | iox::popo::ChunkSenderData |
| struct | iox::popo::ClientChunkDistributorConfig |
| struct | iox::popo::ClientChunkQueueConfig |
| struct | iox::popo::ClientPortData |
| class | iox::popo::ClientPortRouDi The ClientPortRouDi provides the API for accessing a client port from the RouDi middleware daemon side. The client port is divided in the three parts ClientPortData, ClientPortRouDi and ClientPortUser. The ClientPortRouDi provides service discovery functionality that is based on CaPro messages. With this API the dynamic connections between clients and servers ports can be established. |
| class | iox::popo::ClientPortUser The ClientPortUser provides the API for accessing a client port from the user side. The client port is divided in the three parts ClientPortData, ClientPortRouDi and ClientPortUser. The ClientPortUser uses the functionality of a ChunkSender and ChunReceiver for sending requests and receiving responses. Additionally it provides the connect / disconnect API which controls whether the client port shall connect to the server. |
| class | iox::popo::ConditionListener ConditionListener allows one to wait using a shared memory condition variable. |
| class | iox::popo::ConditionNotifier ConditionNotifier can notifiy waiting threads and processes using a shared memory condition variable. |
| struct | iox::popo::ConditionVariableData |
| struct | iox::popo::EventBasedTrigger_t |
| struct | iox::popo::EventCallback |
| class | iox::popo::InterfacePort |
| struct | iox::popo::InterfacePortData |
| struct | iox::popo::InvalidId_t Struct to signal the constructor to create an invalid id. |
| class | iox::popo::Listener 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. |
| class | iox::popo::NotificationAttorney Class which allows accessing private methods to friends of NotificationAttorney. Used for example by the WaitSet. Implements the Client-Attorney Pattern. |
| struct | iox::popo::NotificationCallback the struct describes a callback with a user defined type which can be attached to a WaitSet or a Listener |
| struct | iox::popo::NotificationCallback< OriginType, internal::NoType_t > the struct describes a callback which can be attached to a WaitSet or a Listener |
| class | iox::popo::NotificationInfo NotificationInfo holds the state of a trigger like the pointer to the triggerOrigin, the notification id and the callback. |
| class | iox::popo::PublisherImpl |
| class | iox::popo::PublisherInterface The PublisherInterface class defines the publisher interface used by the Sample class to make it generic. This allows any publisher specialization to be stored as a reference by the Sample class. It is also needed to avoid circular dependencies between Sample and Publisher. |
| struct | iox::popo::PublisherOptions This struct is used to configure the publisher. |
| struct | iox::popo::PublisherPortData |
| class | iox::popo::PublisherPortRouDi The PublisherPortRouDi provides the API for accessing a publisher port from the RouDi middleware daemon side. The publisher port is divided in the three parts PublisherPortData, PublisherPortRouDi and PublisherPortUser. The PublisherPortRouDi provides service discovery functionality that is based on CaPro messages. With this API the dynamic connections between publisher and subscriber ports can be established. |
| class | iox::popo::PublisherPortUser The PublisherPortUser provides the API for accessing a publisher port from the user side. The publisher port is divided in the three parts PublisherPortData, PublisherPortRouDi and PublisherPortUser. The PublisherPortUser uses the functionality of a ChunkSender for sending shared memory chunks. Additionally it provides the offer / stopOffer API which controls whether the publisher port is discoverable for subscriber ports. |
| class | iox::popo::RequestHeader |
| class | iox::popo::ResponseHeader |
| class | iox::popo::RPCBaseHeader |
| class | iox::popo::Sample The Sample class is a mutable abstraction over types which are written to loaned shared memory. These samples are publishable to the iceoryx system. |
| struct | iox::popo::SampleDeleter The SampleDeleter struct is a custom deleter in functor form which releases loans to a sample's underlying memory chunk via the corresponding port.. Each port should create its own instance of this deleter struct. |
| struct | iox::popo::ServerChunkDistributorConfig |
| struct | iox::popo::ServerChunkQueueConfig |
| struct | iox::popo::ServerPortData |
| class | iox::popo::ServerPortRouDi The ServerPortRouDi provides the API for accessing a server port from the RouDi middleware daemon side. The server port is divided in the three parts ServerPortData, ServerPortRouDi and ServerPortUser. The ServerPortRouDi provides service discovery functionality that is based on CaPro messages. With this API the dynamic connections between clients and servers ports can be established. |
| class | iox::popo::ServerPortUser The ServerPortUser provides the API for accessing a server port from the user side. The server port is divided in the three parts ServerPortData, ServerPortRouDi and ServerPortUser. The ServerPortUser uses the functionality of a ChunkSender and ChunReceiver for receiving requests and sending responses. Additionally it provides the offer / stopOffer API which controls whether the server is discoverable for client ports. |
| class | iox::popo::SingleThreadedPolicy |
| struct | iox::popo::StateBasedTrigger_t |
| class | iox::popo::SubscriberImpl |
| struct | iox::popo::SubscriberOptions This struct is used to configure the subscriber. |
| struct | iox::popo::SubscriberPortData |
| class | iox::popo::SubscriberPortMultiProducer The SubscriberPortMultiProducer is the implementation of the SubscriberPortRouDi for a setup where subscribers can have multiple matching publishers. I.e. a n:m pub/sub deployment. The handling of CaPro messages is different for 1:m and n:m deployment. |
| class | iox::popo::SubscriberPortRouDi The SubscriberPortRouDi provides the API for accessing a subscriber port from the RouDi middleware daemon side. The subscriber port is divided in the sevaral parts like SubscriberPortData, SubscriberPortRouDi and SubscriberPortUser. The SubscriberPortRouDi provides service discovery functionality that is based on CaPro messages. With this API the dynamic connections between publisher and subscriber ports can be established. |
| class | iox::popo::SubscriberPortSingleProducer The SubscriberPortSingleProducer is the implementation of the SubscriberPortRouDi for a setup where subscriber is allowed to have only one matching publisher. I.e. a 1:m pub/sub deployment. The handling of CaPro messages is different for 1:m and n:m deployment. |
| class | iox::popo::SubscriberPortUser The SubscriberPortUser provides the API for accessing a subscriber port from the user side. The subscriber port is divided in the parts SubscriberPortData, SubscriberPortUser and different classes for RouDi side access. The SubscriberPortUser uses the functionality of a ChunkReceiver for receiving shared memory chunks. Additionally it provides the subscribe / unsubscribe API which controls whether the subscriber ports shall try to subscribe to matching publisher ports. |
| class | iox::popo::ThreadSafePolicy |
| class | iox::popo::Trigger The Trigger class is 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. |
| class | iox::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. |
| class | iox::popo::TypedUniqueId Unique ID depending on a type. If you would like to assign different types consistent unique ids use this class. Every types gets its own distinct set of ids starting with 0. If the types are the same the ids are the same. |
| class | iox::popo::UntypedPublisherImpl |
| class | iox::popo::UntypedSubscriberImpl |
| class | iox::popo::UsedChunkList This class is used to keep track of the chunks currently in use by the application. In case the application terminates while holding chunks, this list is used by RouDi to retain ownership of the chunks and prevent a chunk leak. In order to always be able to access the used chunks, neither a vector or list can be used, because these container could be corrupted when the application dies in the wrong moment. To be able to do the cleanup, RouDi needs to be able to access the list with the used chunk under all circumstances. This is achieved by storing the ChunkManagement pointer in an array which can always be accessed. Additionally, the type stored is this array must be less or equal to 64 bit in order to write it within one clock cycle to prevent torn writes, which would corrupt the list and could potentially crash RouDi. |
| class | iox::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. |
| class | iox::popo::Void |
| class | iox::popo::WaitSet Logical disjunction of a certain number of Triggers. |
Types🔗
Functions🔗
| Name | |
|---|---|
| template \<typename T > constexpr T |
min(const T left, const T right) |
| template \<typename OriginType ,typename ContextDataType > NotificationCallback< OriginType, ContextDataType > |
createNotificationCallback(void(&)(OriginType *const) callback) creates an NotificationCallback |
| template \<typename OriginType ,typename ContextDataType > NotificationCallback< OriginType, ContextDataType > |
createNotificationCallback(void(&)(OriginType const, ContextDataType const) callback, ContextDataType & userValue) creates an NotificationCallback with a user defined value |
Attributes🔗
| Name | |
|---|---|
| constexpr InvalidId_t | InvalidId |
| constexpr bool | IS_EVENT_ENUM contains true when T is an event based enum, otherwise false |
| constexpr bool | IS_STATE_ENUM contains true when T is a state based enum, otherwise false |
| constexpr StateBasedTrigger_t | StateBasedTrigger |
| constexpr EventBasedTrigger_t | EventBasedTrigger |
Types Documentation🔗
enum ChunkDistributorError🔗
| Enumerator | Value | Description |
|---|---|---|
| INVALID_STATE | ||
| QUEUE_CONTAINER_OVERFLOW | ||
| QUEUE_NOT_IN_CONTAINER |
enum ChunkReceiveResult🔗
| Enumerator | Value | Description |
|---|---|---|
| INVALID_STATE | ||
| TOO_MANY_CHUNKS_HELD_IN_PARALLEL | ||
| NO_CHUNK_AVAILABLE |
enum AllocationError🔗
| Enumerator | Value | Description |
|---|---|---|
| INVALID_STATE | ||
| RUNNING_OUT_OF_CHUNKS | ||
| TOO_MANY_CHUNKS_ALLOCATED_IN_PARALLEL | ||
| INVALID_PARAMETER_FOR_USER_PAYLOAD_OR_USER_HEADER |
enum SubscriberEvent🔗
| Enumerator | Value | Description |
|---|---|---|
| DATA_RECEIVED |
enum SubscriberState🔗
| Enumerator | Value | Description |
|---|---|---|
| HAS_DATA |
enum ListenerError🔗
| Enumerator | Value | Description |
|---|---|---|
| INVALID_STATE | ||
| LISTENER_FULL | ||
| EVENT_ALREADY_ATTACHED | ||
| EMPTY_INVALIDATION_CALLBACK |
enum SubscriberTooSlowPolicy🔗
| Enumerator | Value | Description |
|---|---|---|
| WAIT_FOR_SUBSCRIBER | ||
| DISCARD_OLDEST_DATA |
Used by publisher.
enum QueueFullPolicy🔗
| Enumerator | Value | Description |
|---|---|---|
| BLOCK_PUBLISHER | ||
| DISCARD_OLDEST_DATA |
Used by subscriber.
enum TriggerType🔗
| Enumerator | Value | Description |
|---|---|---|
| STATE_BASED | ||
| EVENT_BASED | ||
| INVALID |
enum WaitSetError🔗
| Enumerator | Value | Description |
|---|---|---|
| INVALID_STATE | ||
| WAIT_SET_FULL | ||
| ALREADY_ATTACHED |
using WaitSetIsConditionSatisfiedCallback🔗
using iox::popo::WaitSetIsConditionSatisfiedCallback = typedef cxx::ConstMethodCallback<bool>;
using ClientChunkQueueData_t🔗
using iox::popo::ClientChunkQueueData_t = typedef ChunkQueueData<ClientChunkQueueConfig, ThreadSafePolicy>;
using ServerChunkQueueData_t🔗
using iox::popo::ServerChunkQueueData_t = typedef ChunkQueueData<ServerChunkQueueConfig, ThreadSafePolicy>;
using ClientChunkDistributorData_t🔗
using iox::popo::ClientChunkDistributorData_t = typedef ChunkDistributorData<ClientChunkDistributorConfig, ThreadSafePolicy, ChunkQueuePusher<ServerChunkQueueData_t> >;
using ServerChunkDistributorData_t🔗
using iox::popo::ServerChunkDistributorData_t = typedef ChunkDistributorData<ServerChunkDistributorConfig, ThreadSafePolicy, ChunkQueuePusher<ClientChunkQueueData_t> >;
using ClientChunkReceiverData_t🔗
using iox::popo::ClientChunkReceiverData_t = typedef ChunkReceiverData<MAX_RESPONSES_PROCESSED_SIMULTANEOUSLY, ClientChunkQueueData_t>;
using ServerChunkReceiverData_t🔗
using iox::popo::ServerChunkReceiverData_t = typedef ChunkReceiverData<MAX_REQUESTS_PROCESSED_SIMULTANEOUSLY, ServerChunkQueueData_t>;
using ClientChunkSenderData_t🔗
using iox::popo::ClientChunkSenderData_t = typedef ChunkSenderData<MAX_REQUESTS_ALLOCATED_SIMULTANEOUSLY, ClientChunkDistributorData_t>;
using ServerChunkSenderData_t🔗
using iox::popo::ServerChunkSenderData_t = typedef ChunkSenderData<MAX_RESPONSES_ALLOCATED_SIMULTANEOUSLY, ServerChunkDistributorData_t>;
typedef uid_t🔗
typedef UniquePortId iox::popo::uid_t;
using StateEnumIdentifier🔗
using iox::popo::StateEnumIdentifier = typedef uint64_t;
used as underlying type it identifies an enum as a state based enum
using EventEnumIdentifier🔗
using iox::popo::EventEnumIdentifier = typedef int64_t;
used as underlying type it identifies an enum as an event based enum
using Publisher🔗
template <typename T ,
typename H =mepoo::NoUserHeader>
using iox::popo::Publisher = typedef PublisherImpl<T, H>;
using Subscriber🔗
template <typename T ,
typename H =mepoo::NoUserHeader>
using iox::popo::Subscriber = typedef SubscriberImpl<T, H>;
using UntypedPublisher🔗
using iox::popo::UntypedPublisher = typedef UntypedPublisherImpl<>;
using UntypedSubscriber🔗
using iox::popo::UntypedSubscriber = typedef UntypedSubscriberImpl<>;
Functions Documentation🔗
function min🔗
template <typename T >
constexpr T min(
const T left,
const T right
)
Todo: Add min() without reference to iox::algorithm?! C++11 needs a declaration for constexpr! Ex.: constexpr uint32_t DefaultChunkDistributorConfig::MAX_HISTORY_CAPACITY; This wouldn't be an issue in C++17.
function createNotificationCallback🔗
template <typename OriginType ,
typename ContextDataType >
inline NotificationCallback< OriginType, ContextDataType > createNotificationCallback(
void(&)(OriginType *const) callback
)
creates an NotificationCallback
Parameters:
- callback reference to a callback with the signature void(OriginType*)
Return: the callback stored inside of an NotificationCallback
function createNotificationCallback🔗
template <typename OriginType ,
typename ContextDataType >
inline NotificationCallback< OriginType, ContextDataType > createNotificationCallback(
void(&)(OriginType *const, ContextDataType *const) callback,
ContextDataType & userValue
)
creates an NotificationCallback with a user defined value
Parameters:
- callback reference to a callback with the signature void(OriginType, ContextDataType)
- userValue reference to a user defined value
Return: the callback and user value stored inside of an NotificationCallback
Attributes Documentation🔗
variable InvalidId🔗
constexpr InvalidId_t InvalidId = [InvalidId_t](/v1.0.3/API-reference/posh/Classes/structiox_1_1popo_1_1InvalidId__t/)();
variable IS_EVENT_ENUM🔗
constexpr bool IS_EVENT_ENUM =
std::is_enum<T>::value&& std::is_same<std::underlying_type_t<T>, EventEnumIdentifier>::value;
contains true when T is an event based enum, otherwise false
variable IS_STATE_ENUM🔗
constexpr bool IS_STATE_ENUM =
std::is_enum<T>::value&& std::is_same<std::underlying_type_t<T>, StateEnumIdentifier>::value;
contains true when T is a state based enum, otherwise false
variable StateBasedTrigger🔗
constexpr StateBasedTrigger_t StateBasedTrigger {};
variable EventBasedTrigger🔗
constexpr EventBasedTrigger_t EventBasedTrigger {};
Updated on 31 May 2022 at 15:29:16 CEST