PhoenixSocket API bridge to IpBus backend. More...

#include <PIpBusBackend.h>

Collaboration diagram for PIpBusSocket:

Public Types
typedef UaMessage	Message
	Define the type of message used by the PAbstractSocketManager.

typedef PIpBusParam	Param
	Define the type of extra parameters which can be used to create a Socket.

Public Member Functions
void	close ()
	Close the socket.

bool	createClientSocket (const Param &extraParam)
	Create a client socket.

bool	createServerSocket (const Param &extraParam)
	Create a server socket.

bool	isConnected () const

	PIpBusSocket ()
	Default constructor of PIpBusSocket.

template<typename T>
PRecvStatus::PRecvStatus	recvData (T &data, PRecvFlag::PRecvFlag flag=PRecvFlag::BLOCK)
	Recieved data with the socket.

PRecvStatus::PRecvStatus	recvMsg (Message &msg, PRecvFlag::PRecvFlag flag=PRecvFlag::BLOCK)
	Receive a message from the given socket.

template<typename T>
PSendStatus::PSendStatus	sendData (const T &data, PSendFlag::PSendFlag flag=PSendFlag::BLOCK)
	Send data with the socket.

PSendStatus::PSendStatus	sendMsg (Message &msg, PSendFlag::PSendFlag flag=PSendFlag::BLOCK)

virtual	~PIpBusSocket ()
	Destructor of PIpBusSocket.

Private Attributes
IpBusImpl *	p_uaSocket
	UA socket.

Detailed Description

PhoenixSocket API bridge to IpBus backend.

Definition at line 28 of file PIpBusBackend.h.

Member Typedef Documentation

◆ Message

typedef UaMessage PIpBusSocket::Message

Define the type of message used by the PAbstractSocketManager.

Definition at line 31 of file PIpBusBackend.h.

◆ Param

typedef PIpBusParam PIpBusSocket::Param

Define the type of extra parameters which can be used to create a Socket.

Definition at line 33 of file PIpBusBackend.h.

Constructor & Destructor Documentation

◆ PIpBusSocket()

PIpBusSocket::PIpBusSocket ( )

Default constructor of PIpBusSocket.

Definition at line 11 of file PIpBusBackend.cpp.

: p_uaSocket(nullptr)
{
 
}

References p_uaSocket.

◆ ~PIpBusSocket()

PIpBusSocket::~PIpBusSocket ( )

virtual

Destructor of PIpBusSocket.

Definition at line 18 of file PIpBusBackend.cpp.

{
        close();
}

References close().

Here is the call graph for this function:

Member Function Documentation

◆ close()

void PIpBusSocket::close ( )

Close the socket.

Definition at line 47 of file PIpBusBackend.cpp.

                        {
        if(p_uaSocket != nullptr){
                p_uaSocket->close();
                p_uaSocket = nullptr;
        }
}

References p_uaSocket.

Referenced by ~PIpBusSocket().

Here is the caller graph for this function:

◆ createClientSocket()

bool PIpBusSocket::createClientSocket ( const Param & extraParam )

Create a client socket.

Parameters

[out] extraParam : extra customisable parameters for the creation of the socket

Returns: true if the socket has been created, false otherwise

Definition at line 28 of file PIpBusBackend.cpp.

                                                             {
        p_uaSocket = IpBusImpl::pipbus_createSocket(extraParam.connectionFilePath, extraParam.connectionId);
        return p_uaSocket != nullptr;
}

References PIpBusParam::connectionFilePath, PIpBusParam::connectionId, p_uaSocket, and IpBusImpl::pipbus_createSocket().

Referenced by PIpBusBackend::createClientSocket(), and createServerSocket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ createServerSocket()

bool PIpBusSocket::createServerSocket ( const Param & extraParam )

Create a server socket.

Parameters

[out] extraParam : extra customisable parameters for the creation of the socket

Returns: true if the socket has been created, false otherwise

Definition at line 38 of file PIpBusBackend.cpp.

                                                             {
        return createClientSocket(extraParam);
}

References createClientSocket().

Referenced by PIpBusBackend::createServerSocket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isConnected()

bool PIpBusSocket::isConnected ( ) const

Definition at line 42 of file PIpBusBackend.cpp.

                                    {
        return p_uaSocket != nullptr;
}

