Got tcp receiving for windows done

Callbacks are done - maybe ill add a few more later - i dont know if they will work correctly yet
Fixed the Serialization class
Added internal tags - for now it only has CONNECT and DISCONNECT - maybe ill add more later
Fixed some data type parameters in some functions

src/NetworkMessage.cpp

@@ -1,6 +1,7 @@
 #include "NetworkMessage.hpp"
 #include "Utility.hpp"
 #include "Serializer.hpp"
+#include <vector>
 
 NetworkMessage::NetworkMessage()
 {
@@ -20,7 +21,7 @@ const NetworkMessage &NetworkMessage::EncodeMessage()
 	return NetworkMessage();
 }
 
-const NetworkMessage & NetworkMessage::DecodeMessage(const NetworkBuffer &buffer)
+const NetworkMessage &NetworkMessage::DecodeMessage(const NetworkBuffer &buffer)
 {
 	NetworkMessage message = DecodeMessageHeader(buffer);
 	message.data = DecodeMessageData(buffer);
@@ -36,12 +37,13 @@ void *NetworkMessage::DecodeMessageData(const NetworkBuffer &buffer)
 	{
 	case 0:
 	{
-		break;
+		void *object;
+		return Serializer::from_bytes(buffer.body, object);
 	}
 	default:
 	{
 		//version nor supported
-		return nullptr;// WORKING HERE!!!!!!!!!!!
+		throw std::runtime_error("NetworkMessage - Decoding version not supported");
 	}
 	}
 }

src/Serializer.cpp

@@ -1,8 +1,10 @@
 #include "Serializer.hpp"
 
-template<typename T> std::array<byte, sizeof(T)> Serializer::to_bytes(const T& object)
+#include <vector>
+
+template<typename T> const std::vector<byte> &Serializer::to_bytes(const T& object)
 {
-	std::array<byte, sizeof(T)> bytes;
+	std::vector<byte> bytes;
 
 	const byte *begin = reinterpret_cast<const byte*>(std::addressof(object));
 	const byte *end = begin + sizeof(T);
@@ -11,12 +13,13 @@ template<typename T> std::array<byte, sizeof(T)> Serializer::to_bytes(const T& o
 	return bytes;
 }
 
-template<typename T> T& Serializer::from_bytes(const std::array<byte, sizeof(T)> &bytes, T& object)
+template<typename T> T& Serializer::from_bytes(byte *bytes, T& object)
 {
 	static_assert(std::is_trivially_copyable<T>::value, "not a TriviallyCopyable type");
 
 	byte *begin_object = reinterpret_cast<byte*>(std::addressof(object));
-	std::copy(std::begin(bytes), std::end(bytes), begin_object);
+	std::vector<byte> bytes_vector(&bytes);
+	std::copy(bytes_vector.begin(), bytes_vector.end(), begin_object);
 
 	return object;
 }

src/Tags.hpp

@@ -0,0 +1,14 @@
+#ifndef TAGS_HPP
+#define TAGS_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#endif
+
+enum InternalTags : uint16
+{
+	CONNECT = 65534,
+	DISCONNECT = 65535,
+};
+
+#endif

src/TcpClientWindows.cpp

@@ -2,6 +2,8 @@
 #include "Utility.hpp"
 #include "Config.hpp"
 #include "NetworkBuffer.hpp"
+#include "Callbacks.hpp"
+#include "Tags.hpp"
 
 #include <iostream>
 
@@ -95,27 +97,37 @@ VoidCode TcpClient::Connect()
 		return VOID_COULDNT_CONNECT;
 }
 
-char *TcpClient::ReceiveDataArray()
+NetworkBuffer TcpClient::ReceiveDataArray()
 {
 	NetworkBuffer buffer;
 
 	if (recv(socket, reinterpret_cast<char*>(buffer.body_size), 4, 0) != 4 || WSAGetLastError() != 0)
 	{
 		// there was a problem receiving the body size of the message
-		return nullptr;
+		return NetworkBuffer();
 	}
 
 	buffer.body = new byte[buffer.body_size]();
 	if (recv(socket, reinterpret_cast<char*>(buffer.body), buffer.body_size, 0) != buffer.body_size || WSAGetLastError() != 0)
 	{
 		//there was a problem receiving the body of the message
-		return nullptr;
+		return NetworkBuffer();
 	}
+
+	return buffer;
 }
 
 const NetworkMessage &TcpClient::ReceiveData()
 {
-	
+	NetworkBuffer received_data = ReceiveDataArray();
+	NetworkMessage message = NetworkMessage(received_data);
+	if (message.tag == CONNECT)
+		OnConnect(message.sender);
+	else if (message.tag == DISCONNECT)
+		OnDisconnect(message.sender);
+	else
+		OnMessage(message.sender, message.tag, message.subject, message.data);
+	return message;
 }
 
 bool TcpClient::SendData(const NetworkMessage &message)