PMockBackendFile.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 "PMockBackendFile.h"


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

PMockSocketFile::PMockSocketFile(){
        
}

PMockSocketFile::~PMockSocketFile(){
        
}


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


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


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


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


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


PRecvStatus::PRecvStatus PMockSocketFile::recvMsg(PMockSocketFile::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 received
                        return PRecvStatus::NO_MESSAGE_RECEIVED;
                }else{
                        return PRecvStatus::OK;
                }
        }
}


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

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

PMockBackendFile::PMockBackendFile(){}

PMockBackendFile::~PMockBackendFile(){}


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


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


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


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


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


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


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


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


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


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