Persson-dev/Simple-Protocol-Lib
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

generic encapsulator

Browse Source
This commit is contained in:
Simon Pribylski
2025-02-27 22:50:51 +01:00
parent f6620dc522
commit 9fa023f716
5 changed files with 96 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
include/sp/extensions/Compress.h
View File

@@ -11,10 +11,17 @@
namespace sp { namespace sp {
namespace option { namespace option {
struct ZlibCompress {}; struct ZlibCompress {
bool m_Enabled = true;
std::size_t m_CompressionThreshold = 64;
};
} // namespace option } // namespace option
} // namespace sp
#include <sp/io/IOInterface.h>
namespace sp {
namespace zlib { namespace zlib {
/** /**
@@ -33,4 +40,15 @@ DataBuffer Compress(const DataBuffer& buffer, std::size_t a_CompressionThreshold
DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength); DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength);
} // namespace zlib } // 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 } // namespace sp

16
include/sp/io/IOInterface.h
View File

@@ -13,14 +13,14 @@ class IOInterface {
void Write(const DataBuffer& a_Data); void Write(const DataBuffer& a_Data);
}; };
template <typename IOTag> template <typename TOption>
class MessageEncapsulator { class MessageEncapsulator {
public: public:
static DataBuffer Encapsulate(const DataBuffer& a_Data); static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOption& a_Option);
static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length); static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length, const TOption& a_Option);
}; };
template <typename IOTag, typename MessageDispatcher, typename MessageFactory> template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
class Stream { class Stream {
protected: protected:
MessageDispatcher m_Dispatcher; MessageDispatcher m_Dispatcher;
@@ -33,16 +33,16 @@ class Stream {
Stream(IOInterface<IOTag>&& a_Interface); Stream(IOInterface<IOTag>&& a_Interface);
Stream(Stream&& a_Stream); 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);
MessageDispatcher& GetDispatcher() { MessageDispatcher& GetDispatcher() {
return m_Dispatcher; return m_Dispatcher;
} }
private: private:
static DataBuffer Encapsulate(const DataBuffer& a_Data); static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOptions&... a_Options);
static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length); static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length, const TOptions&... a_Options);
}; };
} // namespace io } // namespace io

69
include/sp/io/IOInterfaceImpl.inl
View File

@@ -4,39 +4,60 @@
#include <stdexcept> #include <stdexcept>
namespace sp { namespace sp {
namespace io {
namespace details {
template <typename... TOptions>
struct MessageEncapsulatorPack {};
template <> template <>
class MessageEncapsulator<option::ZlibCompress> { struct MessageEncapsulatorPack<> {
public:
static DataBuffer Encapsulate(const DataBuffer& a_Data) { static DataBuffer Encapsulate(const DataBuffer& a_Data) {
return zlib::Compress(a_Data); return a_Data;
} }
static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length) { static DataBuffer Decapsulate(DataBuffer& a_Data, std::size_t a_Length) {
return zlib::Decompress(a_Data, a_Length); return a_Data;
} }
}; };
template <typename IOTag, typename MessageDispatcher, typename MessageFactory> template <typename TOption, typename... TOptions>
Stream<IOTag, MessageDispatcher, MessageFactory>::Stream(IOInterface<IOTag>&& a_Interface) : m_Interface(std::move(a_Interface)) {} 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...);
}
};
template <typename IOTag, typename MessageDispatcher, typename MessageFactory> } // namespace details
Stream<IOTag, MessageDispatcher, MessageFactory>::Stream(Stream<IOTag, MessageDispatcher, MessageFactory>&& a_Stream) :
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)) {} m_Dispatcher(std::move(a_Stream.m_Dispatcher)), m_Interface(std::move(a_Stream.m_Interface)) {}
template <typename IOTag, typename MessageDispatcher, typename MessageFactory> template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
void Stream<IOTag, MessageDispatcher, MessageFactory>::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 data = a_Message.Write();
DataBuffer encapsulated = Encapsulate(data); DataBuffer encapsulated = Encapsulate(data, a_Options...);
DataBuffer finalData; DataBuffer finalData;
finalData << VarInt{encapsulated.GetSize()} << encapsulated; finalData << VarInt{encapsulated.GetSize()} << encapsulated;
m_Interface.Write(finalData); m_Interface.Write(finalData);
} }
template <typename IOTag, typename MessageDispatcher, typename MessageFactory> template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
void Stream<IOTag, MessageDispatcher, MessageFactory>::RecieveMessages() { void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::RecieveMessages(const TOptions&... a_Options) {
while (true) { while (true) {
// reading the first VarInt part byte by byte // reading the first VarInt part byte by byte
std::uint64_t lenghtValue = 0; std::uint64_t lenghtValue = 0;
unsigned int readPos = 0; unsigned int readPos = 0;
@@ -71,7 +92,7 @@ void Stream<IOTag, MessageDispatcher, MessageFactory>::RecieveMessages() {
DataBuffer buffer; DataBuffer buffer;
buffer = m_Interface.Read(lenghtValue); buffer = m_Interface.Read(lenghtValue);
buffer = Decapsulate(buffer, lenghtValue); buffer = Decapsulate(buffer, lenghtValue, a_Options...);
VarInt packetType; VarInt packetType;
buffer >> packetType; buffer >> packetType;
@@ -88,16 +109,16 @@ void Stream<IOTag, MessageDispatcher, MessageFactory>::RecieveMessages() {
} }
} }
template <typename IOTag, typename MessageDispatcher, typename MessageFactory> template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory>::Encapsulate(const DataBuffer& a_Data) { DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Encapsulate(
// TODO: process compress + encryption const DataBuffer& a_Data, const TOptions&... a_Options) {
return MessageEncapsulator<option::ZlibCompress>::Encapsulate(a_Data); return details::MessageEncapsulatorPack<TOptions...>::Encapsulate(a_Data, a_Options...);
} }
template <typename IOTag, typename MessageDispatcher, typename MessageFactory> template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory>::Decapsulate(DataBuffer& a_Data, std::size_t a_Length) { DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Decapsulate(
// TODO: process compress + encryption DataBuffer& a_Data, std::size_t a_Length, const TOptions&... a_Options) {
return MessageEncapsulator<option::ZlibCompress>::Decapsulate(a_Data, a_Length); return details::MessageEncapsulatorPack<TOptions...>::Decapsulate(a_Data, a_Length, a_Options...);
} }
} // namespace io } // namespace io

13
src/sp/extensions/Compress.cpp
View File

@@ -73,4 +73,17 @@ DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength) {
} }
} // namespace zlib } // 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 } // namespace sp

16
test/test_file.cpp
View File

@@ -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() { int main() {
auto handler = std::make_shared<CustomPacketHandler>(); auto handler = std::make_shared<CustomPacketHandler>();
@@ -26,11 +26,17 @@ int main() {
stream.GetDispatcher().RegisterHandler(PacketId::Disconnect, handler); stream.GetDispatcher().RegisterHandler(PacketId::Disconnect, handler);
stream.GetDispatcher().RegisterHandler(PacketId::KeepAlive, handler); 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.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; return 0;
} }