References p_uaSocket.

◆ recvData()

template<typename T>

PRecvStatus::PRecvStatus PIpBusSocket::recvData	(	T &	data,
		PRecvFlag::PRecvFlag	flag = PRecvFlag::BLOCK )

Recieved data with the socket.

Parameters

[out]	data	: data to be recieved with the socket
	flag	: recieving flag (BLOCK, NON_BLOCK)

Returns: status of the recv

Definition at line 71 of file PIpBusBackend_impl.h.

                                                                              {
        PRecvStatus::PRecvStatus recvStatus = PRecvStatus::OK;
        Message msg;
        recvStatus = recvMsg(msg, flag);
        if(recvStatus == PRecvStatus::OK){
                //If the message is empty we cannot initialise the given data, so, this is an error
                if(msg.size() != 0lu){
                        DataStreamIter iter = (DataStreamIter)msg.dataStreamMsg.data();
                        if(!data_message_load<T>(iter, data)){
                                return PRecvStatus::CANNOT_DESERIALIZE_DATA;
                        }
                }else{
                        return PRecvStatus::NO_MESSAGE_RECEIVED;
                }
        }
 
        return recvStatus;
}

References UaMessage::dataStreamMsg, recvMsg(), and UaMessage::size().

Here is the call graph for this function:

◆ recvMsg()

PRecvStatus::PRecvStatus PIpBusSocket::recvMsg	(	PIpBusSocket::Message &	msg,
		PRecvFlag::PRecvFlag	flag = PRecvFlag::BLOCK )

Receive a message from the given socket.

Parameters

msg	the message to be received.
flag	receive flag (BLOCK, NON_BLOCK)

Returns: RecvStatus indicating the result of the receive operation or throw an error. THE BEHAVIOR OF THIS FUNCTION NEEDS TO BE DISCUSSED TO KNOW WHAT KIND OF ERROR WE WANT TO RAISE

Definition at line 190 of file PIpBusBackend.cpp.

                                                                                              {
        if(p_uaSocket == nullptr){
                return PRecvStatus::BROKEN_SOCKET;
        }
 
        try {
                bool success = false;
                if(msg.sizeValue > 1){
                        success = p_uaSocket->readBlock(msg.nodeId, *msg.value.get(), msg.sizeValue);
                }
                else if(msg.sizeValue == 1){
                        uint32_t readValue = 0;
                        success = p_uaSocket->read(msg.nodeId, readValue);
                        if(success) {
                                msg.value.get()->clear();
                                msg.value.get()->push_back(readValue);
                        }
                }
                else {
                        // Invalid size (0)
                        return PRecvStatus::NO_MESSAGE_RECEIVED;
                }
                
                return success ? PRecvStatus::OK : PRecvStatus::BROKEN_BACKEND;
        }
        catch (const uhal::exception::ReadAccessDenied& e) {
                // Read access denied for this node
                return PRecvStatus::BROKEN_BACKEND;
        }
        catch (const uhal::exception::BulkTransferOnSingleRegister& e) {
                // Attempted block transfer on a single register
                return PRecvStatus::BROKEN_BACKEND;
        }
        catch (const uhal::exception::BulkTransferRequestedTooLarge& e) {
                // Block transfer too large
                return PRecvStatus::BROKEN_BACKEND;
        }
        catch (const uhal::exception::NoBranchFoundWithGivenUID& e) {
                // Node ID not found
                return PRecvStatus::BROKEN_BACKEND;
        }
        catch (const std::out_of_range& e) {
                // Out of range error accessing vector
                return PRecvStatus::CANNOT_DESERIALIZE_DATA;
        }
        catch (const std::bad_alloc& e) {
                // Memory allocation problem
                return PRecvStatus::BROKEN_BACKEND;
        }
        catch (...) {
                // Any other non-standard exception
                return PRecvStatus::BROKEN_BACKEND;
        }
}

References UaMessage::nodeId, p_uaSocket, UaMessage::sizeValue, and UaMessage::value.

Referenced by recvData().

Here is the caller graph for this function:

◆ sendData()

template<typename T>

PSendStatus::PSendStatus PIpBusSocket::sendData	(	const T &	data,
		PSendFlag::PSendFlag	flag = PSendFlag::BLOCK )

