finish io

include/sp/extensions/Compress.h

@@ -6,20 +6,7 @@
  */
 
 #include <cstdint>
-#include <sp/common/DataBuffer.h>
-
-namespace sp {
-namespace option {
-
-struct ZlibCompress {
-	bool m_Enabled = true;
-	std::size_t m_CompressionThreshold = 64;
-};
-
-}  // namespace option
-}  // namespace sp
-
-#include <sp/io/IOInterface.h>
+#include <sp/io/MessageEncapsulator.h>
 
 namespace sp {
 namespace zlib {
@@ -41,14 +28,20 @@ DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength);
 
 }  // namespace zlib
 
-namespace io {
 
-template <>
-class MessageEncapsulator<option::ZlibCompress> {
+class ZlibCompress : public MessageEncapsulator {
+  private:
+	std::size_t m_CompressionThreshold;
+
   public:
-	static DataBuffer Encapsulate(const DataBuffer& a_Data, const option::ZlibCompress& a_Option);
-	static DataBuffer Decapsulate(DataBuffer& a_Data, const option::ZlibCompress& a_Option);
+	ZlibCompress() : m_CompressionThreshold(64) {}
+	ZlibCompress(const ZlibCompress&) = default;
+	virtual ~ZlibCompress() {}
+
+  protected:
+	virtual DataBuffer EncapsulateImpl(const DataBuffer& a_Data) override;
+	virtual DataBuffer DecapsulateImpl(DataBuffer& a_Data) override;
 };
 
-}  // namespace io
-}  // namespace sp
+
+}  // namespace sp

