fix tcpsocket error

include/sp/extensions/tcp/TcpSocket.h

@@ -41,6 +41,7 @@ class IOInterface<TcpTag> : private NonCopyable {
 	IOInterface();
 	IOInterface(const std::string& a_Host, std::uint16_t a_Port);
 	IOInterface(IOInterface&& a_Other);
+	IOInterface& operator=(IOInterface&& a_Other);
 	virtual ~IOInterface();
 
 	DataBuffer Read(std::size_t a_Amount);

include/sp/protocol/MessageDispatcher.h

@@ -17,7 +17,7 @@ namespace sp {
 template <typename MessageIdType, typename MessageBase, typename MessageHandler>
 class MessageDispatcher {
   private:
-	std::map<MessageIdType, std::vector<std::shared_ptr<MessageHandler>>> m_Handlers;
+	std::map<MessageIdType, std::vector<std::weak_ptr<MessageHandler>>> m_Handlers;
 
   public:
 	using MessageBaseType = MessageBase;
@@ -38,18 +38,20 @@ class MessageDispatcher {
 	 * \param type The packet type
 	 * \param handler The packet handler
 	 */
-	void RegisterHandler(MessageIdType a_MessageType, const std::shared_ptr<MessageHandler>& a_Handler);
+	void RegisterHandler(MessageIdType a_MessageType, const std::weak_ptr<MessageHandler>& a_Handler);
+	
 	/**
 	 * \brief Unregister a packet handler
 	 * \param type The packet type
 	 * \param handler The packet handler
 	 */
-	void UnregisterHandler(MessageIdType a_MessageType, const std::shared_ptr<MessageHandler>& a_Handler);
+	void UnregisterHandler(MessageIdType a_MessageType, const std::weak_ptr<MessageHandler>& a_Handler);
+	
 	/**
 	 * \brief Unregister a packet handler
 	 * \param handler The packet handler
 	 */
-	void UnregisterHandler(const std::shared_ptr<MessageHandler>& a_Handler);
+	void UnregisterHandler(const std::weak_ptr<MessageHandler>& a_Handler);
 };
 
 #include <sp/protocol/message/MessageDispatcherImpl.inl>

include/sp/protocol/message/MessageDispatcherImpl.inl

@@ -1,34 +1,46 @@
 #pragma once
 
 template <typename MessageIdType, typename MessageBase, typename MessageHandler>
-void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::RegisterHandler(MessageIdType a_MessageType, const std::shared_ptr<MessageHandler>& a_Handler) {
-	auto found = std::find(m_Handlers[a_MessageType].begin(), m_Handlers[a_MessageType].end(), a_Handler);
+void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::RegisterHandler(MessageIdType a_MessageType, const std::weak_ptr<MessageHandler>& a_Handler) {
+	auto found = std::find_if(m_Handlers[a_MessageType].begin(), m_Handlers[a_MessageType].end(), [&a_Handler](const std::weak_ptr<MessageHandler>& handler){
+		return a_Handler.lock() == handler.lock();
+	});
 	if (found == m_Handlers[a_MessageType].end())
 		m_Handlers[a_MessageType].push_back(a_Handler);
 }
 
 template <typename MessageIdType, typename MessageBase, typename MessageHandler>
-void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::UnregisterHandler(MessageIdType a_MessageType, const std::shared_ptr<MessageHandler>& a_Handler) {
-	auto found = std::find(m_Handlers[a_MessageType].begin(), m_Handlers[a_MessageType].end(), a_Handler);
+void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::UnregisterHandler(MessageIdType a_MessageType, const std::weak_ptr<MessageHandler>& a_Handler) {
+	auto found = std::find_if(m_Handlers[a_MessageType].begin(), m_Handlers[a_MessageType].end(), [&a_Handler](const std::weak_ptr<MessageHandler>& handler){
+		return a_Handler.lock() == handler.lock();
+	});
 	if (found != m_Handlers[a_MessageType].end())
 		m_Handlers[a_MessageType].erase(found);
 }
 
 template <typename MessageIdType, typename MessageBase, typename MessageHandler>
-void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::UnregisterHandler(const std::shared_ptr<MessageHandler>& a_Handler) {
+void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::UnregisterHandler(const std::weak_ptr<MessageHandler>& a_Handler) {
 	for (auto& pair : m_Handlers) {
 		if (pair.second.empty())
 			continue;
 
 		MessageIdType type = pair.first;
 
-		m_Handlers[type].erase(std::remove(m_Handlers[type].begin(), m_Handlers[type].end(), a_Handler), m_Handlers[type].end());
+		auto it = std::find_if(pair.second.begin(), pair.second.end(), [&a_Handler](const std::weak_ptr<MessageHandler>& handler){
+			return handler.lock() == a_Handler.lock();
+		});
+
+		if (it != pair.second.end()) 
+			pair.second.erase(it);
+
 	}
 }
 
 template <typename MessageIdType, typename MessageBase, typename MessageHandler>
 void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::Dispatch(const MessageBase& a_Message) {
 	MessageIdType type = a_Message.GetId();
-	for (auto& handler : m_Handlers[type])
-		a_Message.Dispatch(*handler);
+	for (auto& handler : m_Handlers[type]) {
+		if (!handler.expired())
+			a_Message.Dispatch(*handler.lock());
+	}
 }

src/sp/extensions/TcpSocket.cpp

@@ -91,7 +91,8 @@ DataBuffer TcpSocket::Read(std::size_t a_Amount) {
 	std::size_t totalRecieved = 0;
 
 	while (totalRecieved < a_Amount) {
-		int recvAmount = recv(m_Handle, reinterpret_cast<char*>(buffer.data() + totalRecieved), static_cast<int>(a_Amount - totalRecieved), 0);
+		int recvAmount =
+			recv(m_Handle, reinterpret_cast<char*>(buffer.data() + totalRecieved), static_cast<int>(a_Amount - totalRecieved), 0);
 		if (recvAmount <= 0) {
 #if defined(_WIN32) || defined(WIN32)
 			int err = WSAGetLastError();
@@ -99,8 +100,8 @@ DataBuffer TcpSocket::Read(std::size_t a_Amount) {
 			int err = errno;
 #endif
 			if (err == WOULDBLOCK) {
-				m_Status = Status::Error;
-				throw SocketError("Error while reading");
+				// we are in non blocking mode and nothing is available
+				return {};
 			}
 
 			Disconnect();
@@ -150,8 +151,10 @@ void TcpSocket::Disconnect() {
 	m_Status = Status::Disconnected;
 }
 
-
+TcpSocket& TcpSocket::operator=(IOInterface&& a_Other) {
+	std::swap(m_Handle, a_Other.m_Handle);
+	std::swap(m_Status, a_Other.m_Status);
+}
 
 }  // namespace io
-
 }  // namespace sp