Send data with the socket.

Parameters

data	: data to be sent with the socket
flag	: sending flag (BLOCK, NON_BLOCK)

Returns: status of the send

Definition at line 53 of file PIpBusBackend_impl.h.

                                                                                    {
    size_t dataSize(data_size<T>(data));
        Message msg;
        msg.dataStreamMsg.resize(dataSize);
        DataStreamIter iter = (DataStreamIter)msg.dataStreamMsg.data();
        if(data_message_save<T>(iter, data)){                   //Save the message
                return sendMsg(msg, flag);
        }else{
                return PSendStatus::CANNOT_SERIALIZE_DATA;
        }
}

References UaMessage::dataStreamMsg, and sendMsg().

Here is the call graph for this function:

◆ sendMsg()

PSendStatus::PSendStatus PIpBusSocket::sendMsg	(	PIpBusSocket::Message &	msg,
		PSendFlag::PSendFlag	flag = PSendFlag::BLOCK )

Send a message on the given socket.

Parameters

msg	Message to be sent.
flag	Flags to be used for sending the message (BLOCK, NON_BLOCK, etc.).

Returns: PSendStatus indicating the result of the send operation. THE BEHVAIOR OF THIS FUNCTION NEEDS TO BE DISCUSSED TO KNOW WHAT KIND OF ERROR WE WANT TO RAISE

Definition at line 136 of file PIpBusBackend.cpp.

                                                                                              {
        if(p_uaSocket == nullptr){
                return PSendStatus::BROKEN_SOCKET;
        }
        try {
                bool success;
                if(msg.value.get()->size() > 1){
                        success = p_uaSocket->writeBlock(msg.nodeId, *msg.value.get());
                }
                else if(msg.value.get()->size() == 1){
                        success = p_uaSocket->write(msg.nodeId, msg.value.get()->at(0));
                }
                else {
                        // Empty value vector
                        return PSendStatus::CANNOT_SERIALIZE_DATA;
                }
                
                return success ? PSendStatus::OK : PSendStatus::BROKEN_BACKEND;
        }
        catch (const uhal::exception::WriteAccessDenied& e) {
                // Write access denied for this node
                return PSendStatus::BROKEN_BACKEND;
        }
        catch (const uhal::exception::BulkTransferOnSingleRegister& e) {
                // Attempted block transfer on a single register
                return PSendStatus::BROKEN_BACKEND;
        }
        catch (const uhal::exception::BulkTransferRequestedTooLarge& e) {
                // Block transfer too large
                return PSendStatus::BROKEN_BACKEND;
        }
        catch (const uhal::exception::NoBranchFoundWithGivenUID& e) {
                // Node ID not found
                return PSendStatus::BROKEN_BACKEND;
        }
        catch (const std::out_of_range& e) {
                // Out of range error accessing vector
                return PSendStatus::CANNOT_SERIALIZE_DATA;
        }
        catch (const std::bad_alloc& e) {
                // Memory allocation problem
                return PSendStatus::BROKEN_BACKEND;
        }
        catch (...) {
                // Any other non-standard exception
                return PSendStatus::BROKEN_BACKEND;
        }
}

References UaMessage::nodeId, p_uaSocket, and UaMessage::value.

Referenced by sendData().

Here is the caller graph for this function:

Member Data Documentation

◆ p_uaSocket

IpBusImpl* PIpBusSocket::p_uaSocket

private

UA socket.

Definition at line 54 of file PIpBusBackend.h.

Referenced by close(), createClientSocket(), isConnected(), PIpBusSocket(), recvMsg(), and sendMsg().

The documentation for this class was generated from the following files:

/builds/mockplatform/ipbusmock/src/PIpBusBackend.h
/builds/mockplatform/ipbusmock/src/PIpBusBackend.cpp
/builds/mockplatform/ipbusmock/src/PIpBusBackend_impl.h

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Message

◆ Param

Constructor & Destructor Documentation

◆ PIpBusSocket()

◆ ~PIpBusSocket()

Member Function Documentation

◆ close()

◆ createClientSocket()

◆ createServerSocket()

◆ isConnected()

◆ recvData()

◆ recvMsg()

◆ sendData()

◆ sendMsg()

Member Data Documentation

◆ p_uaSocket