include/sp/extensions/tcp/TcpListener.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <sp/extensions/tcp/TcpSocket.h>
+#include <memory>
 
 namespace sp {
 namespace io {
@@ -10,7 +11,7 @@ namespace io {
  */
 class TcpListener : private NonCopyable {
   public:
-	using SocketHandle = TcpTag::SocketHandle;
+	using SocketHandle = TcpSocket::SocketHandle;
 
 	/**
 	 * \brief Starts listening for guests to connect

include/sp/extensions/tcp/TcpSocket.h

@@ -1,14 +1,12 @@
 #pragma once
 
 #include <sp/common/NonCopyable.h>
-#include <sp/io/IOInterface.h>
+#include <sp/io/IoInterface.h>
 
 namespace sp {
 namespace io {
 
-struct TcpTag {
-	using SocketHandle = int;
-};
+class TcpListener;
 
 class SocketError : public std::exception {
   private:
@@ -22,10 +20,9 @@ class SocketError : public std::exception {
 	}
 };
 
-template <>
-class IOInterface<TcpTag> : private NonCopyable {
+class TcpSocket : public sp::IoInterface {
   public:
-	using SocketHandle = TcpTag::SocketHandle;
+	using SocketHandle = int;
 
 	/**
 	 * \enum Status
@@ -40,14 +37,14 @@ class IOInterface<TcpTag> : private NonCopyable {
 		Error,
 	};
 
-	IOInterface();
-	IOInterface(const std::string& a_Host, std::uint16_t a_Port);
-	IOInterface(IOInterface&& a_Other);
-	IOInterface& operator=(IOInterface&& a_Other);
-	virtual ~IOInterface();
+	TcpSocket();
+	TcpSocket(const std::string& a_Host, std::uint16_t a_Port);
+	TcpSocket(TcpSocket&& a_Other);
+	TcpSocket& operator=(TcpSocket&& a_Other);
+	virtual ~TcpSocket();
 
-	DataBuffer Read(std::size_t a_Amount);
-	void Write(const sp::DataBuffer& a_Data);
+	virtual DataBuffer Read(std::size_t a_Amount) override;
+	virtual void Write(const sp::DataBuffer& a_Data) override;
 
 	/**
 	 * \brief Allows to set the socket in non blocking/blocking mode
@@ -79,10 +76,5 @@ class IOInterface<TcpTag> : private NonCopyable {
 	friend class TcpListener;
 };
 
-/**
- * \typedef TcpSocket
- */
-using TcpSocket = IOInterface<TcpTag>;
-
 }  // namespace io
 }  // namespace sp

include/sp/io/IoInterface.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include <sp/common/DataBuffer.h>
+#include <sp/common/NonCopyable.h>
 
 namespace sp {
 
-class IoInterface {
+class IoInterface : private NonCopyable {
   public:
 	virtual DataBuffer Read(std::size_t a_Amount) = 0;
 	virtual void Write(const DataBuffer& a_Data) = 0;

include/sp/io/MessageEncapsulator.h

@@ -5,12 +5,27 @@
 namespace sp {
 
 class MessageEncapsulator {
+  protected:
+	bool m_Enabled = true;
+
   public:
 	MessageEncapsulator() {}
 	virtual ~MessageEncapsulator() {}
 
-	virtual DataBuffer Encapsulate(const DataBuffer& a_Data) = 0;
-	virtual DataBuffer Decapsulate(DataBuffer& a_Data) = 0;
+	DataBuffer Encapsulate(const DataBuffer& a_Data) {
+		if (!m_Enabled)
+			return a_Data;
+		return EncapsulateImpl(a_Data);
+	}
+	DataBuffer Decapsulate(DataBuffer& a_Data) {
+		if (!m_Enabled)
+			return a_Data;
+		return DecapsulateImpl(a_Data);
+	}
+
+  protected:
+	virtual DataBuffer EncapsulateImpl(const DataBuffer& a_Data) = 0;
+	virtual DataBuffer DecapsulateImpl(DataBuffer& a_Data) = 0;
 };
 
 }  // namespace sp

include/sp/io/MessageStream.h

@@ -9,8 +9,8 @@ namespace sp {
 
 template <typename TMessageFactory>
 class MessageStream {
-  private:
-	std::vector<MessageEncapsulator> m_Encapsulators;
+  protected:
+	std::vector<std::shared_ptr<MessageEncapsulator>> m_Encapsulators;
 	std::shared_ptr<IoInterface> m_Stream;
 
 	using MessageBaseType = typename TMessageFactory::MessageBaseType;
@@ -19,11 +19,30 @@ class MessageStream {
   public:
 	MessageStream(std::shared_ptr<IoInterface>&& a_Stream) : m_Stream(std::move(a_Stream)) {}
 
+	template<typename... TEnc>
+	MessageStream(std::shared_ptr<IoInterface>&& a_Stream, TEnc&&... a_Encapsulators) :
+		m_Stream(std::move(a_Stream)){
+			m_Encapsulators.reserve(sizeof...(a_Encapsulators));
+			AddEncapsulators(std::move(a_Encapsulators ...));
+		}
+
 	std::unique_ptr<MessageBaseType> ReadMessage();
 	std::unique_ptr<MessageBaseType> ReadMessage(MessageIdType a_Id);
 
 	void WriteMessage(const MessageBaseType& a_Message, bool a_WriteId = true);
 
+	template<typename... Args>
+	void AddEncapsulators(Args&& ... a_Encapsulators) {
+		AddEncapsulators(std::move(std::make_tuple<>(a_Encapsulators ...)));
+	}
+
+	template<typename... Args>
+	void AddEncapsulators(std::tuple<Args...>&& a_Encapsulators) {
+		TupleForEach([this](auto&& a_Encapsulator){
+			m_Encapsulators.push_back(std::move(a_Encapsulator));
+		}, a_Encapsulators);
+	}
+
   private:
 	DataBuffer ReadAndDecapsulate();
 	std::unique_ptr<MessageBaseType> MakeMessage(DataBuffer& buffer, MessageIdType a_Id);

include/sp/io/MessageStream.inl

@@ -12,8 +12,8 @@ DataBuffer MessageStream<TMessageFactory>::ReadAndDecapsulate() {
 	std::size_t amount = messageLength.GetValue();
 	DataBuffer buffer = m_Stream->Read(amount);
 	
-	for (MessageEncapsulator& enc : m_Encapsulators) {
-		buffer = enc.Decapsulate(buffer);
+	for (auto& enc : m_Encapsulators) {
+		buffer = enc->Decapsulate(buffer);
 	}
 
 	return buffer;
@@ -51,8 +51,8 @@ void MessageStream<TMessageFactory>::WriteMessage(const MessageBaseType& a_Messa
 	if (a_WriteId)
 		buffer << VarInt{static_cast<std::uint64_t>(a_Message.GetId())};
 	buffer << a_Message.Write();
-	for (MessageEncapsulator& enc : m_Encapsulators) {
-		buffer = enc.Encapsulate(buffer);
+	for (auto& enc : m_Encapsulators) {
+		buffer = enc->Encapsulate(buffer);
 	}
 	DataBuffer header;
 	header << VarInt{buffer.GetSize()};