PIpBusBackend.cpp

Go to the documentation of this file.

/***************************************
    Author: Jean Jacquemier & Thibaut Oprinsen
    Email: jean.jacquemier@lapp.in2p3.fr
    License: CeCILL-C
****************************************/
 
#include "PIpBusBackend.h"
#include "ipbrw.h"

PIpBusSocket::PIpBusSocket()
: p_uaSocket(nullptr)
{
 
}

PIpBusSocket::~PIpBusSocket()
{
        close();
}

bool PIpBusSocket::createClientSocket(const Param & extraParam){
        p_uaSocket = IpBusImpl::pipbus_createSocket(extraParam.connectionFilePath, extraParam.connectionId);
        return p_uaSocket != nullptr;
}

bool PIpBusSocket::createServerSocket(const Param & extraParam){
        return createClientSocket(extraParam);
}
 
bool PIpBusSocket::isConnected() const{
        return p_uaSocket != nullptr;
}

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

PIpBusBackend::PIpBusBackend()
{
 
}

PIpBusBackend::Param PIpBusBackend::client(std::string &connectionFilePath, std::string &connectionId){
        Param param;
        param.connectionFilePath = connectionFilePath;
        param.connectionId = connectionId;
        return param;
}

PIpBusBackend::Param PIpBusBackend::server(std::string &connectionFilePath, std::string &connectionId){
        return PIpBusBackend::client(connectionFilePath, connectionId);
}

bool PIpBusBackend::createClientSocket(PIpBusBackend::Socket & socket, const PSocketParam & socketParam, const Param & param){
        return socket.createClientSocket(param);
}

bool PIpBusBackend::createServerSocket(PIpBusBackend::Socket & socket, const PSocketParam & socketParam, const Param & param){
        return socket.createServerSocket(param);
}


// void PIpBusBackend::msgToMock(DataStreamMsg & mockMsg, const PIpBusBackend::Message & msg){
//      size_t dataSize(msg.size());
//      mockMsg.resize(dataSize);
//      memcpy(mockMsg.data(), msg.dataStreamMsg.data(), dataSize);
// }
 
void PIpBusBackend::msgToMock(DataStreamMsg & mockMsg, const PIpBusBackend::Message & msg){
    size_t dataSize(data_size(msg));
    mockMsg.resize(dataSize);
    DataStreamIter iter = (DataStreamIter)mockMsg.data();
    data_message_save(iter, msg);
}


// void PIpBusBackend::mockToMsg(PIpBusBackend::Message & msg, DataStreamMsg & mockMsg){
//      size_t dataSize(mockMsg.size());
//      msg.dataStreamMsg.resize(dataSize);
//      memcpy((void*)msg.dataStreamMsg.data(), mockMsg.data(), dataSize);
// }
 
void PIpBusBackend::mockToMsg(PIpBusBackend::Message & msg, DataStreamMsg & mockMsg){
    DataStreamIter iter = (DataStreamIter)mockMsg.data();
    data_message_load(iter, msg);
}

PSendStatus::PSendStatus PIpBusSocket::sendMsg(PIpBusSocket::Message & msg, PSendFlag::PSendFlag flag){
        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;
        }
}

PRecvStatus::PRecvStatus PIpBusSocket::recvMsg(PIpBusSocket::Message & msg, PRecvFlag::PRecvFlag flag){
        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;
        }
}