aboutsummaryrefslogtreecommitdiff
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/src/Utils/IO/Archive.cpp37
-rw-r--r--core/src/Utils/IO/Archive.hpp14
-rw-r--r--core/src/Utils/IO/DataStream.cpp283
-rw-r--r--core/src/Utils/IO/DataStream.hpp227
-rw-r--r--core/src/Utils/IO/StringIntegration.hpp8
-rw-r--r--core/src/Utils/IO/UuidIntegration.hpp5
-rw-r--r--core/src/Utils/IO/VectorIntegration.hpp6
-rw-r--r--core/src/Utils/IO/fwd.hpp8
8 files changed, 276 insertions, 312 deletions
diff --git a/core/src/Utils/IO/Archive.cpp b/core/src/Utils/IO/Archive.cpp
index 559c476..b6f806b 100644
--- a/core/src/Utils/IO/Archive.cpp
+++ b/core/src/Utils/IO/Archive.cpp
@@ -10,23 +10,9 @@ constexpr uint8_t kByteOrderMark = []() {
}
}();
-std::optional<DataArchive> DataArchive::SaveFile(const std::filesystem::path& path)
+std::optional<InputDataStream> DataArchive::LoadFile(const std::filesystem::path& path)
{
- auto archive = DataArchive(DataStream(std::fstream(path)));
- auto& stream = archive.mStream;
-
- stream.WriteBytes(kMagicNumberCount, kMagicNumbers);
- stream.Write(kByteOrderMark);
-
- stream.SetEndianness(std::endian::native);
-
- return archive;
-}
-
-std::optional<DataArchive> DataArchive::LoadFile(const std::filesystem::path& path)
-{
- auto archive = DataArchive(DataStream(std::fstream(path)));
- auto& stream = archive.mStream;
+ auto stream = InputDataStream(std::fstream(path));
uint8_t magicNumbers[kMagicNumberCount];
stream.ReadBytes(kMagicNumberCount, magicNumbers);
@@ -46,20 +32,17 @@ std::optional<DataArchive> DataArchive::LoadFile(const std::filesystem::path& pa
default: std::abort();
}
- return archive;
+ return stream;
}
-const DataStream& DataArchive::GetStream() const
+std::optional<OutputDataStream> DataArchive::SaveFile(const std::filesystem::path& path)
{
- return mStream;
-}
+ auto stream = OutputDataStream(std::fstream(path));
-DataStream& DataArchive::GetStream()
-{
- return mStream;
-}
+ stream.WriteBytes(kMagicNumberCount, kMagicNumbers);
+ stream.Write(kByteOrderMark);
-DataArchive::DataArchive(DataStream stream)
- : mStream(std::move(stream))
-{
+ stream.SetEndianness(std::endian::native);
+
+ return stream;
}
diff --git a/core/src/Utils/IO/Archive.hpp b/core/src/Utils/IO/Archive.hpp
index 72f79c6..28e7c99 100644
--- a/core/src/Utils/IO/Archive.hpp
+++ b/core/src/Utils/IO/Archive.hpp
@@ -7,16 +7,8 @@
class DataArchive
{
-private:
- DataStream mStream;
-
public:
- static std::optional<DataArchive> SaveFile(const std::filesystem::path& path);
- static std::optional<DataArchive> LoadFile(const std::filesystem::path& path);
-
- const DataStream& GetStream()const;
- DataStream& GetStream();
-
-private:
- DataArchive(DataStream stream);
+ // TODO more complete impl
+ static std::optional<InputDataStream> LoadFile(const std::filesystem::path& path);
+ static std::optional<OutputDataStream> SaveFile(const std::filesystem::path& path);
};
diff --git a/core/src/Utils/IO/DataStream.cpp b/core/src/Utils/IO/DataStream.cpp
index 4880901..7fee881 100644
--- a/core/src/Utils/IO/DataStream.cpp
+++ b/core/src/Utils/IO/DataStream.cpp
@@ -2,78 +2,23 @@
#include <bit>
#include <limits>
+#include <utility>
static_assert(std::numeric_limits<float>::is_iec559, "Non IEE754/IEC559 'float' is not supported.");
static_assert(std::numeric_limits<double>::is_iec559, "Non IEE754/IEC559 'double' is not supported.");
static_assert(std::endian::native == std::endian::little || std::endian::native == std::endian::big, "Mixed endian is not supported.");
-DataStream::DataStream(std::fstream stream)
- : mBackend{ std::move(stream) }
- , mEndian{ std::endian::big }
-{
-}
-
-std::endian DataStream::GetEndianness() const
-{
- return mEndian;
-}
-
-void DataStream::SetEndianness(std::endian endianness)
-{
- mEndian = endianness;
-}
-
-void DataStream::ReadBytes(size_t byteCount, std::byte* buffer)
-{
- mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::ReadBytes(size_t byteCount, char* buffer)
-{
- mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::ReadBytes(size_t byteCount, signed char* buffer)
-{
- mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::ReadBytes(size_t byteCount, unsigned char* buffer)
-{
- mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::WriteBytes(size_t byteCount, const std::byte* buffer)
-{
- mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::WriteBytes(size_t byteCount, const char* buffer)
-{
- mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::WriteBytes(size_t byteCount, const signed char* buffer)
-{
- mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::WriteBytes(size_t byteCount, const unsigned char* buffer)
-{
- mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
// Reading/writing signed integer byte-by-byte is fine, since the representation got fixed to 2's complements in C++20
-uint16_t ByteSwap(uint16_t n)
+static uint16_t ByteSwap(uint16_t n)
{
auto bytes = reinterpret_cast<std::byte*>(n);
std::swap(bytes[0], bytes[1]);
return n;
}
-uint32_t ByteSwap(uint32_t n)
+static uint32_t ByteSwap(uint32_t n)
{
#ifdef _MSC_VER
// TODO
@@ -82,7 +27,7 @@ uint32_t ByteSwap(uint32_t n)
#endif
}
-uint64_t ByteSwap(uint64_t n)
+static uint64_t ByteSwap(uint64_t n)
{
#ifdef _MSC_VER
// TODO
@@ -92,7 +37,7 @@ uint64_t ByteSwap(uint64_t n)
}
template <class TSigned>
-TSigned ByteSwap(TSigned n)
+static TSigned ByteSwap(TSigned n)
{
using Unsigned = std::make_unsigned_t<TSigned>;
@@ -100,179 +45,239 @@ TSigned ByteSwap(TSigned n)
return std::bit_cast<TSigned>(swapped);
}
-void DataStream::Write(int8_t n)
+std::endian BaseDataStream::GetEndianness() const
{
- mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+ return mEndian;
}
-void DataStream::Write(int16_t n)
+void BaseDataStream::SetEndianness(std::endian endianness)
{
- if (mEndian != std::endian::native) {
- n = ::ByteSwap(n);
- }
- mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+ mEndian = endianness;
}
-void DataStream::Write(int32_t n)
+InputDataStream::InputDataStream(std::fstream stream)
+ : mBackend{ std::move(stream) }
{
- if (mEndian != std::endian::native) {
- n = ::ByteSwap(n);
- }
- mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
}
-void DataStream::Write(int64_t n)
+void InputDataStream::ReadBytes(size_t byteCount, std::byte* buffer)
{
- if (mEndian != std::endian::native) {
- n = ::ByteSwap(n);
- }
- mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+ mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void InputDataStream::ReadBytes(size_t byteCount, char* buffer)
+{
+ mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void InputDataStream::ReadBytes(size_t byteCount, signed char* buffer)
+{
+ mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void InputDataStream::ReadBytes(size_t byteCount, unsigned char* buffer)
+{
+ mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
}
-void DataStream::Read(int8_t& n)
+void InputDataStream::Read(int8_t& n)
{
// sizeof() of a reference type yields the size of the reference
mBackend.read(reinterpret_cast<char*>(&n), sizeof(n));
}
-void DataStream::Read(int16_t& n)
+void InputDataStream::Read(int16_t& n)
{
int16_t tmp;
mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
- if (mEndian != std::endian::native) {
+ if (GetEndianness() != std::endian::native) {
n = ::ByteSwap(tmp);
} else {
n = tmp;
}
}
-void DataStream::Read(int32_t& n)
+void InputDataStream::Read(int32_t& n)
{
int32_t tmp;
mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
- if (mEndian != std::endian::native) {
+ if (GetEndianness() != std::endian::native) {
n = ::ByteSwap(tmp);
} else {
n = tmp;
}
}
-void DataStream::Read(int64_t& n)
+void InputDataStream::Read(int64_t& n)
{
int64_t tmp;
mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
- if (mEndian != std::endian::native) {
+ if (GetEndianness() != std::endian::native) {
n = ::ByteSwap(tmp);
} else {
n = tmp;
}
}
-void DataStream::Write(uint8_t n)
-{
- mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
-}
-
-void DataStream::Write(uint16_t n)
-{
- if (mEndian != std::endian::native) {
- n = ::ByteSwap(n);
- }
- mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
-}
-
-void DataStream::Write(uint32_t n)
-{
- if (mEndian != std::endian::native) {
- n = ::ByteSwap(n);
- }
- mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
-}
-
-void DataStream::Write(uint64_t n)
-{
- if (mEndian != std::endian::native) {
- n = ::ByteSwap(n);
- }
- mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
-}
-
-void DataStream::Read(uint8_t& n)
+void InputDataStream::Read(uint8_t& n)
{
mBackend.read(reinterpret_cast<char*>(&n), sizeof(n));
}
-void DataStream::Read(uint16_t& n)
+void InputDataStream::Read(uint16_t& n)
{
uint16_t tmp;
mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
- if (mEndian != std::endian::native) {
+ if (GetEndianness() != std::endian::native) {
n = ::ByteSwap(tmp);
} else {
n = tmp;
}
}
-void DataStream::Read(uint32_t& n)
+void InputDataStream::Read(uint32_t& n)
{
uint32_t tmp;
mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
- if (mEndian != std::endian::native) {
+ if (GetEndianness() != std::endian::native) {
n = ::ByteSwap(tmp);
} else {
n = tmp;
}
}
-void DataStream::Read(uint64_t& n)
+void InputDataStream::Read(uint64_t& n)
{
uint64_t tmp;
mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
- if (mEndian != std::endian::native) {
+ if (GetEndianness() != std::endian::native) {
n = ::ByteSwap(tmp);
} else {
n = tmp;
}
}
-void DataStream::Write(float n)
+void InputDataStream::Read(float& n)
{
- auto buffer = std::bit_cast<uint32_t>(n);
- if (mEndian != std::endian::native) {
+ uint32_t buffer;
+ Read(buffer);
+
+ if (GetEndianness() != std::endian::native) {
buffer = ::ByteSwap(buffer);
}
- mBackend.read(reinterpret_cast<char*>(&buffer), sizeof(buffer));
+
+ n = std::bit_cast<float>(buffer);
}
-void DataStream::Write(double n)
+void InputDataStream::Read(double& n)
{
- auto buffer = std::bit_cast<uint64_t>(n);
- if (mEndian != std::endian::native) {
+ uint64_t buffer;
+ Read(buffer);
+
+ if (GetEndianness() != std::endian::native) {
buffer = ::ByteSwap(buffer);
}
- mBackend.read(reinterpret_cast<char*>(&buffer), sizeof(buffer));
+
+ n = std::bit_cast<double>(buffer);
}
-void DataStream::Read(float& n)
+OutputDataStream::OutputDataStream(std::fstream stream)
+ : mBackend{ std::move(stream) }
{
- uint32_t buffer;
- Read(buffer);
+}
- if (mEndian != std::endian::native) {
- buffer = ::ByteSwap(buffer);
+void OutputDataStream::WriteBytes(size_t byteCount, const std::byte* buffer)
+{
+ mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void OutputDataStream::WriteBytes(size_t byteCount, const char* buffer)
+{
+ mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void OutputDataStream::WriteBytes(size_t byteCount, const signed char* buffer)
+{
+ mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void OutputDataStream::WriteBytes(size_t byteCount, const unsigned char* buffer)
+{
+ mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void OutputDataStream::Write(int8_t n)
+{
+ mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(int16_t n)
+{
+ if (GetEndianness() != std::endian::native) {
+ n = ::ByteSwap(n);
}
+ mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
- n = std::bit_cast<float>(buffer);
+void OutputDataStream::Write(int32_t n)
+{
+ if (GetEndianness() != std::endian::native) {
+ n = ::ByteSwap(n);
+ }
+ mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
}
-void DataStream::Read(double& n)
+void OutputDataStream::Write(int64_t n)
{
- uint64_t buffer;
- Read(buffer);
+ if (GetEndianness() != std::endian::native) {
+ n = ::ByteSwap(n);
+ }
+ mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(uint8_t n)
+{
+ mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(uint16_t n)
+{
+ if (GetEndianness() != std::endian::native) {
+ n = ::ByteSwap(n);
+ }
+ mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
- if (mEndian != std::endian::native) {
+void OutputDataStream::Write(uint32_t n)
+{
+ if (GetEndianness() != std::endian::native) {
+ n = ::ByteSwap(n);
+ }
+ mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(uint64_t n)
+{
+ if (GetEndianness() != std::endian::native) {
+ n = ::ByteSwap(n);
+ }
+ mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(float n)
+{
+ auto buffer = std::bit_cast<uint32_t>(n);
+ if (GetEndianness() != std::endian::native) {
buffer = ::ByteSwap(buffer);
}
+ mBackend.read(reinterpret_cast<char*>(&buffer), sizeof(buffer));
+}
- n = std::bit_cast<double>(buffer);
+void OutputDataStream::Write(double n)
+{
+ auto buffer = std::bit_cast<uint64_t>(n);
+ if (GetEndianness() != std::endian::native) {
+ buffer = ::ByteSwap(buffer);
+ }
+ mBackend.read(reinterpret_cast<char*>(&buffer), sizeof(buffer));
}
diff --git a/core/src/Utils/IO/DataStream.hpp b/core/src/Utils/IO/DataStream.hpp
index 8dca00f..d1f3647 100644
--- a/core/src/Utils/IO/DataStream.hpp
+++ b/core/src/Utils/IO/DataStream.hpp
@@ -8,67 +8,116 @@
#include <fstream>
#include <span>
-class SerializationStreamProxy
+class BaseDataStream
{
+private:
+ std::endian mEndian = std::endian::big;
+
+public:
+ std::endian GetEndianness() const;
+ void SetEndianness(std::endian endianness);
+};
+
+class InputDataStream : public BaseDataStream
+{
+private:
+ std::fstream mBackend;
+
public:
static constexpr bool IsSerializer()
{
- return true;
+ return false;
}
-public:
- DataStream* Stream;
+ InputDataStream(std::fstream stream);
- template <class T>
- void Bytes(size_t byteCount, T* buffer) const;
+ void ReadBytes(size_t byteCount, std::byte* buffer);
+ void ReadBytes(size_t byteCount, char* buffer);
+ void ReadBytes(size_t byteCount, signed char* buffer);
+ void ReadBytes(size_t byteCount, unsigned char* buffer);
- template <class T>
- void Value(T t) const;
+ template <class TInserter>
+ void ReadBytes(size_t byteCount, TInserter&& inserter)
+ {
+ for (size_t i = 0; i < byteCount; ++i) {
+ uint8_t byte;
+ Read(byte);
- template <class T>
- void Object(T& obj) const;
+ inserter = byte;
+ }
+ }
- template <class TObject, class TAdapter>
- void ObjectAdapted(TObject& obj, TAdapter&& adapter) const;
-};
+ void Read(int8_t& n);
+ void Read(int16_t& n);
+ void Read(int32_t& n);
+ void Read(int64_t& n);
-class DeserializationStreamProxy
-{
-public:
- static constexpr bool IsSerializer()
+ void Read(uint8_t& n);
+ void Read(uint16_t& n);
+ void Read(uint32_t& n);
+ void Read(uint64_t& n);
+
+ void Read(float& n);
+ void Read(double& n);
+
+ template <class TObject>
+ void ReadObject(TObject& obj)
{
- return false;
+ if constexpr (requires(TObject t) { t.ReadFromDataStream(std::declval<BaseDataStream>()); }) {
+ obj.ReadFromDataStream(*this);
+ } else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval<DataInputStream>()); }) {
+ obj.OperateIOProxy(*this);
+ } else {
+ static_assert(false && sizeof(TObject), "This type does not have integration with InputDataStream.");
+ }
+ }
+
+ template <class TObject, class TAdapter>
+ void ReadObjectAdapted(TObject& obj, TAdapter&& adapter)
+ {
+ adapter.ReadFromDataStream(*this, obj);
}
public:
- DataStream* Stream;
+ // Proxy functions for OperateIOProxy
template <class T>
- void Bytes(size_t byteCount, T* buffer) const;
+ void Bytes(size_t byteCount, T* buffer) const
+ {
+ ReadBytes(byteCount, buffer);
+ }
template <class T>
- void Value(T& t) const;
+ void Value(T& t) const
+ {
+ Read(t);
+ }
template <class T>
- void Object(T& obj) const;
+ void Object(T& obj) const
+ {
+ ReadObject(obj);
+ }
template <class TObject, class TAdapter>
- void ObjectAdapted(TObject& obj, TAdapter&& adapter) const;
+ void ObjectAdapted(TObject& obj, TAdapter&& adapter) const
+ {
+ ReadObjectAdapted(obj, adapter);
+ }
};
-class DataStream
+class OutputDataStream : public BaseDataStream
{
private:
- // TODO customizable storage lik QIODevice
- // TODO move read/write into separate classes, removing need of IOAdapters?
std::fstream mBackend;
- std::endian mEndian;
public:
- DataStream(std::fstream stream);
+ static constexpr bool IsSerializer()
+ {
+ return true;
+ }
- std::endian GetEndianness() const;
- void SetEndianness(std::endian endianness);
+ OutputDataStream(std::fstream stream);
void WriteBytes(size_t byteCount, const std::byte* buffer);
void WriteBytes(size_t byteCount, const char* buffer);
@@ -84,58 +133,28 @@ public:
}
}
- void ReadBytes(size_t byteCount, std::byte* buffer);
- void ReadBytes(size_t byteCount, char* buffer);
- void ReadBytes(size_t byteCount, signed char* buffer);
- void ReadBytes(size_t byteCount, unsigned char* buffer);
-
- template <class TInserter>
- void ReadBytes(size_t byteCount, TInserter&& inserter)
- {
- for (size_t i = 0; i < byteCount; ++i) {
- uint8_t byte;
- Read(byte);
-
- inserter = byte;
- }
- }
-
void Write(int8_t n);
void Write(int16_t n);
void Write(int32_t n);
void Write(int64_t n);
- void Read(int8_t& n);
- void Read(int16_t& n);
- void Read(int32_t& n);
- void Read(int64_t& n);
-
void Write(uint8_t n);
void Write(uint16_t n);
void Write(uint32_t n);
void Write(uint64_t n);
- void Read(uint8_t& n);
- void Read(uint16_t& n);
- void Read(uint32_t& n);
- void Read(uint64_t& n);
-
void Write(float n);
void Write(double n);
- void Read(float& n);
- void Read(double& n);
-
template <class TObject>
void WriteObject(TObject& obj)
{
- if constexpr (requires(TObject t) { t.WriteToDataStream(std::declval<DataStream>()); }) {
+ if constexpr (requires(TObject t) { t.WriteToDataStream(std::declval<BaseDataStream>()); }) {
obj.WriteToDataStream(*this);
- } else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval<SerializationStreamProxy>()); }) {
- SerializationStreamProxy adapter{ this };
- obj.OperateIOProxy(adapter);
+ } else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval<DataOutputStream>()); }) {
+ obj.OperateIOProxy(*this);
} else {
- static_assert(false && sizeof(TObject), "This type does not have integration with DataStream.");
+ static_assert(false && sizeof(TObject), "This type does not have integration with OutputDataStream.");
}
}
@@ -145,70 +164,30 @@ public:
adapter.WriteToDataStream(*this, obj);
}
- template <class TObject>
- void ReadObject(TObject& obj)
+public:
+ // Proxy functions for OperateIOProxy
+
+ template <class T>
+ void Bytes(size_t byteCount, T* buffer) const
{
- if constexpr (requires(TObject t) { t.ReadFromDataStream(std::declval<DataStream>()); }) {
- obj.ReadFromDataStream(*this);
- } else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval<DeserializationStreamProxy>()); }) {
- DeserializationStreamProxy adapter{ this };
- obj.OperateIOProxy(adapter);
- } else {
- static_assert(false && sizeof(TObject), "This type does not have integration with DataStream.");
- }
+ WriteBytes(byteCount, buffer);
}
- template <class TObject, class TAdapter>
- void ReadObjectAdapted(TObject& obj, TAdapter&& adapter)
+ template <class T>
+ void Value(T t) const
{
- adapter.ReadFromDataStream(*this, obj);
+ Write(t);
}
-};
-
-template <class T>
-void SerializationStreamProxy::Bytes(size_t byteCount, T* buffer) const
-{
- Stream->WriteBytes(byteCount, buffer);
-}
-
-template <class T>
-void SerializationStreamProxy::Value(T t) const
-{
- Stream->Write(t);
-}
-template <class T>
-void SerializationStreamProxy::Object(T& obj) const
-{
- Stream->WriteObject(obj);
-}
-
-template <class TObject, class TAdapter>
-void SerializationStreamProxy::ObjectAdapted(TObject& obj, TAdapter&& adapter) const
-{
- Stream->WriteObjectAdapted(obj, adapter);
-}
-
-template <class T>
-void DeserializationStreamProxy::Bytes(size_t byteCount, T* buffer) const
-{
- Stream->WriteBytes(byteCount, buffer);
-}
-
-template <class T>
-void DeserializationStreamProxy::Value(T& t) const
-{
- Stream->Read(t);
-}
-
-template <class T>
-void DeserializationStreamProxy::Object(T& obj) const
-{
- Stream->ReadObject(obj);
-}
+ template <class T>
+ void Object(T& obj) const
+ {
+ WriteObject(obj);
+ }
-template <class TObject, class TAdapter>
-void DeserializationStreamProxy::ObjectAdapted(TObject& obj, TAdapter&& adapter) const
-{
- Stream->ReadObjectAdapted(obj, adapter);
-}
+ template <class TObject, class TAdapter>
+ void ObjectAdapted(TObject& obj, TAdapter&& adapter) const
+ {
+ WriteObjectAdapted(obj, adapter);
+ }
+};
diff --git a/core/src/Utils/IO/StringIntegration.hpp b/core/src/Utils/IO/StringIntegration.hpp
index a90ea98..8c5588c 100644
--- a/core/src/Utils/IO/StringIntegration.hpp
+++ b/core/src/Utils/IO/StringIntegration.hpp
@@ -1,5 +1,7 @@
#pragma once
+#include "Utils/IO/DataStream.hpp"
+
#include <iterator>
#include <string>
#include <string_view>
@@ -7,7 +9,7 @@
namespace DataStreamAdapters {
struct String
{
- void ReadFromDataStream(DataStream& s, std::string& str)
+ void ReadFromDataStream(InputDataStream& s, std::string& str)
{
uint64_t size;
s.Read(size);
@@ -17,7 +19,7 @@ struct String
s.ReadBytes(size, std::back_inserter(str));
}
- void WriteToDataStream(DataStream& s, const std::string& str)
+ void WriteToDataStream(OutputDataStream& s, const std::string& str)
{
s.Write((uint64_t)str.size());
s.WriteBytes(str.size(), str.data());
@@ -26,7 +28,7 @@ struct String
struct StringView
{
- void WriteToDataStream(DataStream& s, const std::string_view& str)
+ void WriteToDataStream(OutputDataStream& s, const std::string_view& str)
{
s.Write((uint64_t)str.size());
s.WriteBytes(str.size(), str.data());
diff --git a/core/src/Utils/IO/UuidIntegration.hpp b/core/src/Utils/IO/UuidIntegration.hpp
index b6ca062..605f821 100644
--- a/core/src/Utils/IO/UuidIntegration.hpp
+++ b/core/src/Utils/IO/UuidIntegration.hpp
@@ -1,5 +1,6 @@
#pragma once
+#include "Utils/IO/DataStream.hpp"
#include "Utils/UUID.hpp"
#include <cstddef>
@@ -9,7 +10,7 @@
namespace DataStreamAdapters {
struct Uuid
{
- void ReadFromDataStream(DataStream& s, uuids::uuid& uuid)
+ void ReadFromDataStream(InputDataStream& s, uuids::uuid& uuid)
{
uint8_t buffer[16];
s.ReadBytes(16, buffer);
@@ -17,7 +18,7 @@ struct Uuid
uuid = uuids::uuid(gsl::span<uint8_t, 16>{ buffer });
}
- void WriteToDataStream(DataStream& s, const uuids::uuid& uuid)
+ void WriteToDataStream(OutputDataStream& s, const uuids::uuid& uuid)
{
auto gslSpan = uuid.as_bytes();
s.WriteBytes(gslSpan.size(), gslSpan.data());
diff --git a/core/src/Utils/IO/VectorIntegration.hpp b/core/src/Utils/IO/VectorIntegration.hpp
index ff6e3a8..dedbf29 100644
--- a/core/src/Utils/IO/VectorIntegration.hpp
+++ b/core/src/Utils/IO/VectorIntegration.hpp
@@ -1,12 +1,14 @@
#pragma once
+#include "Utils/IO/DataStream.hpp"
+
#include <vector>
namespace DataStreamAdapters {
struct Vector
{
template <class TElement>
- void ReadFromDataStream(DataStream& s, std::vecetor<TElement>& vec)
+ void ReadFromDataStream(InputDataStream& s, std::vecetor<TElement>& vec)
{
s.Write((uint64_t)vec.size());
for (auto& element : vec) {
@@ -15,7 +17,7 @@ struct Vector
}
template <class TElement>
- void WriteToDataStream(DataStream& s, const std::vecetor<TElement>& vec)
+ void WriteToDataStream(OutputDataStream& s, const std::vecetor<TElement>& vec)
{
uint64_t size;
s >> size;
diff --git a/core/src/Utils/IO/fwd.hpp b/core/src/Utils/IO/fwd.hpp
index f249e34..5bfdb20 100644
--- a/core/src/Utils/IO/fwd.hpp
+++ b/core/src/Utils/IO/fwd.hpp
@@ -3,7 +3,7 @@
// Archive.hpp
class DataArchive;
-// DataStream.hpp
-class SerializationStreamProxy;
-class DeserializationStreamProxy;
-class DataStream;
+// BaseDataStream.hpp
+class BaseDataStream;
+class InputDataStream;
+class OutputDataStream;
generated by cgit v1.2.3-70-g09d2 (git 2.50.1) at 2025-08-21 20:06:32 +0000