From 6c2ae22feba9116b1f736b701e36e74ab5b5b794 Mon Sep 17 00:00:00 2001 From: rtk0c Date: Sat, 21 Aug 2021 14:39:17 -0700 Subject: Add read/write logic for all ints and floats --- core/src/Utils/IO/DataStream.cpp | 278 ++++++++++++++++++++++++++++++++++++++- core/src/Utils/IO/DataStream.hpp | 184 +++++++++++++------------- 2 files changed, 369 insertions(+), 93 deletions(-) (limited to 'core') diff --git a/core/src/Utils/IO/DataStream.cpp b/core/src/Utils/IO/DataStream.cpp index 0e0a37b..95e0b09 100644 --- a/core/src/Utils/IO/DataStream.cpp +++ b/core/src/Utils/IO/DataStream.cpp @@ -1,6 +1,280 @@ #include "DataStream.hpp" -DataStream::DataStream() - : mEndian{ LittleEndian } +#include +#include + +static_assert(std::numeric_limits::is_iec559, "Non IEE754/IEC559 'float' is not supported."); +static_assert(std::numeric_limits::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 } +{ +} + +DataStream::~DataStream() = default; + +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(buffer), static_cast(byteCount)); +} + +void DataStream::ReadBytes(size_t byteCount, char* buffer) +{ + mBackend.read(reinterpret_cast(buffer), static_cast(byteCount)); +} + +void DataStream::ReadBytes(size_t byteCount, signed char* buffer) +{ + mBackend.read(reinterpret_cast(buffer), static_cast(byteCount)); +} + +void DataStream::ReadBytes(size_t byteCount, unsigned char* buffer) +{ + mBackend.read(reinterpret_cast(buffer), static_cast(byteCount)); +} + +void DataStream::WriteBytes(size_t byteCount, const std::byte* buffer) +{ + mBackend.write(reinterpret_cast(buffer), static_cast(byteCount)); +} + +void DataStream::WriteBytes(size_t byteCount, const char* buffer) +{ + mBackend.write(reinterpret_cast(buffer), static_cast(byteCount)); +} + +void DataStream::WriteBytes(size_t byteCount, const signed char* buffer) +{ + mBackend.write(reinterpret_cast(buffer), static_cast(byteCount)); +} + +void DataStream::WriteBytes(size_t byteCount, const unsigned char* buffer) +{ + mBackend.write(reinterpret_cast(buffer), static_cast(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) +{ + auto bytes = reinterpret_cast(n); + std::swap(bytes[0], bytes[1]); + return n; +} + +uint32_t ByteSwap(uint32_t n) +{ +#ifdef _MSC_VER + // TODO +#else + return __builtin_bswap32(n); +#endif +} + +uint64_t ByteSwap(uint64_t n) +{ +#ifdef _MSC_VER + // TODO +#else + return __builtin_bswap64(n); +#endif +} + +template +TSigned ByteSwap(TSigned n) +{ + using Unsigned = std::make_unsigned_t; + + auto swapped = ::ByteSwap(std::bit_cast(n)); + return std::bit_cast(swapped); +} + +void DataStream::Write(int8_t n) +{ + mBackend.write(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Write(int16_t n) +{ + if (mEndian != std::endian::native) { + n = ::ByteSwap(n); + } + mBackend.write(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Write(int32_t n) +{ + if (mEndian != std::endian::native) { + n = ::ByteSwap(n); + } + mBackend.write(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Write(int64_t n) +{ + if (mEndian != std::endian::native) { + n = ::ByteSwap(n); + } + mBackend.write(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Read(int8_t& n) +{ + // sizeof() of a reference type yields the size of the reference + mBackend.read(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Read(int16_t& n) +{ + int16_t tmp; + mBackend.read(reinterpret_cast(&tmp), sizeof(tmp)); + if (mEndian != std::endian::native) { + n = ::ByteSwap(tmp); + } else { + n = tmp; + } +} + +void DataStream::Read(int32_t& n) +{ + int32_t tmp; + mBackend.read(reinterpret_cast(&tmp), sizeof(tmp)); + if (mEndian != std::endian::native) { + n = ::ByteSwap(tmp); + } else { + n = tmp; + } +} + +void DataStream::Read(int64_t& n) +{ + int64_t tmp; + mBackend.read(reinterpret_cast(&tmp), sizeof(tmp)); + if (mEndian != std::endian::native) { + n = ::ByteSwap(tmp); + } else { + n = tmp; + } +} + +void DataStream::Write(uint8_t n) +{ + mBackend.write(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Write(uint16_t n) +{ + if (mEndian != std::endian::native) { + n = ::ByteSwap(n); + } + mBackend.write(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Write(uint32_t n) +{ + if (mEndian != std::endian::native) { + n = ::ByteSwap(n); + } + mBackend.write(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Write(uint64_t n) { + if (mEndian != std::endian::native) { + n = ::ByteSwap(n); + } + mBackend.write(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Read(uint8_t& n) +{ + mBackend.read(reinterpret_cast(&n), sizeof(n)); +} + +void DataStream::Read(uint16_t& n) +{ + uint16_t tmp; + mBackend.read(reinterpret_cast(&tmp), sizeof(tmp)); + if (mEndian != std::endian::native) { + n = ::ByteSwap(tmp); + } else { + n = tmp; + } +} + +void DataStream::Read(uint32_t& n) +{ + uint32_t tmp; + mBackend.read(reinterpret_cast(&tmp), sizeof(tmp)); + if (mEndian != std::endian::native) { + n = ::ByteSwap(tmp); + } else { + n = tmp; + } +} + +void DataStream::Read(uint64_t& n) +{ + uint64_t tmp; + mBackend.read(reinterpret_cast(&tmp), sizeof(tmp)); + if (mEndian != std::endian::native) { + n = ::ByteSwap(tmp); + } else { + n = tmp; + } +} + +void DataStream::Write(float n) +{ + auto buffer = std::bit_cast(n); + if (mEndian != std::endian::native) { + buffer = ::ByteSwap(buffer); + } + mBackend.read(reinterpret_cast(&buffer), sizeof(buffer)); +} + +void DataStream::Write(double n) +{ + auto buffer = std::bit_cast(n); + if (mEndian != std::endian::native) { + buffer = ::ByteSwap(buffer); + } + mBackend.read(reinterpret_cast(&buffer), sizeof(buffer)); +} + +void DataStream::Read(float& n) +{ + uint32_t buffer; + Read(buffer); + + if (mEndian != std::endian::native) { + buffer = ::ByteSwap(buffer); + } + + n = std::bit_cast(buffer); +} + +void DataStream::Read(double& n) +{ + uint64_t buffer; + Read(buffer); + + if (mEndian != std::endian::native) { + buffer = ::ByteSwap(buffer); + } + + n = std::bit_cast(buffer); } diff --git a/core/src/Utils/IO/DataStream.hpp b/core/src/Utils/IO/DataStream.hpp index a88fe07..b965263 100644 --- a/core/src/Utils/IO/DataStream.hpp +++ b/core/src/Utils/IO/DataStream.hpp @@ -2,8 +2,10 @@ #include "cplt_fwd.hpp" +#include #include #include +#include #include class SerializationStreamProxy @@ -18,28 +20,16 @@ public: DataStream* Stream; template - void Bytes(size_t byteCount, T* buffer) const - { - Stream->WriteBytes(byteCount, buffer); - } + void Bytes(size_t byteCount, T* buffer) const; template - void Value(T t) const - { - Stream->Write(t); - } + void Value(T t) const; template - void Object(T& obj) const - { - Stream->WriteObject(obj); - } + void Object(T& obj) const; template - void ObjectAdapted(TObject& obj, TAdapter adapter) const - { - Stream->WriteObjectAdapted(obj, adapter); - } + void ObjectAdapted(TObject& obj, TAdapter&& adapter) const; }; class DeserializationStreamProxy @@ -54,66 +44,46 @@ public: DataStream* Stream; template - void Bytes(size_t byteCount, T* buffer) const - { - Stream->WriteBytes(byteCount, buffer); - } + void Bytes(size_t byteCount, T* buffer) const; template - void Value(T& t) const - { - Stream->Read(t); - } + void Value(T& t) const; template - void Object(T& obj) const - { - Stream->ReadObject(obj); - } + void Object(T& obj) const; template - void ObjectAdapted(TObject& obj, TAdapter& adapter) const - { - Stream->ReadObjectAdapted(obj, adapter); - } + void ObjectAdapted(TObject& obj, TAdapter&& adapter) const; }; -namespace DataStreamTraits { - -template -concept HasMember = requires(T t) -{ - t.ReadFromDataStream(std::declval()); - t.WriteToDataStream(std::declval()); -}; - -template -concept HasIOAdapterMember = requires(T t) -{ - t.OperateIOProxy(std::declval()); - t.OperateIOProxy(std::declval()); -}; - -} // namespace DataStreamTraits - class DataStream { -public: - enum Endianness - { - BigEndian, - LittleEndian, - }; - private: - Endianness mEndian; + // TODO customizable storage lik QIODevice + // TODO move read/write into separate classes, removing need of IOAdapters? + std::fstream mBackend; + std::endian mEndian; public: - DataStream(); + DataStream(std::fstream stream); ~DataStream(); - Endianness GetEndianness() const; - void SetEndianness(Endianness endianness); + std::endian GetEndianness() const; + void SetEndianness(std::endian endianness); + + void WriteBytes(size_t byteCount, const std::byte* buffer); + void WriteBytes(size_t byteCount, const char* buffer); + void WriteBytes(size_t byteCount, const signed char* buffer); + void WriteBytes(size_t byteCount, const unsigned char* buffer); + + template + void WriteBytes(TIterator&& begin, TIterator&& end) + { + for (; begin != end; ++begin) { + uint8_t byte = *begin; + Write(byte); + } + } void ReadBytes(size_t byteCount, std::byte* buffer); void ReadBytes(size_t byteCount, char* buffer); @@ -131,20 +101,6 @@ public: } } - void WriteBytes(size_t byteCount, const std::byte* buffer); - void WriteBytes(size_t byteCount, const char* buffer); - void WriteBytes(size_t byteCount, const signed char* buffer); - void WriteBytes(size_t byteCount, const unsigned char* buffer); - - template - void WriteBytes(TIterator&& begin, TIterator&& end) - { - for (; begin != end; ++begin) { - uint8_t byte = *begin; - Write(byte); - } - } - void Write(int8_t n); void Write(int16_t n); void Write(int32_t n); @@ -172,13 +128,12 @@ public: void Read(double& n); template - void ReadObject(TObject& obj) + void WriteObject(TObject& obj) { - using namespace DataStreamTraits; - if constexpr (requires(TObject t) { t.ReadFromDataStream(std::declval()); }) { - obj.ReadFromDataStream(*this); - } else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval()); }) { - DeserializationStreamProxy adapter{ this }; + if constexpr (requires(TObject t) { t.WriteToDataStream(std::declval()); }) { + obj.WriteToDataStream(*this); + } else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval()); }) { + SerializationStreamProxy adapter{ this }; obj.OperateIOProxy(adapter); } else { static_assert(false && sizeof(TObject), "This type does not have integration with DataStream."); @@ -186,19 +141,18 @@ public: } template - void ReadObjectAdapted(TObject& obj, TAdapter& adapter) + void WriteObjectAdapted(TObject& obj, TAdapter&& adapter) { - adapter.ReadFromDataStream(*this, obj); + adapter.WriteToDataStream(*this, obj); } template - void WriteObject(TObject& obj) + void ReadObject(TObject& obj) { - using namespace DataStreamTraits; - if constexpr (requires(TObject t) { t.WriteToDataStream(std::declval()); }) { - obj.WriteToDataStream(*this); - } else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval()); }) { - SerializationStreamProxy adapter{ this }; + if constexpr (requires(TObject t) { t.ReadFromDataStream(std::declval()); }) { + obj.ReadFromDataStream(*this); + } else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval()); }) { + DeserializationStreamProxy adapter{ this }; obj.OperateIOProxy(adapter); } else { static_assert(false && sizeof(TObject), "This type does not have integration with DataStream."); @@ -206,8 +160,56 @@ public: } template - void WriteObjectAdapted(TObject& obj, TAdapter& adapter) + void ReadObjectAdapted(TObject& obj, TAdapter&& adapter) { - adapter.WriteToDataStream(*this, obj); + adapter.ReadFromDataStream(*this, obj); } }; + +template +void SerializationStreamProxy::Bytes(size_t byteCount, T* buffer) const +{ + Stream->WriteBytes(byteCount, buffer); +} + +template +void SerializationStreamProxy::Value(T t) const +{ + Stream->Write(t); +} + +template +void SerializationStreamProxy::Object(T& obj) const +{ + Stream->WriteObject(obj); +} + +template +void SerializationStreamProxy::ObjectAdapted(TObject& obj, TAdapter&& adapter) const +{ + Stream->WriteObjectAdapted(obj, adapter); +} + +template +void DeserializationStreamProxy::Bytes(size_t byteCount, T* buffer) const +{ + Stream->WriteBytes(byteCount, buffer); +} + +template +void DeserializationStreamProxy::Value(T& t) const +{ + Stream->Read(t); +} + +template +void DeserializationStreamProxy::Object(T& obj) const +{ + Stream->ReadObject(obj); +} + +template +void DeserializationStreamProxy::ObjectAdapted(TObject& obj, TAdapter&& adapter) const +{ + Stream->ReadObjectAdapted(obj, adapter); +} -- cgit v1.2.3-70-g09d2