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"
 
 
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(const std::string & address, size_t port, bool isMockRecord, const std::string & mockDirectory){
        PMockBackend::Param param;
        param.address = address;
        param.port = port;
        param.isMockRecord = isMockRecord;
        param.mockDirectory = mockDirectory;
        return param;
}
 
 
PMockBackend::Param PMockBackend::server(const std::string & address, size_t port, bool isMockRecord, const std::string & mockDirectory){
        return PMockBackend::client(address, port, isMockRecord, mockDirectory);
}
 
 
bool PMockBackend::createClientSocket(PMockBackend::Socket & socket, const PMockParam & param){
        socket.param = param;
        socket.eventIndex = 0lu;
        std::stringstream socketFileName;
        if(param.mockDirectory != ""){
                socketFileName << param.mockDirectory << "/";
        }
        socketFileName << param.address << "_" << param.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 PMockParam & param){
        return createClientSocket(socket, param);
}
 
 
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);
}