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(const typename _TBackend::Param & param, const typename _TMockBackend::Param & mockParam){
        bool b(true);
        if(p_mode != PSocketMode::NO_MOCK){
                b &= _TMockBackend::createClientSocket(p_mockSocket, mockParam);
        }
        if(p_mode != PSocketMode::MOCK){
                b &= _TBackend::createClientSocket(p_socket, param);
        }
        return b;
}
 
 
template<typename _TBackend, typename _TMockBackend>
bool PGenericSocket<_TBackend, _TMockBackend>::createServerSocket(const typename _TBackend::Param & param, const typename _TMockBackend::Param & mockParam){
        bool b(true);
        if(p_mode != PSocketMode::NO_MOCK){
                b &= _TMockBackend::createServerSocket(p_mockSocket, mockParam);
        }
        if(p_mode != PSocketMode::MOCK){
                b &= _TBackend::createServerSocket(p_socket, param);
        }
        return b;
}
 
 
template<typename _TBackend, typename _TMockBackend>
bool PGenericSocket<_TBackend, _TMockBackend>::sendMsg(typename _TBackend::Message & msg, PSendFlag::PSendFlag flag){
        bool b(true);
        //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 vecTmp;
                _TBackend::msgToMock(vecTmp, msg);
                b &= _TMockBackend::send(p_mockSocket, vecTmp, 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 && b){
                b &= _TBackend::send(p_socket, msg, flag);
        }
        return b;
}
 
 
template<typename _TBackend, typename _TMockBackend>
bool PGenericSocket<_TBackend, _TMockBackend>::recvMsg(typename _TBackend::Message & msg, PRecvFlag::PRecvFlag flag){
        bool b(true);
        if(p_mode == PSocketMode::NO_MOCK){     //Normal mode
                b &= _TBackend::recv(p_socket, msg, flag);
        }else if(p_mode == PSocketMode::MOCK){  //Mock mode
                typename _TMockBackend::Message msgMock;
                b &= _TMockBackend::recv(p_mockSocket, msgMock, flag);
                if(b){
                        _TBackend::mockToMsg(msg, msgMock);
                }
        }else{                                  //Mock record mode
                b &= _TBackend::recv(p_socket, msg, flag);
                if(b){
                        typename _TMockBackend::Message msgMock;
                        _TBackend::msgToMock(msgMock, msg);
                        b &= _TMockBackend::recv(p_mockSocket, msgMock, flag);
                }
                else {
                        typename _TMockBackend::Message empty_msg;
                        b &= _TMockBackend::recv(p_mockSocket, empty_msg, flag);
                }
        }
        return b;
}
 
template<typename _TBackend, typename _TMockBackend>
void PGenericSocket<_TBackend, _TMockBackend>::close(){
        if(p_mode == PSocketMode::MOCK){
                _TMockBackend::close(p_mockSocket);
        }else if(p_mode == PSocketMode::NO_MOCK){
                _TBackend::close(p_socket);
        }else{
                _TMockBackend::close(p_mockSocket);
                _TBackend::close(p_socket);
        }
}
 
 
template<typename _TBackend, typename _TMockBackend>
bool PGenericSocket<_TBackend, _TMockBackend>::isConnected() const{
        bool b(true);
        if(p_mode != PSocketMode::NO_MOCK){
                b &= _TMockBackend::isConnected(p_mockSocket);
        }
        if(p_mode != PSocketMode::MOCK){
                b &= _TBackend::isConnected(p_socket);
        }
        return b;
}
 
 
template<typename _TBackend, typename _TMockBackend>
void PGenericSocket<_TBackend, _TMockBackend>::initialisationPGenericSocket(PSocketMode::PSocketMode mode){
        p_mode = mode;
}
 
 
#endif