Skip to content

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🔗

Name
enum ChunkDistributorError
enum ChunkReceiveResult
enum AllocationError
enum EventEnumIdentifier SubscriberEvent
enum StateEnumIdentifier SubscriberState
enum ListenerError
enum uint8_t SubscriberTooSlowPolicy { WAIT_FOR_SUBSCRIBER, DISCARD_OLDEST_DATA }
Used by publisher.
enum uint8_t QueueFullPolicy { BLOCK_PUBLISHER, DISCARD_OLDEST_DATA }
Used by subscriber.
enum TriggerType
enum uint8_t WaitSetError
using cxx::ConstMethodCallback< bool > WaitSetIsConditionSatisfiedCallback
using ChunkQueueData< ClientChunkQueueConfig, ThreadSafePolicy > ClientChunkQueueData_t
using ChunkQueueData< ServerChunkQueueConfig, ThreadSafePolicy > ServerChunkQueueData_t
using ChunkDistributorData< ClientChunkDistributorConfig, ThreadSafePolicy, ChunkQueuePusher< ServerChunkQueueData_t > > ClientChunkDistributorData_t
using ChunkDistributorData< ServerChunkDistributorConfig, ThreadSafePolicy, ChunkQueuePusher< ClientChunkQueueData_t > > ServerChunkDistributorData_t
using ChunkReceiverData< MAX_RESPONSES_PROCESSED_SIMULTANEOUSLY, ClientChunkQueueData_t > ClientChunkReceiverData_t
using ChunkReceiverData< MAX_REQUESTS_PROCESSED_SIMULTANEOUSLY, ServerChunkQueueData_t > ServerChunkReceiverData_t
using ChunkSenderData< MAX_REQUESTS_ALLOCATED_SIMULTANEOUSLY, ClientChunkDistributorData_t > ClientChunkSenderData_t
using ChunkSenderData< MAX_RESPONSES_ALLOCATED_SIMULTANEOUSLY, ServerChunkDistributorData_t > ServerChunkSenderData_t
typedef UniquePortId uid_t
using uint64_t StateEnumIdentifier
used as underlying type it identifies an enum as a state based enum
using int64_t EventEnumIdentifier
used as underlying type it identifies an enum as an event based enum
template \<typename T ,typename H =mepoo::NoUserHeader>
using PublisherImpl< T, H >
Publisher
template \<typename T ,typename H =mepoo::NoUserHeader>
using SubscriberImpl< T, H >
Subscriber
using UntypedPublisherImpl<> UntypedPublisher
using UntypedSubscriberImpl<> UntypedSubscriber

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.1/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 17 June 2021 at 11:15:27 CEST