Skip to content

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.

#include <client_port_user.hpp>

Inherits from iox::popo::BasePort

Public Types🔗

Name
using ClientPortData MemberType_t

Public Functions🔗

Name
ClientPortUser(cxx::not_null< MemberType_t *const > clientPortDataPtr)
ClientPortUser(const ClientPortUser & other)
ClientPortUser & operator=(const ClientPortUser & )
ClientPortUser(ClientPortUser && rhs) =default
ClientPortUser & operator=(ClientPortUser && rhs) =default
~ClientPortUser() =default
cxx::expected< RequestHeader *, AllocationError > allocateRequest(const uint32_t userPayloadSize)
Allocate a chunk, the ownerhip of the SharedChunk remains in the ClientPortUser for being able to cleanup if the user process disappears.
void freeRequest(RequestHeader *const requestHeader)
Free an allocated request without sending it.
void sendRequest(RequestHeader *const requestHeader)
Send an allocated request chunk to the server port.
void connect()
try to connect to the server Caution: There can be delays between calling connect and a change in the connection state
void disconnect()
disconnect from the server
ConnectionState getConnectionState() const
get the current connection state. Caution: There can be delays between calling connect and a change in the connection state. The connection state can also change without user interaction if the server comes and goes
cxx::expected< cxx::optional< const ResponseHeader * >, ChunkReceiveResult > getResponse()
Tries to get the next response from the queue. If there is a new one, the ChunkHeader of the oldest response in the queue is returned (FiFo queue)
void releaseResponse(const ResponseHeader *const responseHeader)
Release a response that was obtained with getResponseChunk.
bool hasNewResponses() const
check if there are responses in the queue
bool hasLostResponsesSinceLastCall()
check if there was a queue overflow since the last call of hasLostResponseChunks
void setConditionVariable(ConditionVariableData & conditionVariableData, const uint64_t notificationIndex)
set a condition variable (via its pointer) to the client
void unsetConditionVariable()
unset a condition variable from the client
bool isConditionVariableSet() const
check if there's a condition variable set

Additional inherited members🔗

Public Functions inherited from iox::popo::BasePort

Name
BasePort(MemberType_t *const basePortDataPtr)
BasePort(const BasePort & other)
BasePort(BasePort && )
virtual ~BasePort() =default
operator bool() const
a port can be constructed from a nullptr, additionally it also can be moved and in these cases the member methods would work on a nullptr. to circumvent this problem
capro::ServiceDescription getCaProServiceDescription() const
Reads Type of actual CaPro Port (publisher/subscriber...)
RuntimeName_t getRuntimeName() const
Gets name of the application's runtime for the active port.
UniquePortId getUniqueID() const
Gets Id of the active port.
NodeName_t getNodeName() const
returns node name for the active port
void destroy()
Indicate that this port can be destroyed.
bool toBeDestroyed() const
Checks whether port can be destroyed.

Public Types Documentation🔗

using MemberType_t🔗

using iox::popo::ClientPortUser::MemberType_t =  ClientPortData;

Public Functions Documentation🔗

function ClientPortUser🔗

explicit ClientPortUser(
    cxx::not_null< MemberType_t *const > clientPortDataPtr
)

function ClientPortUser🔗

ClientPortUser(
    const ClientPortUser & other
)

function operator=🔗

ClientPortUser & operator=(
    const ClientPortUser & 
)

function ClientPortUser🔗

ClientPortUser(
    ClientPortUser && rhs
) =default

function operator=🔗

ClientPortUser & operator=(
    ClientPortUser && rhs
) =default

function ~ClientPortUser🔗

~ClientPortUser() =default

function allocateRequest🔗

cxx::expected< RequestHeader *, AllocationError > allocateRequest(
    const uint32_t userPayloadSize
)

Allocate a chunk, the ownerhip of the SharedChunk remains in the ClientPortUser for being able to cleanup if the user process disappears.

Parameters:

  • userPayloadSizesize of the user-paylaod without additional headers

Return: on success pointer to a ChunkHeader which can be used to access the chunk-header, user-header and user-payload fields, error if not

function freeRequest🔗

void freeRequest(
    RequestHeader *const requestHeader
)

Free an allocated request without sending it.

Parameters:

  • chunkHeaderpointer to the ChunkHeader to free

function sendRequest🔗

void sendRequest(
    RequestHeader *const requestHeader
)

Send an allocated request chunk to the server port.

Parameters:

  • chunkHeaderpointer to the ChunkHeader to send

function connect🔗

void connect()

try to connect to the server Caution: There can be delays between calling connect and a change in the connection state

myPort.connect();
while(myPort.getConnectionState() != ConnectionState::CONNECTED)
    sleep(1_s);

function disconnect🔗

void disconnect()

disconnect from the server

function getConnectionState🔗

ConnectionState getConnectionState() const

get the current connection state. Caution: There can be delays between calling connect and a change in the connection state. The connection state can also change without user interaction if the server comes and goes

Return: ConnectionState

function getResponse🔗

cxx::expected< cxx::optional< const ResponseHeader * >, ChunkReceiveResult > getResponse()

Tries to get the next response from the queue. If there is a new one, the ChunkHeader of the oldest response in the queue is returned (FiFo queue)

Return: optional that has a new chunk header or no value if there are no new responses in the underlying queue, ChunkReceiveResult on error

function releaseResponse🔗

void releaseResponse(
    const ResponseHeader *const responseHeader
)

Release a response that was obtained with getResponseChunk.

Parameters:

  • chunkHeaderpointer to the ChunkHeader to release

function hasNewResponses🔗

bool hasNewResponses() const

check if there are responses in the queue

Return: if there are responses in the queue return true, otherwise false

function hasLostResponsesSinceLastCall🔗

bool hasLostResponsesSinceLastCall()

check if there was a queue overflow since the last call of hasLostResponseChunks

Return: true if the underlying queue overflowed since last call of this method, otherwise false

function setConditionVariable🔗

void setConditionVariable(
    ConditionVariableData & conditionVariableData,
    const uint64_t notificationIndex
)

set a condition variable (via its pointer) to the client

function unsetConditionVariable🔗

void unsetConditionVariable()

unset a condition variable from the client

function isConditionVariableSet🔗

bool isConditionVariableSet() const

check if there's a condition variable set

Return: true if a condition variable attached, otherwise false


Updated on 17 June 2021 at 11:15:27 CEST