Merge branch 'add_send_recv_with_blocking_state' into 'master'

Add send recv with blocking state

See merge request !1

src/PEmptyBackend.cpp

@@ -76,20 +76,20 @@ bool PEmptyBackend::createServerSocket(PEmptyBackend::Socket & socket, const PEm
 ///Send message on the given socket
 /**	@param socket : socket to be used
  * 	@param msg : message to be sent
- * 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
+ * 	@param flag : flags to be used to send the message (BLOCK, NON_BLOCK, etc)
  * 	@return true on success, false otherwise
 */
-bool PEmptyBackend::send(PEmptyBackend::Socket & socket, const PEmptyBackend::Message & msg, int flags){
+bool PEmptyBackend::send(PEmptyBackend::Socket & socket, const PEmptyBackend::Message & msg, PSendFlag::PSendFlag flag){
 	return true;
 }
 
 ///Recieve message from the given socket
 /**	@param socket : socket to be used
  * 	@param msg : message to be recieved
- * 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
+ * 	@param flag : flags to be used to send the message (BLOCK, NON_BLOCK, etc)
  * 	@return true on success, false otherwise
 */
-bool PEmptyBackend::recv(PEmptyBackend::Socket & socket, PEmptyBackend::Message & msg, int flags){
+bool PEmptyBackend::recv(PEmptyBackend::Socket & socket, PEmptyBackend::Message & msg, PRecvFlag::PRecvFlag flag){
 	return false;
 }
 

src/PEmptyBackend.h

@@ -7,6 +7,7 @@
 #ifndef __PEMPTY_BACKEND_H__
 #define __PEMPTY_BACKEND_H__
 
+#include "PSocketFlag.h"
 #include "phoenix_mock_socket.h"
 
 ///@brief Set of parameters to be passed to create a socket with mock backend
@@ -26,15 +27,6 @@ class PEmptyBackend{
 		typedef std::vector<char> Message;
 		///Define the type of extra parameters which can be used to create a Socket used by the PAbstractSocketManager
 		typedef PEmptyParam Param;
-		///Type of the send flag
-		typedef int SendFlag;
-		///Type of the recv flag
-		typedef int RecvFlag;
-		
-		///Default send flags of the PZmqBackend used by the PAbstractSocketManager
-		static const int defaultSendFlag = 0;
-		///Default recv flags of the PZmqBackend used by the PAbstractSocketManager
-		static const int defaultRecvFlag = 0;
 		
 		PEmptyBackend();
 		
@@ -47,9 +39,10 @@ class PEmptyBackend{
 		static bool createClientSocket(Socket & socket, const PEmptyParam & param);
 		static bool createServerSocket(Socket & socket, const PEmptyParam & param);
 		
-		static bool send(Socket & socket, const Message& msg, int flags);
-		static bool recv(Socket & socket, Message& msg, int flags);
-				
+		static bool send(Socket & socket, const Message& msg, PSendFlag::PSendFlag flag);
+		
+		static bool recv(Socket & socket, Message& msg, PRecvFlag::PRecvFlag flag);
+		
 		static void msgResize(Message& msg, size_t sizeMsg);
 		static size_t msgSize(const Message& msg);
 		static const char* msgData(const Message& msg);

src/PGenericSocket.h

@@ -8,6 +8,7 @@
 #define __PGENERIC_SOCKET_H__
 
 #include "PSocketMode.h"
+#include "PSocketFlag.h"
 #include "phoenix_mock_socket.h"
 
 ///@brief Abstract socket which has a mock mode to avoid heavy socket backend for unit tests
@@ -22,11 +23,11 @@ class PGenericSocket{
 		
 		///Send message on the given socket
 		/**	@param data : data to be sent
-		* 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
+		* 	@param flag : flag to be used to send the message (BLOCK, NON_BLOCK, etc)
 		* 	@return true on success, false otherwise
 		*/
-		template<typename U, typename _TFlag>
-		bool sendData(const U & data, _TFlag flags){
+		template<typename U>
+		bool sendData(const U & data, PSendFlag::PSendFlag flag){
 			size_t dataSize(data_size<U>(data));
 			bool b(true);
 			
@@ -35,7 +36,7 @@ class PGenericSocket{
 				_TMockBackend::msgResize(msg, dataSize);
 				char* iter = _TMockBackend::msgData(msg);
 				if(data_message_save<char*, U>(iter, data)){			//Save the message
-					b &= _TMockBackend::send(p_mockSocket, msg, (typename _TMockBackend::SendFlag)flags);
+					b &= _TMockBackend::send(p_mockSocket, msg, flag);
 				}else{
 					b = false;
 				}
@@ -45,46 +46,27 @@ class PGenericSocket{
 				_TBackend::msgResize(msg, dataSize);
 				char* iter = _TBackend::msgData(msg);
 				if(data_message_save<char*, U>(iter, data)){			//Save the message
-					b &= _TBackend::send(p_socket, msg, (typename _TBackend::SendFlag)flags);
+					b &= _TBackend::send(p_socket, msg, flag);
 				}else{
 					b = false;
 				}
 			}
 			return b;
 		}
-		
-		///Send message on the given socket
-		/**	@param msg : message to be sent
-		* 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
-		* 	@return true on success, false otherwise
-		*/
-		template<typename _TFlag>
-		bool sendMsg(typename _TBackend::Message & msg, _TFlag flags){
-			size_t dataSize(msg.size());
-			bool b(true);
-			if(p_mode != PSocketMode::NO_MOCK){
-				typename _TMockBackend::Message vecTmp;
-				_TMockBackend::msgResize(vecTmp, dataSize);
-				memcpy(_TMockBackend::msgData(vecTmp), _TBackend::msgData(msg), dataSize);
-				b &= _TMockBackend::send(p_mockSocket, vecTmp, (typename _TMockBackend::SendFlag)flags);
-			}
-			if(p_mode != PSocketMode::MOCK){
-				b &= _TBackend::send(p_socket, msg, (typename _TBackend::SendFlag)flags);
-			}
-			return b;
-		}
+
+		bool sendMsg(typename _TBackend::Message & msg, PSendFlag::PSendFlag flag);
 		
 		///Recieve message from the given socket
 		/**	@param data : data to be recieved
-		* 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
+		* 	@param flag : flag to be used to send the message (BLOCK, NON_BLOCK, etc)
 		* 	@return true on success, false otherwise
 		*/
-		template<typename U, typename _TFlag>
-		bool recvData(U & data, _TFlag flags){
+		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, (typename _TBackend::RecvFlag)flags);
+				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){
@@ -93,7 +75,7 @@ class PGenericSocket{
 				}
 			}else if(p_mode == PSocketMode::MOCK){	//Mock mode
 				typename _TMockBackend::Message msg;
-				b &= _TMockBackend::recv(p_mockSocket, msg, (typename _TMockBackend::RecvFlag)flags);
+				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){
@@ -102,7 +84,7 @@ class PGenericSocket{
 				}
 			}else{					//Mock record mode
 				typename _TBackend::Message msg;
-				b &= _TBackend::recv(p_socket, msg, (typename _TBackend::RecvFlag)flags);
+				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){
@@ -114,43 +96,14 @@ class PGenericSocket{
 						size_t dataSize(_TBackend::msgSize(msg));
 						_TMockBackend::msgResize(msgMock, dataSize);
 						memcpy(_TMockBackend::msgData(msgMock), _TBackend::msgData(msg), dataSize);
-						b &= _TMockBackend::recv(p_mockSocket, msgMock, (typename _TMockBackend::RecvFlag)flags);
+						b &= _TMockBackend::recv(p_mockSocket, msgMock, flag);
 					}
 				}
 			}
 			return b;
 		}
 		
-		///Recieve message from the given socket
-		/**	@param msg : message to be recieved
-		* 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
-		* 	@return true on success, false otherwise
-		*/
-		template<typename _TFlag>
-		bool recvMsg(typename _TBackend::Message & msg, _TFlag flags){
-			bool b(true);
-			if(p_mode == PSocketMode::NO_MOCK){	//Normal mode
-				b &= _TBackend::recv(p_socket, msg, (typename _TBackend::RecvFlag)flags);
-			}else if(p_mode == PSocketMode::MOCK){	//Mock mode
-				typename _TMockBackend::Message msgMock;
-				b &= _TMockBackend::recv(p_mockSocket, msgMock, (typename _TMockBackend::RecvFlag)flags);
-				if(b){
-					size_t dataSize(_TMockBackend::msgSize(msgMock));
-					_TBackend::msgResize(msg, dataSize);
-					memcpy(_TBackend::msgData(msg), _TMockBackend::msgData(msgMock), dataSize);
-				}
-			}else{					//Mock record mode
-				b &= _TBackend::recv(p_socket, msg, (typename _TBackend::RecvFlag)flags);
-				if(b){
-					typename _TMockBackend::Message msgMock;
-					size_t dataSize(_TBackend::msgSize(msg));
-					_TMockBackend::msgResize(msgMock, dataSize);
-					memcpy(_TMockBackend::msgData(msgMock), _TBackend::msgData(msg), dataSize);
-					b &= _TMockBackend::recv(p_mockSocket, msgMock, (typename _TMockBackend::RecvFlag)flags);
-				}
-			}
-			return b;
-		}
+		bool recvMsg(typename _TBackend::Message & msg, PRecvFlag::PRecvFlag flag);
 		
 		void close();
 		bool isConnected() const;

src/PGenericSocketManager.h

@@ -22,6 +22,7 @@ class PGenericSocketManager{
 		virtual ~PGenericSocketManager();
 		
 		void setMode(PSocketMode::PSocketMode mode);
+		PSocketMode::PSocketMode getMode() const;
 		bool addClientSocket(const _TSocketKey & name, const typename _TBackend::Param & param, const typename _TMockBackend::Param & mockParam);
 		bool addServerSocket(const _TSocketKey & name, const typename _TBackend::Param & param, const typename _TMockBackend::Param & mockParam);
 		
@@ -31,88 +32,38 @@ class PGenericSocketManager{
 		///Send data on the given socket
 		/**	@param name : name of the socket to be used
 		* 	@param data : data to be sent
+		* 	@param flag : flag to be used to send the message (BLOCK, NON_BLOCK, etc)
 		* 	@return true on success, false otherwise
 		*/
 		template<typename U>
-		bool sendData(const _TSocketKey & name, const U & data){
-			return sendData(name, data, _TBackend::defaultSendFlag);
-		}
-		
-		///Send data on the given socket
-		/**	@param name : name of the socket to be used
-		* 	@param data : data to be sent
-		* 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
-		* 	@return true on success, false otherwise
-		*/
-		template<typename U, typename _TFlag>
-		bool sendData(const _TSocketKey & name, const U & data, _TFlag flags){
+		bool sendData(const _TSocketKey & name, const U & data, PSendFlag::PSendFlag flag = PSendFlag::BLOCK){
 			PGenericSocket<_TBackend, _TMockBackend> * socket = getSocket(name);
 			if(socket != NULL){
-				return socket->sendData(data, flags);
+				return socket->sendData(data, flag);
 			}else{
 				return false;
 			}
 		}
-		bool sendMsg(const _TSocketKey & name, typename _TBackend::Message & msg);
 		
-		///Send message on the given socket
-		/**	@param name : name of the socket to be used
-		* 	@param msg : message to be sent
-		* 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
-		* 	@return true on success, false otherwise
-		*/
-		template<typename _TFlag>
-		bool sendMsg(const _TSocketKey & name, typename _TBackend::Message & msg, _TFlag flags){
-			PGenericSocket<_TBackend, _TMockBackend> * socket = getSocket(name);
-			if(socket != NULL){
-				return socket->sendMsg(msg, flags);
-			}else{
-				return false;
-			}
-		}
+		bool sendMsg(const _TSocketKey & name, typename _TBackend::Message & msg, PSendFlag::PSendFlag flag = PSendFlag::BLOCK);
 		
 		///Recieve data from the given socket
 		/**	@param name : name of the socket to be used
 		* 	@param data : data to be recieved
+		* 	@param flags : flags to be used to send the message (BLOCK, NON_BLOCK, etc)
 		* 	@return true on success, false otherwise
 		*/
 		template<typename U>
-		bool recvData(const _TSocketKey & name, U & data){
-			return recvData(name, data, _TBackend::defaultRecvFlag);
-		}
-		///Recieve data from the given socket
-		/**	@param name : name of the socket to be used
-		* 	@param data : data to be recieved
-		* 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
-		* 	@return true on success, false otherwise
-		*/
-		template<typename U, typename _TFlag>
-		bool recvData(const _TSocketKey & name, U & data, _TFlag flags){
+		bool recvData(const _TSocketKey & name, U & data, PRecvFlag::PRecvFlag flag = PRecvFlag::BLOCK){
 			PGenericSocket<_TBackend, _TMockBackend> * socket = getSocket(name);
 			if(socket != NULL){
-				return socket->recvData(data, flags);
+				return socket->recvData(data, flag);
 			}else{
 				return false;
 			}
 		}
 		
-		bool recvMsg(const _TSocketKey & name, typename _TBackend::Message & msg);
-		
-		///Recieve message from the given socket
-		/**	@param name : name of the socket to be used
-		* 	@param msg : message to be recieved
-		* 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
-		* 	@return true on success, false otherwise
-		*/
-		template<typename _TFlag>
-		bool recvMsg(const _TSocketKey & name, typename _TBackend::Message & msg, _TFlag flags){
-			PGenericSocket<_TBackend, _TMockBackend> * socket = getSocket(name);
-			if(socket != NULL){
-				return socket->recvMsg(msg, flags);
-			}else{
-				return false;
-			}
-		}
+		bool recvMsg(const _TSocketKey & name, typename _TBackend::Message & msg, PRecvFlag::PRecvFlag flag = PRecvFlag::BLOCK);
 		
 		PGenericSocket<_TBackend, _TMockBackend>* getSocket(const _TSocketKey & name);
 		bool isSocketExist(const _TSocketKey & name) const;

src/PGenericSocketManager_impl.h

@@ -31,6 +31,14 @@ void PGenericSocketManager<_TSocketKey, _TBackend, _TMockBackend>::setMode(PSock
 	p_mode = mode;
 }
 
+///Get if the current PGenericSocketManager is a mock
+/**	@return Mode of the Socket (no mock, mock, mock_record)
+*/
+template<typename _TSocketKey, typename _TBackend, typename _TMockBackend>
+PSocketMode::PSocketMode PGenericSocketManager<_TSocketKey, _TBackend, _TMockBackend>::getMode() const{
+	return p_mode;
+}
+
 ///Create a client socket
 /**	@param name : name (key) to get the socket
  * 	@param param : extra customisable parameters for the creation of the socket (depends on the backend)
@@ -95,21 +103,33 @@ void PGenericSocketManager<_TSocketKey, _TBackend, _TMockBackend>::clear(){
 ///Send message on the given socket
 /**	@param name : name of the socket to be used
 * 	@param msg : message to be sent
+* 	@param flag : flags to be used to send the message (BLOCK, NON_BLOCK, etc)
 * 	@return true on success, false otherwise
 */
 template<typename _TSocketKey, typename _TBackend, typename _TMockBackend>
-bool PGenericSocketManager<_TSocketKey, _TBackend, _TMockBackend>::sendMsg(const _TSocketKey & name, typename _TBackend::Message & msg){
-	return sendMsg(name, msg, _TBackend::defaultSendFlag);
+bool PGenericSocketManager<_TSocketKey, _TBackend, _TMockBackend>::sendMsg(const _TSocketKey & name, typename _TBackend::Message & msg, PSendFlag::PSendFlag flag){
+	PGenericSocket<_TBackend, _TMockBackend> * socket = getSocket(name);
+	if(socket != NULL){
+		return socket->sendMsg(msg, flag);
+	}else{
+		return false;
+	}
 }
 
 ///Recieve message from the given socket
 /**	@param name : name of the socket to be used
 * 	@param msg : message to be recieved
+* 	@param flag : flags to be used to send the message (BLOCK, NON_BLOCK, etc)
 * 	@return true on success, false otherwise
 */
 template<typename _TSocketKey, typename _TBackend, typename _TMockBackend>
-bool PGenericSocketManager<_TSocketKey, _TBackend, _TMockBackend>::recvMsg(const _TSocketKey & name, typename _TBackend::Message & msg){
-	return recvMsg(name, msg, _TBackend::defaultRecvFlag);
+bool PGenericSocketManager<_TSocketKey, _TBackend, _TMockBackend>::recvMsg(const _TSocketKey & name, typename _TBackend::Message & msg, PRecvFlag::PRecvFlag flag){
+	PGenericSocket<_TBackend, _TMockBackend> * socket = getSocket(name);
+	if(socket != NULL){
+		return socket->recvMsg(msg, flag);
+	}else{
+		return false;
+	}
 }
 
 ///Get a socket by name (or key)

src/PGenericSocket_impl.h

@@ -57,6 +57,58 @@ bool PGenericSocket<_TBackend, _TMockBackend>::createServerSocket(const typename
 	return b;
 }
 
+///Send message on the given socket
+/**	@param msg : message to be sent
+* 	@param flag : flags to be used to send the message (BLOCK, NON_BLOCK, etc)
+* 	@return true on success, false otherwise
+*/
+template<typename _TBackend, typename _TMockBackend>
+bool PGenericSocket<_TBackend, _TMockBackend>::sendMsg(typename _TBackend::Message & msg, PSendFlag::PSendFlag flag){
+	size_t dataSize(msg.size());
+	bool b(true);
+	if(p_mode != PSocketMode::NO_MOCK){
+		typename _TMockBackend::Message vecTmp;
+		_TMockBackend::msgResize(vecTmp, dataSize);
+		memcpy(_TMockBackend::msgData(vecTmp), _TBackend::msgData(msg), dataSize);
+		b &= _TMockBackend::send(p_mockSocket, vecTmp, flag);
+	}
+	if(p_mode != PSocketMode::MOCK){
+		b &= _TBackend::send(p_socket, msg, flag);
+	}
+	return b;
+}
+
+///Recieve message from the given socket
+/**	@param msg : message to be recieved
+* 	@param flag : flags to be used to send the message (BLOCK, NON_BLOCK, etc)
+* 	@return true on success, false otherwise
+*/
+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){
+			size_t dataSize(_TMockBackend::msgSize(msgMock));
+			_TBackend::msgResize(msg, dataSize);
+			memcpy(_TBackend::msgData(msg), _TMockBackend::msgData(msgMock), dataSize);
+		}
+	}else{					//Mock record mode
+		b &= _TBackend::recv(p_socket, msg, flag);
+		if(b){
+			typename _TMockBackend::Message msgMock;
+			size_t dataSize(_TBackend::msgSize(msg));
+			_TMockBackend::msgResize(msgMock, dataSize);
+			memcpy(_TMockBackend::msgData(msgMock), _TBackend::msgData(msg), dataSize);
+			b &= _TMockBackend::recv(p_mockSocket, msgMock, flag);
+		}
+	}
+	return b;
+}
+
 ///Close the socket
 template<typename _TBackend, typename _TMockBackend>
 void PGenericSocket<_TBackend, _TMockBackend>::close(){

src/PMockBackend.cpp

@@ -74,10 +74,10 @@ bool PMockBackend::createServerSocket(PMockBackend::Socket & socket, const PMock
 ///Send message on the given socket
 /**	@param socket : socket to be used
  * 	@param msg : message to be sent
- * 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
+ * 	@param flag : flag to be used to send the message (BLOCK, NON_BLOCK, etc)
  * 	@return true on success, false otherwise
 */
-bool PMockBackend::send(PMockBackend::Socket & socket, const PMockBackend::Message & msg, int flags){
+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);
@@ -102,10 +102,10 @@ bool PMockBackend::send(PMockBackend::Socket & socket, const PMockBackend::Messa
 ///Recieve message from the given socket
 /**	@param socket : socket to be used
  * 	@param msg : message to be recieved
- * 	@param flags : flags to be used to send the message (none, dontwait, sndmore, etc)
+ * 	@param flag : flag to be used to send the message (BLOCK, NON_BLOCK, etc)
  * 	@return true on success, false otherwise
 */
-bool PMockBackend::recv(PMockBackend::Socket & socket, PMockBackend::Message & msg, int flags){
+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{

src/PMockBackend.h

@@ -7,6 +7,7 @@
 #ifndef __PMOCKBACKEND_H__
 #define __PMOCKBACKEND_H__
 
+#include "PSocketFlag.h"
 #include "phoenix_mock_socket.h"
 
 ///@brief Set of parameters to be passed to create a socket with mock backend
@@ -42,15 +43,6 @@ class PMockBackend{
 		typedef std::vector<char> Message;
 		///Define the type of extra parameters which can be used to create a Socket used by the PAbstractSocketManager
 		typedef PMockParam Param;
-		///Type of the send flag
-		typedef int SendFlag;
-		///Type of the recv flag
-		typedef int RecvFlag;
-		
-		///Default send flags of the PZmqBackend used by the PAbstractSocketManager
-		static const int defaultSendFlag = 0;
-		///Default recv flags of the PZmqBackend used by the PAbstractSocketManager
-		static const int defaultRecvFlag = 0;
 		
 		PMockBackend();
 		
@@ -60,8 +52,8 @@ class PMockBackend{
 		static bool createClientSocket(Socket & socket, const PMockParam & param);
 		static bool createServerSocket(Socket & socket, const PMockParam & param);
 		
-		static bool send(Socket & socket, const Message& msg, int flags);
-		static bool recv(Socket & socket, Message& msg, int flags);
+		static bool send(Socket & socket, const Message& msg, PSendFlag::PSendFlag flag);
+		static bool recv(Socket & socket, Message& msg, PRecvFlag::PRecvFlag flag);
 				
 		static void msgResize(Message& msg, size_t sizeMsg);
 		static size_t msgSize(const Message& msg);

src/PSocketFlag.h

+/***************************************
+	Auteur : Pierre Aubert
+	Mail : pierre.aubert@lapp.in2p3.fr
+	Licence : CeCILL-C
+****************************************/
+
+#ifndef __PSOCKET_FLAG_H__
+#define __PSOCKET_FLAG_H__
+
+namespace PSendFlag{
+	///@brief describe the sending flag of the Socket
+	enum PSendFlag{
+		BLOCK,		//Normal usage of the Socket. Blocking until a message is sent
+		NON_BLOCK	//The Socket send does not stop the execution of the program
+	};
+}
+
+namespace PRecvFlag{
+	///@brief describe the recieving flag of the Socket
+	enum PRecvFlag{
+		BLOCK,		//Normal usage of the Socket. Blocking until a message comes
+		NON_BLOCK	//The Socket recv does not stop the execution of the program
+	};
+}
+
+#endif
+