generic encapsulator

.github/workflows/ubuntu.yml

@@ -1,31 +0,0 @@
-name: Linux arm64
-run-name: Build And Test
-
-on: [push]
-
-
-env:
-  XMAKE_ROOT: y
-
-jobs:
-  Build:
-    runs-on: ubuntu-latest
-    steps: 
-      - name: Check out repository code
-        uses: actions/checkout@v3
-
-      - name: Prepare XMake
-        uses: xmake-io/github-action-setup-xmake@v1
-        with:
-          xmake-version: latest
-          actions-cache-folder: '.xmake-cache'
-          actions-cache-key: 'ubuntu'
-      
-      - name: XMake config
-        run: xmake f -p linux -y
-
-      - name: Build
-        run: xmake
-
-      - name: Test
-        run: xmake test

include/sp/common/DataBuffer.h

@@ -35,7 +35,6 @@ class DataBuffer {
 	typedef Data::difference_type difference_type;
 
 	DataBuffer();
-	DataBuffer(std::size_t a_InitialSize);
 	DataBuffer(const DataBuffer& other);
 	DataBuffer(const DataBuffer& other, difference_type offset);
 	DataBuffer(DataBuffer&& other);
@@ -167,7 +166,7 @@ class DataBuffer {
 			K newKey;
 			V newValue;
 			*this >> newKey >> newValue;
-			data.emplace(newKey, newValue);
+			data.insert({newKey, newValue});
 		}
 		return *this;
 	}

include/sp/common/NonCopyable.h

@@ -1,25 +0,0 @@
-#pragma once
-
-/**
- * \file NonCopyable.h
- * \brief File containing the sp::NonCopyable class
- */
-
-namespace sp {
-
-/**
- * \class NonCopyable
- * \brief Class used to make a class non copyable
- * \note Inherit from this class privately to make a class non copyable
- */
-class NonCopyable {
-  public:
-	NonCopyable(const NonCopyable&) = delete;
-	NonCopyable& operator=(const NonCopyable&) = delete;
-
-  protected:
-	NonCopyable() {}
-	~NonCopyable() {}
-};
-
-}  // namespace sp

include/sp/common/VarInt.h

@@ -21,8 +21,6 @@ class VarInt {
 	std::uint64_t m_Value;
 
   public:
-	static const std::uint64_t MAX_VALUE = static_cast<std::uint64_t>(-1) >> 8;
-
 	VarInt() : m_Value(0) {}
 	/**
 	 * \brief Construct a variable integer from a value

include/sp/extensions/Compress.h

@@ -47,7 +47,7 @@ template <>
 class MessageEncapsulator<option::ZlibCompress> {
   public:
 	static DataBuffer Encapsulate(const DataBuffer& a_Data, const option::ZlibCompress& a_Option);
-	static DataBuffer Decapsulate(DataBuffer& a_Data, const option::ZlibCompress& a_Option);
+	static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length, const option::ZlibCompress& a_Option);
 };
 
 }  // namespace io

include/sp/extensions/Extensions.h

@@ -3,7 +3,3 @@
 #if __has_include(<sp/extensions/Compress.h>)
 	#include <sp/extensions/Compress.h>
 #endif
-
-#if __has_include(<sp/extensions/Tcp.h>)
-	#include <sp/extensions/Tcp.h>
-#endif

include/sp/extensions/Tcp.h

@@ -1,4 +0,0 @@
-#pragma once
-
-#include <sp/extensions/tcp/TcpListener.h>
-#include <sp/extensions/tcp/TcpSocket.h>

include/sp/extensions/tcp/TcpListener.h

@@ -1,65 +0,0 @@
-#pragma once
-
-#include <sp/extensions/tcp/TcpSocket.h>
-
-namespace sp {
-namespace io {
-
-/**
- * \class TcpListener
- */
-class TcpListener : private NonCopyable {
-  public:
-	/**
-	 * \brief Starts listening for guests to connect
-	 * \param port The port to listen to
-	 * \param maxConnexions The maximum amount of connexion that can happen at the same time. \n
-	 * Every other guests will be kicked if this amount is reached.
-	 * \return Whether this action was succesfull
-	 */
-	TcpListener(std::uint16_t a_Port, int a_MaxConnexions);
-
-	/**
-	 * \brief Default destructor
-	 */
-	~TcpListener();
-
-	/**
-	 * \brief Tries to accept an incoming request to connect
-	 * \return the new socket if a new connexion was accepted or nullptr
-	 */
-	std::unique_ptr<TcpSocket> Accept();
-
-	/**
-	 * \brief Closes the socket
-	 */
-	void Close();
-
-	/**
-	 * \brief Allows to set the socket in non blocking/blocking mode
-	 * \param a_Blocking If set to true, every call to Read will wait until the socket receives something
-	 * \return true if the operation was successful
-	 */
-	bool SetBlocking(bool a_Blocking);
-
-	/**
-	 * \brief Getter of the m_Port member
-	 * \return The port which the socket listen to
-	 */
-	std::uint16_t GetListeningPort() const;
-
-	/**
-	 * \brief Getter of the m_MaxConnections member
-	 * \return The maximum amount of connexions that can happen at the same time.
-	 */
-	int GetMaximumConnections() const;
-
-  private:
-	SocketHandle m_Handle;
-	std::uint16_t m_Port;
-	int m_MaxConnections;
-};
-
-
-}  // namespace io
-}  // namespace sp

