125 lines
4.2 KiB
C++
125 lines
4.2 KiB
C++
#pragma once
|
|
|
|
#include <sp/extensions/Compress.h>
|
|
#include <stdexcept>
|
|
|
|
namespace sp {
|
|
|
|
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, typename... TOptions>
|
|
void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::SendMessage(
|
|
const MessageBase& a_Message, const TOptions&... a_Options) {
|
|
DataBuffer data = a_Message.Write();
|
|
DataBuffer encapsulated = Encapsulate(data, a_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(const TOptions&... a_Options) {
|
|
while (true) {
|
|
// reading the first VarInt part byte by byte
|
|
std::uint64_t lenghtValue = 0;
|
|
unsigned int readPos = 0;
|
|
|
|
while (true) {
|
|
static constexpr int SEGMENT_BITS = (1 << 7) - 1;
|
|
static constexpr int CONTINUE_BIT = 1 << 7;
|
|
|
|
DataBuffer buffer = m_Interface.Read(sizeof(std::uint8_t));
|
|
|
|
// eof
|
|
if (buffer.GetSize() == 0)
|
|
return;
|
|
|
|
std::uint8_t part;
|
|
buffer >> part;
|
|
lenghtValue |= static_cast<std::uint64_t>(part & SEGMENT_BITS) << readPos;
|
|
|
|
if ((part & CONTINUE_BIT) == 0)
|
|
break;
|
|
|
|
readPos += 7;
|
|
|
|
if (readPos >= 8 * sizeof(lenghtValue))
|
|
throw std::runtime_error("VarInt is too big");
|
|
}
|
|
|
|
// nothing to read
|
|
if (lenghtValue == 0)
|
|
return;
|
|
|
|
DataBuffer buffer;
|
|
buffer = m_Interface.Read(lenghtValue);
|
|
|
|
buffer = Decapsulate(buffer, lenghtValue, a_Options...);
|
|
|
|
VarInt packetType;
|
|
buffer >> packetType;
|
|
|
|
static const MessageFactory messageFactory;
|
|
|
|
std::unique_ptr<MessageBase> message = messageFactory.CreateMessage(packetType.GetValue());
|
|
|
|
assert(message != nullptr);
|
|
|
|
message->Read(buffer);
|
|
|
|
GetDispatcher().Dispatch(*message);
|
|
}
|
|
}
|
|
|
|
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
|