PMockBackend.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <sstream>
 
#include "data_stream_check_value.h"
#include "PMockBackend.h"


bool phoenix_createMockBackend(PMockSocket & mock, const PSocketParam & socketParam, const std::string & prefix, const PMockParam & extraParam){
        mock.setIsMockRecord(true);
        bool b = mock.createClientSocket(socketParam, extraParam);
        mock.setMockPrefix(prefix);
        return b;
}

PMockSocket::PMockSocket(){
        
}

PMockSocket::~PMockSocket(){
        
}


bool PMockSocket::createClientSocket(const PSocketParam & socketParam, const PMockBackend::Param & extraParam){
        p_socketParam = socketParam;
        p_extraParam = extraParam;
        
        return true;
}


bool PMockSocket::createServerSocket(const PSocketParam & socketParam, const PMockBackend::Param & extraParam){
        return createClientSocket(socketParam, extraParam);
}


void PMockSocket::setMockPrefix(const std::string & mockPrefix){
        std::stringstream socketFileName;
        socketFileName << mockPrefix << p_socketParam.hostname << "_" << p_socketParam.port << ".pmockbackend";
        p_mock.setFileName(socketFileName.str());
}


void PMockSocket::setIsMockRecord(bool isMockRecord){
        p_mock.setIsRecord(isMockRecord);
}


PSendStatus::PSendStatus PMockSocket::sendMsg(const PMockBackend::Message & msg, PSendFlag::PSendFlag flag){
        if(p_mock.getIsRecord()){
                p_mock.append(msg);
        }else{
                check_stream_assert(p_mock.checkCurrentValue("PMockSocket::sendMsg", msg));
        }
        return PSendStatus::OK;
}


PRecvStatus::PRecvStatus PMockSocket::recvMsg(PMockBackend::Message & msg, PRecvFlag::PRecvFlag flag){
        if(p_mock.getIsRecord()){
                p_mock.append(msg);
                return PRecvStatus::OK;
        }else{
                p_mock.getCurrentValue(msg);
                if(msg.size() == 0lu){  //If the message is empty, it is not recieved
                        return PRecvStatus::NO_MESSAGE_RECEIVED;
                }else{
                        return PRecvStatus::OK;
                }
        }
}


bool PMockSocket::isConnected() const{
        return true;
}

void PMockSocket::close(){
        p_mock.close();
}
 
 

PMockBackend::PMockBackend(){
        
}


PMockBackend::Param PMockBackend::client(){
        PMockBackend::Param param;
        return param;
}


PMockBackend::Param PMockBackend::server(){
        return PMockBackend::client();
}


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


bool PMockBackend::createServerSocket(PMockBackend::Socket & socket, const PSocketParam & socketParam, const PMockParam & param){
        return createClientSocket(socket, socketParam, param);
}


void PMockBackend::msgResize(PMockBackend::Message & msg, size_t sizeMsg){
        msg.resize(sizeMsg);
}


size_t PMockBackend::msgSize(const PMockBackend::Message & msg){
        return msg.size();
}


const DataStreamIter PMockBackend::msgData(const PMockBackend::Message & msg){
        return (const DataStreamIter)msg.data();
}


DataStreamIter PMockBackend::msgData(PMockBackend::Message & msg){
        return msg.data();
}


void PMockBackend::msgToMock(DataStreamMsg & mockMsg, const PMockBackend::Message & msg){
        size_t dataSize(PMockBackend::msgSize(msg));
        mockMsg.resize(dataSize);
        memcpy(mockMsg.data(), PMockBackend::msgData(msg), dataSize);
}


void PMockBackend::mockToMsg(PMockBackend::Message & msg, DataStreamMsg & mockMsg){
        size_t dataSize(mockMsg.size());
        PMockBackend::msgResize(msg, dataSize);
        memcpy(PMockBackend::msgData(msg), mockMsg.data(), dataSize);
}