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_loadMockSocket(const std::string & prefix, const std::string & host, size_t port, PVecMockMessage & vecMessage){
        std::stringstream socketFileName;
        socketFileName << prefix << host << "_" << port << ".pmockbackend";
        return data_load(socketFileName.str(), vecMessage);
}


bool phoenix_saveMockSocket(const std::string & prefix, const std::string & host, size_t port, const PVecMockMessage & vecMessage){
        std::stringstream socketFileName;
        socketFileName << prefix << host << "_" << port << ".pmockbackend";
        return data_save(socketFileName.str(), vecMessage);
}


template<>
bool checkValue<DataStreamType>(const std::string & testName, const std::vector<DataStreamType> & vecData, const std::vector<DataStreamType> & vecReferenceData){
        if(vecData.size() != vecReferenceData.size()){
                std::cout << "checkValue<DataStreamType> : "<<testName<<" => vecData.size(" << vecData.size() << ") !=  vecReferenceData.size("<<vecReferenceData.size()<<")" << std::endl;
                return false;
        }
        bool b(true);
        for(size_t i(0lu); i < vecData.size() && b; ++i){
                b &= vecData[i] == vecReferenceData[i];
                if(!b){
                        std::cout << "checkValue<DataStreamType> : "<<testName<<" => vecData["<<i<<"](" << (int)vecData[i] << ") !=  vecReferenceData["<<i<<"]("<<(int)vecReferenceData[i]<<")" << std::endl;
                }
        }
//      if(b){std::cout << "checkValue : "<<testName<<" => Ok"<<std::endl;}
//      else{std::cout << "checkValue : "<<testName<<" => WRONG!!!!"<<std::endl;}
        return b;
}

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 std::string & address, size_t port, const PMockParam & param){
        socket.eventIndex = 0lu;
        std::stringstream socketFileName;
        if(socket.param.mockPrefix != ""){
                socketFileName << socket.param.mockPrefix;
        }
        socketFileName << address << "_" << port << ".pmockbackend";
        socket.fileNameMessage = socketFileName.str();
        bool b(true);
        if(!socket.param.isMockRecord){        //If we are not in record mode, we load all the exchange
                b &= data_load(socket.fileNameMessage, socket.vecMessage);
                if(!b){
                        std::cerr << "PMockBackend::createClientSocket : cannot load file '"<<socket.fileNameMessage<<"'" << std::endl;
                }
        }
        return b;
}


bool PMockBackend::createServerSocket(PMockBackend::Socket & socket, const std::string & address, size_t port, const PMockParam & param){
        return createClientSocket(socket, address, port, param);
}


void PMockBackend::setMockPrefix(Socket & socket, const std::string & mockPrefix){
        socket.param.mockPrefix = mockPrefix;
}


void PMockBackend::setIsMockRecord(Socket & socket, bool isMockRecord){
        socket.param.isMockRecord = isMockRecord;
}
 


bool PMockBackend::send(PMockBackend::Socket & socket, const PMockBackend::Message & msg, PSendFlag::PSendFlag flag){
        bool b(true);
        if(socket.param.isMockRecord){ //If we record all events
                socket.vecMessage.push_back(msg);
        }else{
                if(socket.vecMessage.size() == 0lu){
                        std::cerr << "PMockBackend::send : empty vector of message" << std::endl;
                        return false;
                }
                //Let's pick the current message
                if(socket.eventIndex >= socket.vecMessage.size()){
                        socket.eventIndex = 0lu;      //Let's loop if all the events were used
                }
                //Let's check if the current message matches the message we are supposed to send
                std::stringstream strEvent;
                strEvent << socket.eventIndex;
                b &= checkValue("PMockBackend::send : event " + strEvent.str(), msg, socket.vecMessage[socket.eventIndex]);
        }
        ++socket.eventIndex;
        return b;
}


bool PMockBackend::recv(PMockBackend::Socket & socket, PMockBackend::Message & msg, PRecvFlag::PRecvFlag flag){
        if(socket.param.isMockRecord){ //If we record all events
                socket.vecMessage.push_back(msg);
        }else{
                if(socket.vecMessage.size() == 0lu){
                        std::cerr << "PMockBackend::recv : empty vector of message" << std::endl;
                        return false;
                }
                //Let's pick the current message
                if(socket.eventIndex >= socket.vecMessage.size()){
                        socket.eventIndex = 0lu;      //Let's loop if all the events were used
                }
                msg = socket.vecMessage[socket.eventIndex];
        }
        ++socket.eventIndex;
        return true;
}


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::close(PMockBackend::Socket & socket){
        if(socket.param.isMockRecord){
                data_save(socket.fileNameMessage, socket.vecMessage);
        }
}


bool PMockBackend::isConnected(const PMockBackend::Socket & socket){
        return true;
}


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);
}