include/sp/extensions/tcp/TcpSocket.h

@@ -1,86 +0,0 @@
-#pragma once
-
-#include <sp/common/NonCopyable.h>
-#include <sp/io/IOInterface.h>
-
-namespace sp {
-namespace io {
-
-using SocketHandle = int;
-
-struct TcpTag {};
-
-class SocketError : public std::exception {
-  private:
-	std::string m_Error;
-
-  public:
-	SocketError(std::string&& a_Msg) : m_Error(std::move(a_Msg)) {}
-
-	virtual const char* what() const noexcept override {
-		return m_Error.c_str();
-	}
-};
-
-template <>
-class IOInterface<TcpTag> : private NonCopyable {
-  public:
-	/**
-	 * \enum Status
-	 * \brief Describes the state of a socket
-	 */
-	enum class Status {
-		/** The socket is connected */
-		Connected,
-		/** The socket is not connected */
-		Disconnected,
-		/** Something bad happened */
-		Error,
-	};
-
-	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);
-	void Write(const sp::DataBuffer& a_Data);
-
-	/**
-	 * \brief Allows to set the socket in non blocking/blocking mode
-	 * \param a_Block If set to true, every call to Read will wait until the socket receives something
-	 * \return true if the operation was successful
-	 */
-	bool SetBlocking(bool a_Block);
-
-	/**
-	 * \brief Getter of the m_Status member
-	 * \return The TcpSocket::Status of this socket
-	 */
-	Status GetStatus() const;
-
-	/**
-	 * \brief Disconnects the socket from the remote
-	 * \note Does nothing if the socket is not connected. \n
-	 * 	This function is also called by the destructor.
-	 */
-	void Disconnect();
-
-
-  private:
-	SocketHandle m_Handle;
-	Status m_Status;
-
-	void Connect(const std::string& a_Host, std::uint16_t a_Port);
-
-	friend class TcpListener;
-};
-
-/**
- * \typedef TcpSocket
- */
-using TcpSocket = IOInterface<TcpTag>;
-
-}  // namespace io
-}  // namespace sp

include/sp/io/IOInterface.h

@@ -17,7 +17,7 @@ template <typename TOption>
 class MessageEncapsulator {
   public:
 	static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOption& a_Option);
-	static DataBuffer Decapsulate(DataBuffer& a_Data, const TOption& a_Option);
+	static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length, const TOption& a_Option);
 };
 
 template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
@@ -25,23 +25,16 @@ class Stream {
   protected:
 	MessageDispatcher m_Dispatcher;
 	IOInterface<IOTag> m_Interface;
-	std::tuple<TOptions...> m_Options;
 
 	using MessageBase = typename MessageDispatcher::MessageBaseType;
 
   public:
 	Stream() {}
-	Stream(IOInterface<IOTag>&& a_Interface, TOptions&&... a_Options);
+	Stream(IOInterface<IOTag>&& a_Interface);
 	Stream(Stream&& a_Stream);
 
-	void RecieveMessages();
+	void RecieveMessages(const TOptions&... a_Options);
-	void SendMessage(const MessageBase& a_Message);
+	void SendMessage(const MessageBase& a_Message, const TOptions&... a_Options);
-
-
-	template <typename TOption>
-	TOption& GetOption() {
-		return std::get<TOption>(m_Options);
-	}
 
 	MessageDispatcher& GetDispatcher() {
 		return m_Dispatcher;
@@ -49,7 +42,7 @@ class Stream {
 
   private:
 	static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOptions&... a_Options);
-	static DataBuffer Decapsulate(DataBuffer& a_Data, const TOptions&... a_Options);
+	static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length, const TOptions&... a_Options);
 };
 
 }  // namespace io

