generic encapsulator

include/sp/extensions/Compress.h

@@ -8,6 +8,19 @@
 #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>
+
 namespace sp {
 namespace zlib {
 
@@ -27,4 +40,15 @@ DataBuffer Compress(const DataBuffer& buffer, std::size_t a_CompressionThreshold
 DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength);
 
 }  // namespace zlib
+
+namespace io {
+
+template <>
+class MessageEncapsulator<option::ZlibCompress> {
+  public:
+	static DataBuffer Encapsulate(const 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
 }  // namespace sp

include/sp/io/IOInterface.h

@@ -13,7 +13,14 @@ class IOInterface {
 	void Write(const DataBuffer& a_Data);
 };
 
-template <typename IOTag, typename MessageDispatcher, typename MessageFactory>
+template <typename TOption>
+class MessageEncapsulator {
+  public:
+	static DataBuffer Encapsulate(const 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>
 class Stream {
   protected:
 	MessageDispatcher m_Dispatcher;
@@ -26,12 +33,16 @@ class Stream {
 	Stream(IOInterface<IOTag>&& a_Interface);
 	Stream(Stream&& a_Stream);
 
-	void RecieveMessages();
-	void SendMessage(const MessageBase& a_Message);
+	void RecieveMessages(const TOptions&... a_Options);
+	void SendMessage(const MessageBase& a_Message, const TOptions&... a_Options);
 
 	MessageDispatcher& GetDispatcher() {
 		return m_Dispatcher;
 	}
+
+  private:
+	static DataBuffer Encapsulate(const 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

@@ -1,30 +1,63 @@
 #pragma once
 
-#include <stdexcept>
 #include <sp/extensions/Compress.h>
+#include <stdexcept>
 
 namespace sp {
-namespace io {
-template <typename IOTag, typename MessageDispatcher, typename MessageFactory>
-Stream<IOTag, MessageDispatcher, MessageFactory>::Stream(IOInterface<IOTag>&& a_Interface) : m_Interface(std::move(a_Interface)) {}
 
-template <typename IOTag, typename MessageDispatcher, typename MessageFactory>
-Stream<IOTag, MessageDispatcher, MessageFactory>::Stream(Stream<IOTag, MessageDispatcher, MessageFactory>&& a_Stream) :
+namespace details {
+
+template <typename... TOptions>
+struct MessageEncapsulatorPack {};
+
+template <>
+struct MessageEncapsulatorPack<> {
+	static DataBuffer Encapsulate(const DataBuffer& a_Data) {
+		return a_Data;
+	}
+	static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length) {
+		return a_Data;
+	}
+};
+
+template <typename TOption, typename... TOptions>
+struct MessageEncapsulatorPack<TOption, TOptions...> {
+	static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOption& a_Option, const TOptions&... a_Options) {
+		DataBuffer data = io::MessageEncapsulator<TOption>::Encapsulate(a_Data, a_Option);
+		return MessageEncapsulatorPack<TOptions...>::Encapsulate(data, 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_Length, a_Option);
+		return MessageEncapsulatorPack<TOptions...>::Decapsulate(data, data.GetSize(), a_Options...);
+	}
+};
+
+}  // namespace details
+
+namespace io {
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(IOInterface<IOTag>&& a_Interface) :
+	m_Interface(std::move(a_Interface)) {}
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(
+	Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>&& a_Stream) :
 	m_Dispatcher(std::move(a_Stream.m_Dispatcher)), m_Interface(std::move(a_Stream.m_Interface)) {}
 
-template <typename IOTag, typename MessageDispatcher, typename MessageFactory>
-void Stream<IOTag, MessageDispatcher, MessageFactory>::SendMessage(const MessageBase& a_Message) {
-	// TODO: process compress + encryption
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::SendMessage(
+	const MessageBase& a_Message, const TOptions&... a_Options) {
 	DataBuffer data = a_Message.Write();
-	DataBuffer compressed = zlib::Compress(data);
-	m_Interface.Write(compressed);
+	DataBuffer encapsulated = Encapsulate(data, a_Options...);
+	DataBuffer finalData;
+	finalData << VarInt{encapsulated.GetSize()} << encapsulated;
+	m_Interface.Write(finalData);
 }
 
-template <typename IOTag, typename MessageDispatcher, typename MessageFactory>
-void Stream<IOTag, MessageDispatcher, MessageFactory>::RecieveMessages() {
-	// TODO: process compress + encryption
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+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;
 		unsigned int readPos = 0;
@@ -59,9 +92,7 @@ void Stream<IOTag, MessageDispatcher, MessageFactory>::RecieveMessages() {
 		DataBuffer buffer;
 		buffer = m_Interface.Read(lenghtValue);
 
-		// TODO: process compress + encryption
-
-		buffer = zlib::Decompress(buffer, lenghtValue);
+		buffer = Decapsulate(buffer, lenghtValue, a_Options...);
 
 		VarInt packetType;
 		buffer >> packetType;
@@ -78,5 +109,17 @@ void Stream<IOTag, MessageDispatcher, MessageFactory>::RecieveMessages() {
 	}
 }
 
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Encapsulate(
+	const DataBuffer& a_Data, const TOptions&... a_Options) {
+	return details::MessageEncapsulatorPack<TOptions...>::Encapsulate(a_Data, a_Options...);
+}
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Decapsulate(
+	DataBuffer& a_Data, std::size_t a_Length, const TOptions&... a_Options) {
+	return details::MessageEncapsulatorPack<TOptions...>::Decapsulate(a_Data, a_Length, a_Options...);
+}
+
 }  // namespace io
 }  // namespace sp

src/sp/extensions/Compress.cpp

@@ -34,21 +34,13 @@ DataBuffer Compress(const DataBuffer& buffer, std::size_t a_CompressionThreshold
 
 	if (buffer.GetSize() < a_CompressionThreshold) {
 		// Don't compress since it's a small packet
-		VarInt compressedDataLength = 0;
-		VarInt packetLength = compressedDataLength.GetSerializedLength() + buffer.GetSize();
-
-		packet << packetLength;
-		packet << compressedDataLength;
+		packet << VarInt{0};
 		packet << buffer;
 		return packet;
 	}
 
 	DataBuffer compressedData = Deflate(buffer.data(), buffer.GetSize());
-
 	VarInt uncompressedDataLength = buffer.GetSize();
-	VarInt packetLength = uncompressedDataLength.GetSerializedLength() + compressedData.GetSize();
-
-	packet << packetLength;
 
 	if (compressedData.GetSize() >= buffer.GetSize()) {
 		// the compression is overkill so we don't send the compressed buffer
@@ -81,4 +73,17 @@ DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength) {
 }
 
 }  // namespace zlib
+
+namespace io {
+
+DataBuffer MessageEncapsulator<option::ZlibCompress>::Encapsulate(const DataBuffer& a_Data, const option::ZlibCompress& a_Option) {
+	return a_Option.m_Enabled ? zlib::Compress(a_Data, a_Option.m_CompressionThreshold) : a_Data;
+}
+
+DataBuffer MessageEncapsulator<option::ZlibCompress>::Decapsulate(
+	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
 }  // namespace sp

test/test_file.cpp

@@ -17,7 +17,7 @@ class CustomPacketHandler : public sp::PacketHandler {
 	}
 };
 
-using FileStream = sp::io::Stream<sp::io::FileTag, sp::PacketDispatcher, sp::PacketFactory>;
+using FileStream = sp::io::Stream<sp::io::FileTag, sp::PacketDispatcher, sp::PacketFactory, sp::option::ZlibCompress>;
 
 int main() {
 	auto handler = std::make_shared<CustomPacketHandler>();
@@ -26,11 +26,17 @@ int main() {
 	stream.GetDispatcher().RegisterHandler(PacketId::Disconnect, handler);
 	stream.GetDispatcher().RegisterHandler(PacketId::KeepAlive, handler);
 
-	stream.SendMessage(KeepAlivePacket{96});
-	stream.SendMessage(KeepAlivePacket{69});
-	stream.SendMessage(DisconnectPacket{"This is in the fiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiile !"});
+	auto zlibOptions = sp::option::ZlibCompress{};
 
-	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;
 }