finish io

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()};