include/sp/io/IOInterfaceImpl.inl

@@ -15,7 +15,7 @@ struct MessageEncapsulatorPack<> {
 	static DataBuffer Encapsulate(const DataBuffer& a_Data) {
 		return a_Data;
 	}
-	static DataBuffer Decapsulate(DataBuffer& a_Data) {
+	static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length) {
 		return a_Data;
 	}
 };
@@ -26,9 +26,9 @@ struct MessageEncapsulatorPack<TOption, TOptions...> {
 		DataBuffer data = io::MessageEncapsulator<TOption>::Encapsulate(a_Data, a_Option);
 		return MessageEncapsulatorPack<TOptions...>::Encapsulate(data, a_Options...);
 	}
-	static DataBuffer Decapsulate(DataBuffer& a_Data, const TOption& a_Option, const TOptions&... a_Options) {
+	static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length, const TOption& a_Option, const TOptions&... a_Options) {
-		DataBuffer data = io::MessageEncapsulator<TOption>::Decapsulate(a_Data, a_Option);
+		DataBuffer data = io::MessageEncapsulator<TOption>::Decapsulate(a_Data, a_Length, a_Option);
-		return MessageEncapsulatorPack<TOptions...>::Decapsulate(data, a_Options...);
+		return MessageEncapsulatorPack<TOptions...>::Decapsulate(data, data.GetSize(), a_Options...);
 	}
 };
 
