PGenericSocket_impl.h

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#ifndef __PGENERIC_SOCKET_H_IMPL__
#define __PGENERIC_SOCKET_H_IMPL__
 
#include "PGenericSocket.h"


template<typename _TBackend, typename _TMockBackend>
PGenericSocket<_TBackend, _TMockBackend>::PGenericSocket(PSocketMode::PSocketMode mode){
        initialisationPGenericSocket(mode);
}

template<typename _TBackend, typename _TMockBackend>
PGenericSocket<_TBackend, _TMockBackend>::~PGenericSocket(){
        close();
}


template<typename _TBackend, typename _TMockBackend>
bool PGenericSocket<_TBackend, _TMockBackend>::createClientSocket(_TBackend & backend, _TMockBackend & mockBackend, const PSocketParam & socketParam, const typename _TBackend::Param & param, const std::string & mockPrefix, const typename _TMockBackend::Param & mockParam){
        bool b(true);
        b &= mockBackend.createClientSocket(p_mockSocket, socketParam, mockParam);
        b &= backend.createClientSocket(p_socket, socketParam, param);
        p_mockSocket.setMockPrefix(mockPrefix);
        p_mockSocket.setIsMockRecord(p_mode == PSocketMode::MOCK_RECORD);
        return b;
}


template<typename _TBackend, typename _TMockBackend>
bool PGenericSocket<_TBackend, _TMockBackend>::createServerSocket(_TBackend & backend, _TMockBackend & mockBackend, const PSocketParam & socketParam, const typename _TBackend::Param & param, const std::string & mockPrefix, const typename _TMockBackend::Param & mockParam){
        bool b(true);
        b &= mockBackend.createServerSocket(p_mockSocket, socketParam, mockParam);
        b &= backend.createServerSocket(p_socket, socketParam, param);
        p_mockSocket.setMockPrefix(mockPrefix);
        p_mockSocket.setIsMockRecord(p_mode == PSocketMode::MOCK_RECORD);
        return b;
}


template<typename _TBackend, typename _TMockBackend>
void PGenericSocket<_TBackend, _TMockBackend>::setMode(PSocketMode::PSocketMode mode){
        p_mode = mode;
        p_mockSocket.setIsMockRecord(mode == PSocketMode::MOCK_RECORD);
}


template<typename _TBackend, typename _TMockBackend>
PSendStatus::PSendStatus PGenericSocket<_TBackend, _TMockBackend>::sendMsg(typename _TBackend::Message & msg, PSendFlag::PSendFlag flag){
        PSendStatus::PSendStatus sendStatus = PSendStatus::OK;
        //This is normal to call the mock backend on a send, because it will check if the send message is the expected one
        //by respected to the recorded mock
        if(p_mode != PSocketMode::NO_MOCK){
                typename _TMockBackend::Message msgMock;
                _TBackend::msgToMock(msgMock, msg);
                sendStatus = p_mockSocket.sendMsg(msgMock, flag);
        }
 
        // If we dont test if b is true, we will always send the message even if the mock backend is not connected
        // I don't know if it is a good idea to do so
        // If we do that, we might have somme issues if the user tries to end a message. The mock may give an error that will not be catch 
        // Because the boolean value is not checked. So the real backend could have sent corretly the message and the mock not....
 
        if(p_mode != PSocketMode::MOCK && sendStatus == PSendStatus::OK){
                sendStatus = p_socket.sendMsg(msg, flag);
        }
        return sendStatus;
}


template<typename _TBackend, typename _TMockBackend>
PRecvStatus::PRecvStatus PGenericSocket<_TBackend, _TMockBackend>::recvMsg(typename _TBackend::Message & msg, PRecvFlag::PRecvFlag flag){
        PRecvStatus::PRecvStatus recvStatus = PRecvStatus::OK;
        if(p_mode == PSocketMode::NO_MOCK){   //Normal mode
                recvStatus = p_socket.recvMsg(msg, flag);
        }else if(p_mode == PSocketMode::MOCK){   //Mock mode
                typename _TMockBackend::Message msgMock;
                recvStatus = p_mockSocket.recvMsg(msgMock, flag);
                _TBackend::mockToMsg(msg, msgMock);
        }else{                                  //Mock record mode
                recvStatus = p_socket.recvMsg(msg, flag);
                if(recvStatus == PRecvStatus::OK){
                        typename _TMockBackend::Message msgMock;
                        _TBackend::msgToMock(msgMock, msg);
                        recvStatus = p_mockSocket.recvMsg(msgMock, flag);
                }else{
                        typename _TMockBackend::Message emptyMsg;
                        recvStatus = p_mockSocket.recvMsg(emptyMsg, flag);
                }
        }
        return recvStatus;
}

template<typename _TBackend, typename _TMockBackend>
void PGenericSocket<_TBackend, _TMockBackend>::close(){
        p_mockSocket.close();
        p_socket.close();
}


template<typename _TBackend, typename _TMockBackend>
bool PGenericSocket<_TBackend, _TMockBackend>::isConnected() const{
        bool b(true);
        if(p_mode != PSocketMode::NO_MOCK){
                b &= p_mockSocket.isConnected();
        }
        if(p_mode != PSocketMode::MOCK){
                b &= p_socket.isConnected();
        }
        return b;
}

template<typename _TBackend, typename _TMockBackend>
bool PGenericSocket<_TBackend, _TMockBackend>::waitUntilConnection(size_t refreshTimer, size_t nbRetry) const {
        size_t counter(0);
        bool b(false);
        while(!b && counter < nbRetry) {
                b = isConnected();
                //FIXME : use the clock backend instead of usleep
                usleep(refreshTimer);
                ++counter;
        }
        return b;
}


template<typename _TBackend, typename _TMockBackend>
void PGenericSocket<_TBackend, _TMockBackend>::initialisationPGenericSocket(PSocketMode::PSocketMode mode){
        p_mode = mode;
}
 
 
#endif