PGenericSocket.h

Go to the documentation of this file.

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

template<typename _TBackend, typename _TMockBackend>
class PGenericSocket{
        public:
                PGenericSocket(PSocketMode::PSocketMode mode);
                virtual ~PGenericSocket();
        
                bool createClientSocket(const typename _TBackend::Param & param, const typename _TMockBackend::Param & mockParam);
                bool createServerSocket(const typename _TBackend::Param & param, const typename _TMockBackend::Param & mockParam);
                
                
                bool createClientSocket(const std::string & host, size_t port, const typename _TBackend::Param & param, const std::string & mockPrefix, const typename _TMockBackend::Param & mockParam);
                bool createServerSocket(const std::string & host, size_t port, const typename _TBackend::Param & param, const std::string & mockPrefix, const typename _TMockBackend::Param & mockParam);
                
                void setMode(PSocketMode::PSocketMode mode);
                

                template<typename U>
                bool sendData(const U & data, PSendFlag::PSendFlag flag){
                        size_t dataSize(data_size<U>(data));
                        bool b(true);
                        
                        if(p_mode != PSocketMode::NO_MOCK){
                                typename _TMockBackend::Message msg;
                                _TMockBackend::msgResize(msg, dataSize);
                                DataStreamIter iter = _TMockBackend::msgData(msg);
                                if(data_message_save<U>(iter, data)){                   //Save the message
                                        b &= _TMockBackend::send(p_mockSocket, msg, flag);
                                }else{
                                        b = false;
                                }
                        }
 
                        // 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){
                                typename _TBackend::Message msg;
                                _TBackend::msgResize(msg, dataSize);
                                DataStreamIter iter = _TBackend::msgData(msg);
                                if(data_message_save<U>(iter, data)){                   //Save the message
                                        b &= _TBackend::send(p_socket, msg, flag);
                                }else{
                                        b = false;
                                }
                        }
                        return b;
                }
 
                bool sendMsg(typename _TBackend::Message & msg, PSendFlag::PSendFlag flag);
                

                template<typename U>
                bool recvData(U & data, PRecvFlag::PRecvFlag flag){
                        bool b(true);
                        if(p_mode == PSocketMode::NO_MOCK){   //Normal mode
                                typename _TBackend::Message msg;
                                b &= _TBackend::recv(p_socket, msg, flag);
                                //If the message is empty we cannot initialise the given data, so, this is an error
                                b &= _TBackend::msgSize(msg) != 0lu;
                                if(b){
                                        DataStreamIter iter = _TBackend::msgData(msg);
                                        b &= data_message_load<U>(iter, data);
                                }
                        }else if(p_mode == PSocketMode::MOCK){   //Mock mode
                                typename _TMockBackend::Message msg;
                                b &= _TMockBackend::recv(p_mockSocket, msg, flag);
                                //If the message is empty we cannot initialise the given data, so, this is an error
                                b &= _TMockBackend::msgSize(msg) != 0lu;
                                if(b){
                                        DataStreamIter iter = _TMockBackend::msgData(msg);
                                        b &= data_message_load<U>(iter, data);
                                }
                        }else{                                  //Mock record mode
                                typename _TBackend::Message msg;
                                b &= _TBackend::recv(p_socket, msg, flag);
                                //If the message is empty we cannot initialise the given data, so, this is an error
                                b &= _TBackend::msgSize(msg) != 0lu;
                                if(b){
                                        DataStreamIter iter = _TBackend::msgData(msg);
                                        b &= data_message_load<U>(iter, data);
                                        //Let's convert the message into the mock backend
                                        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;
                }
                
                bool recvMsg(typename _TBackend::Message & msg, PRecvFlag::PRecvFlag flag);
                
                void close();
                bool isConnected() const;
                
        private:
                void initialisationPGenericSocket(PSocketMode::PSocketMode mode);
                
                PSocketMode::PSocketMode p_mode;
                
                typename _TBackend::Socket p_socket;
                typename _TMockBackend::Socket p_mockSocket;
};
 
#include "PGenericSocket_impl.h"
 
 
#endif