@@ -37,8 +37,8 @@ struct MessageEncapsulatorPack<TOption, TOptions...> {
 namespace io {
 
 template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
-Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(IOInterface<IOTag>&& a_Interface, TOptions&&... a_Options) :
+Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(IOInterface<IOTag>&& a_Interface) :
-	m_Interface(std::move(a_Interface)), m_Options(std::make_tuple<TOptions...>(std::move(a_Options)...)) {}
+	m_Interface(std::move(a_Interface)) {}
 
 template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
 Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(
@@ -46,18 +46,17 @@ Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(
 	m_Dispatcher(std::move(a_Stream.m_Dispatcher)), m_Interface(std::move(a_Stream.m_Interface)) {}
 
 template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
-void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::SendMessage(const MessageBase& a_Message) {
+void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::SendMessage(
+	const MessageBase& a_Message, const TOptions&... a_Options) {
 	DataBuffer data = a_Message.Write();
-	DataBuffer encapsulated = std::apply([&data](const auto&... a_Options) {
+	DataBuffer encapsulated = Encapsulate(data, a_Options...);
-		return Encapsulate(data, a_Options...);
-	}, m_Options);
 	DataBuffer finalData;
 	finalData << VarInt{encapsulated.GetSize()} << encapsulated;
 	m_Interface.Write(finalData);
 }
 
 template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
-void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::RecieveMessages() {
+void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::RecieveMessages(const TOptions&... a_Options) {
 	while (true) {
 		// reading the first VarInt part byte by byte
 		std::uint64_t lenghtValue = 0;
@@ -93,9 +92,7 @@ void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::RecieveMessa
 		DataBuffer buffer;
 		buffer = m_Interface.Read(lenghtValue);
 
-		buffer = std::apply([&buffer, lenghtValue](const auto&... a_Options) {
+		buffer = Decapsulate(buffer, lenghtValue, a_Options...);
-			return Decapsulate(buffer, a_Options...);
-		}, m_Options);
 
 		VarInt packetType;
 		buffer >> packetType;
@@ -120,8 +117,8 @@ DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Encaps
 
 template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
 DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Decapsulate(
-	DataBuffer& a_Data, const TOptions&... a_Options) {
+	DataBuffer& a_Data, std::size_t a_Length, const TOptions&... a_Options) {
-	return details::MessageEncapsulatorPack<TOptions...>::Decapsulate(a_Data, a_Options...);
+	return details::MessageEncapsulatorPack<TOptions...>::Decapsulate(a_Data, a_Length, a_Options...);
 }
 
 }  // namespace io

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

include/sp/protocol/message/MessageDispatcherImpl.inl

@@ -1,36 +1,34 @@
 #pragma once
 
 template <typename MessageIdType, typename MessageBase, typename MessageHandler>
-void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::RegisterHandler(MessageIdType a_MessageType, MessageHandler* a_Handler) {
+void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::RegisterHandler(MessageIdType a_MessageType, const std::shared_ptr<MessageHandler>& a_Handler) {
-	assert(a_Handler);
 	auto found = std::find(m_Handlers[a_MessageType].begin(), m_Handlers[a_MessageType].end(), a_Handler);
 	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, MessageHandler* a_Handler) {
+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);
 	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(MessageHandler* a_Handler) {
+void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::UnregisterHandler(const std::shared_ptr<MessageHandler>& a_Handler) {
 	for (auto& pair : m_Handlers) {
 		if (pair.second.empty())
 			continue;
 
 		MessageIdType type = pair.first;
 
-		pair.second.erase(std::remove(pair.second.begin(), pair.second.end(), a_Handler), pair.second.end());
+		m_Handlers[type].erase(std::remove(m_Handlers[type].begin(), m_Handlers[type].end(), a_Handler), m_Handlers[type].end());
 	}
 }
 
 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]) {
+	for (auto& handler : m_Handlers[type])
 		a_Message.Dispatch(*handler);
 }
-}

src/sp/common/DataBuffer.cpp

@@ -8,8 +8,6 @@ namespace sp {
 
 DataBuffer::DataBuffer() : m_ReadOffset(0) {}
 
-DataBuffer::DataBuffer(std::size_t a_InitialSize) : m_Buffer(a_InitialSize), m_ReadOffset(0) {}
-
 DataBuffer::DataBuffer(const DataBuffer& other) : m_Buffer(other.m_Buffer), m_ReadOffset(other.m_ReadOffset) {}
 
 DataBuffer::DataBuffer(DataBuffer&& other) : m_Buffer(std::move(other.m_Buffer)), m_ReadOffset(std::move(other.m_ReadOffset)) {}

src/sp/extensions/Compress.cpp

@@ -11,7 +11,7 @@ static DataBuffer Inflate(const std::uint8_t* source, std::size_t size, std::siz
 	DataBuffer result;
 	result.Resize(uncompressedSize);
 
-	uncompress(static_cast<Bytef*>(result.data()), reinterpret_cast<uLongf*>(&uncompressedSize), static_cast<const Bytef*>(source),
+	uncompress(static_cast<Bytef*>(result.data()), static_cast<uLongf*>(&uncompressedSize), static_cast<const Bytef*>(source),
 		static_cast<uLong>(size));
 
 	assert(result.GetSize() == uncompressedSize);
@@ -77,12 +77,12 @@ DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength) {
 namespace io {
 
 DataBuffer MessageEncapsulator<option::ZlibCompress>::Encapsulate(const DataBuffer& a_Data, const option::ZlibCompress& a_Option) {
-	static constexpr std::size_t MAX_COMPRESS_THRESHOLD = VarInt::MAX_VALUE;
+	return a_Option.m_Enabled ? zlib::Compress(a_Data, a_Option.m_CompressionThreshold) : a_Data;
-	return zlib::Compress(a_Data, a_Option.m_Enabled ? a_Option.m_CompressionThreshold : MAX_COMPRESS_THRESHOLD);
 }
 
-DataBuffer MessageEncapsulator<option::ZlibCompress>::Decapsulate(DataBuffer& a_Data, const option::ZlibCompress& a_Option) {
+DataBuffer MessageEncapsulator<option::ZlibCompress>::Decapsulate(
-	return zlib::Decompress(a_Data, a_Data.GetSize());
+	DataBuffer& a_Data, std::size_t a_Length, const option::ZlibCompress& a_Option) {
+	return a_Option.m_Enabled ? zlib::Decompress(a_Data, a_Length) : a_Data;
 }
 
 }  // namespace io

src/sp/extensions/TcpListener.cpp

@@ -1,114 +0,0 @@
-#include <sp/extensions/tcp/TcpListener.h>
-
-
-#ifdef _WIN32
-
-// Windows
-
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-#define ioctl ioctlsocket
-#define WOULDBLOCK WSAEWOULDBLOCK
-#define MSG_DONTWAIT 0
-
-#else
-
-// Linux/Unix
-
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#define closesocket close
-#define WOULDBLOCK EWOULDBLOCK
-#define SD_BOTH SHUT_RDWR
-
-#endif
-
-
-
-#ifndef INVALID_SOCKET
-#define INVALID_SOCKET -1
-#endif
-
-
-namespace sp {
-namespace io {
-
-TcpListener::TcpListener(std::uint16_t a_Port, int a_MaxConnexions) {
-	if ((m_Handle = static_cast<SocketHandle>(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))) < 0) {
-		throw SocketError("Failed to create server socket");
-	}
-
-	struct sockaddr_in address;
-	address.sin_family = AF_INET;
-	address.sin_addr.s_addr = INADDR_ANY;
-	address.sin_port = htons(a_Port);
-
-	if (bind(m_Handle, reinterpret_cast<sockaddr*>(&address), sizeof(address)) < 0)
-		throw SocketError("Failed to create server socket");
-
-	if (listen(m_Handle, a_MaxConnexions) < 0)
-		throw SocketError("Failed to create server socket");
-
-	socklen_t len = sizeof(address);
-	if (getsockname(m_Handle, reinterpret_cast<sockaddr*>(&address), &len) < 0)
-		throw SocketError("Failed to create server socket");
-
-	m_Port = ntohs(address.sin_port);
-	m_MaxConnections = a_MaxConnexions;
-}
-
-
-TcpListener::~TcpListener() {
-	Close();
-}
-
-std::unique_ptr<TcpSocket> TcpListener::Accept() {
-	sockaddr remoteAddress;
-	int addrlen = sizeof(remoteAddress);
-
-	auto newSocket = std::make_unique<TcpSocket>();
-
-	newSocket->m_Handle = static_cast<SocketHandle>(
-		accept(m_Handle, reinterpret_cast<sockaddr*>(&remoteAddress), reinterpret_cast<socklen_t*>(&addrlen)));
-
-	if (newSocket->m_Handle < 0)
-		return nullptr;
-
-	newSocket->m_Status = TcpSocket::Status::Connected;
-	return newSocket;
-}
-
-void TcpListener::Close() {
-	if (m_Handle > 0) {
-		closesocket(m_Handle);
-		shutdown(m_Handle, SD_BOTH);
-	}
-}
-
-bool TcpListener::SetBlocking(bool a_Blocking) {
-	unsigned long mode = !a_Blocking;
-
-	if (ioctl(m_Handle, FIONBIO, &mode) < 0) {
-		return false;
-	}
-
-	return true;
-}
-
-std::uint16_t TcpListener::GetListeningPort() const {
-	return m_Port;
-}
-
-int TcpListener::GetMaximumConnections() const {
-	return m_MaxConnections;
-}
-
-}  // namespace io
-}  // namespace sp

src/sp/extensions/TcpSocket.cpp

@@ -1,164 +0,0 @@
-#include <sp/extensions/tcp/TcpSocket.h>
-
-#ifdef _WIN32
-
-// Windows
-
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-#define ioctl ioctlsocket
-#define WOULDBLOCK WSAEWOULDBLOCK
-#define MSG_DONTWAIT 0
-
-#else
-
-// Linux/Unix
-
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#define closesocket close
-#define WOULDBLOCK EWOULDBLOCK
-
-#endif
-
-
-
-#ifndef INVALID_SOCKET
-#define INVALID_SOCKET -1
-#endif
-
-
-namespace sp {
-namespace io {
-
-TcpSocket::IOInterface() : m_Handle(static_cast<SocketHandle>(INVALID_SOCKET)), m_Status(Status::Disconnected) {}
-
-TcpSocket::IOInterface(const std::string& a_Host, std::uint16_t a_Port) : IOInterface() {
-	Connect(a_Host, a_Port);
-}
-
-TcpSocket::IOInterface(IOInterface&& a_Other) {
-	std::swap(m_Handle, a_Other.m_Handle);
-	std::swap(m_Status, a_Other.m_Status);
-}
-
-TcpSocket::~IOInterface() {}
-
-void TcpSocket::Connect(const std::string& a_Host, std::uint16_t a_Port) {
-	struct addrinfo hints {};
-
-	struct addrinfo* result = nullptr;
-
-	hints.ai_family = AF_INET;
-	hints.ai_socktype = SOCK_STREAM;
-	hints.ai_protocol = IPPROTO_TCP;
-
-	m_Status = Status::Error;
-
-	if (getaddrinfo(a_Host.c_str(), std::to_string(static_cast<int>(a_Port)).c_str(), &hints, &result) != 0) {
-		throw SocketError("Failed to get address info");
-	}
-
-	m_Handle = static_cast<SocketHandle>(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
-	if (m_Handle < 0) {
-		throw SocketError("Failed to create socket");
-	}
-
-	struct addrinfo* ptr = nullptr;
-	for (ptr = result; ptr != nullptr; ptr = ptr->ai_next) {
-		struct sockaddr* sockaddr = ptr->ai_addr;
-		if (connect(m_Handle, sockaddr, sizeof(sockaddr_in)) == 0) {
-			break;
-		}
-	}
-
-	freeaddrinfo(result);
-
-	if (!ptr) {
-		throw SocketError("Could not find a suitable interface for connecting");
-	}
-
-	m_Status = Status::Connected;
-}
-
-DataBuffer TcpSocket::Read(std::size_t a_Amount) {
-	DataBuffer buffer(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);
-		if (recvAmount <= 0) {
-#if defined(_WIN32) || defined(WIN32)
-			int err = WSAGetLastError();
-#else
-			int err = errno;
-#endif
-			if (err == WOULDBLOCK) {
-				// we are in non blocking mode and nothing is available
-				return {};
-			}
-
-			Disconnect();
-			m_Status = Status::Error;
-			throw SocketError("Error while reading");
-		}
-		totalRecieved += recvAmount;
-	}
-	return buffer;
-}
-
-void TcpSocket::Write(const sp::DataBuffer& a_Data) {
-	if (GetStatus() != Status::Connected)
-		return;
-
-	std::size_t sent = 0;
-
-	while (sent < a_Data.GetSize()) {
-		int cur = send(m_Handle, reinterpret_cast<const char*>(a_Data.data() + sent), static_cast<int>(a_Data.GetSize() - sent), 0);
-
-		if (cur <= 0) {
-			Disconnect();
-			m_Status = Status::Error;
-			return;
-		}
-		sent += static_cast<std::size_t>(cur);
-	}
-}
-
-bool TcpSocket::SetBlocking(bool a_Block) {
-	unsigned long mode = !a_Block;
-
-	if (ioctl(m_Handle, FIONBIO, &mode) < 0) {
-		return false;
-	}
-
-	return true;
-}
-
-TcpSocket::Status TcpSocket::GetStatus() const {
-	return m_Status;
-}
-
-void TcpSocket::Disconnect() {
-	if (m_Handle > 0)
-		closesocket(m_Handle);
-	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);
-	return *this;
-}
-
-}  // namespace io
-}  // namespace sp

test/test_file.cpp

@@ -22,21 +22,21 @@ using FileStream = sp::io::Stream<sp::io::FileTag, sp::PacketDispatcher, sp::Pac
 int main() {
 	auto handler = std::make_shared<CustomPacketHandler>();
 
-	FileStream stream(sp::io::File{"test.txt", sp::io::FileTag::In | sp::io::FileTag::Out}, {});
+	FileStream stream(sp::io::File{"test.txt", sp::io::FileTag::In | sp::io::FileTag::Out});
-	stream.GetDispatcher().RegisterHandler(PacketId::Disconnect, handler.get());
+	stream.GetDispatcher().RegisterHandler(PacketId::Disconnect, handler);
-	stream.GetDispatcher().RegisterHandler(PacketId::KeepAlive, handler.get());
+	stream.GetDispatcher().RegisterHandler(PacketId::KeepAlive, handler);
 
-	stream.SendMessage(KeepAlivePacket{96});
+	auto zlibOptions = sp::option::ZlibCompress{};
-	stream.SendMessage(KeepAlivePacket{69});
-	stream.SendMessage(DisconnectPacket{
-		"This is in the "
-		"fiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiile !"});
-	stream.GetOption<sp::option::ZlibCompress>().m_Enabled = false;
-	stream.SendMessage(DisconnectPacket{
-		"This is in the "
-		"fiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiile !"});
 
-	stream.RecieveMessages();
+	stream.SendMessage(KeepAlivePacket{96}, zlibOptions);
+	stream.SendMessage(KeepAlivePacket{69}, zlibOptions);
+	stream.SendMessage(
+		DisconnectPacket{
+			"This is in the "
+			"fiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiile !"},
+		zlibOptions);
+
+	stream.RecieveMessages(zlibOptions);
 
 	return 0;
 }

test/test_io.cpp

@@ -23,13 +23,13 @@ int main() {
 	auto handler = std::make_shared<CustomPacketHandler>();
 
 	DataBufferStream stream;
-	stream.GetDispatcher().RegisterHandler(PacketId::Disconnect, handler.get());
+	stream.GetDispatcher().RegisterHandler(PacketId::Disconnect, handler);
 
 	// this should not be dispatched
 	stream.SendMessage(KeepAlivePacket{96});
 	stream.RecieveMessages();
 
-	stream.GetDispatcher().RegisterHandler(PacketId::KeepAlive, handler.get());
+	stream.GetDispatcher().RegisterHandler(PacketId::KeepAlive, handler);
 
 	stream.SendMessage(KeepAlivePacket{69});
 	stream.RecieveMessages();

test/test_packets.cpp

@@ -48,10 +48,10 @@ int main() {
 	packet->Dispatch(*handler);
 
 	sp::PacketDispatcher dispatcher;
-	dispatcher.RegisterHandler(PacketId::KeepAlive, handler.get());
+	dispatcher.RegisterHandler(PacketId::KeepAlive, handler);
 	dispatcher.Dispatch(*packet);
-	dispatcher.UnregisterHandler(PacketId::KeepAlive, handler.get());
+	dispatcher.UnregisterHandler(PacketId::KeepAlive, handler);
-	dispatcher.UnregisterHandler(handler.get());
+	dispatcher.UnregisterHandler(handler);
 
 	return 0;
 }

xmake.lua

@@ -6,21 +6,12 @@ local modules = {
     Compression = {
         Option = "zlib",
         Deps = {"zlib"},
+        Packages = {"zlib"},
         Includes = {"include/(sp/extensions/Compress.h)"},
         Sources = {"src/sp/extensions/Compress.cpp"}
-    },
-    TcpSocket = {
-        Option = "tcp",
-        Deps = {},
-        Includes = {"include/(sp/extensions/Tcp.h)", "include/(sp/extensions/tcp/*.h)"},
-        Sources = {"src/sp/extensions/Tcp*.cpp"}
     }
 }
 
-
-
-
-
 -- Map modules to options
 for name, module in table.orderpairs(modules) do
 	if module.Option then
@@ -28,10 +19,6 @@ for name, module in table.orderpairs(modules) do
     end
 end
 
-
-
-
-
 -- Add modules requirements
 for name, module in table.orderpairs(modules) do
 	if module.Deps then
@@ -39,10 +26,6 @@ for name, module in table.orderpairs(modules) do
     end
 end
 
-
-
-
-
 -- Add modules targets
 for name, module in table.orderpairs(modules) do
 	if module.Deps and has_config(module.Option) then
@@ -54,7 +37,7 @@ for name, module in table.orderpairs(modules) do
             for _, source in table.orderpairs(module.Sources) do
                 add_files(source)
             end
-            for _, package in table.orderpairs(module.Deps) do
+            for _, package in table.orderpairs(module.Packages) do
                 add_packages(package)
             end
             set_group("Library")
@@ -62,17 +45,14 @@ for name, module in table.orderpairs(modules) do
     end
 end
 
-
-
-
-
 target("SimpleProtocol")
     add_includedirs("include")
     add_files("src/sp/**.cpp")
-    set_group("Library")
-    set_kind("$(kind)")
     
-    add_headerfiles("include/(sp/**.h)", "include/(sp/**.inl)")
+    local includeFolders = {"common", "default", "io", "protocol"}
+    for _, folder in ipairs(includeFolders) do
+        add_headerfiles("include/(sp/" .. folder .. "/**.h)")
+    end
 
     -- adding extensions
     for name, module in table.orderpairs(modules) do
@@ -83,14 +63,8 @@ target("SimpleProtocol")
 
     -- we don't want extensions
     remove_files("src/sp/extensions/**.cpp")
-    remove_headerfiles("include/(sp/extension/**.h)")
+    set_group("Library")
-
+    set_kind("$(kind)")
-    -- we need this for endian functions
-    if is_os("windows") then
-        add_links("ws2_32")
-    end
-
-
 
 -- Tests
 for _, file in ipairs(os.files("test/**.cpp")) do