diff --git a/include/Nazara/Core.hpp b/include/Nazara/Core.hpp index a1d87c0a2..50aecb311 100644 --- a/include/Nazara/Core.hpp +++ b/include/Nazara/Core.hpp @@ -1,4 +1,4 @@ -// This file was automatically generated on 17 Nov 2015 at 13:20:45 +// This file was automatically generated on 20 Nov 2015 at 14:22:32 /* Nazara Engine - Core module @@ -55,7 +55,6 @@ #include #include #include -#include #include #include #include @@ -70,6 +69,8 @@ #include #include #include +#include +#include #include #include #include @@ -78,6 +79,7 @@ #include #include #include +#include #include #endif // NAZARA_GLOBAL_CORE_HPP diff --git a/include/Nazara/Core/MemoryStream.hpp b/include/Nazara/Core/MemoryStream.hpp deleted file mode 100644 index 7328b7707..000000000 --- a/include/Nazara/Core/MemoryStream.hpp +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright (C) 2015 Jérôme Leclercq -// This file is part of the "Nazara Engine - Core module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef NAZARA_MEMORYSTREAM_HPP -#define NAZARA_MEMORYSTREAM_HPP - -#include -#include -#include - -namespace Nz -{ - class NAZARA_CORE_API MemoryStream : public Stream - { - public: - MemoryStream(); - MemoryStream(const void* ptr, unsigned int size); - MemoryStream(const MemoryStream&) = default; - MemoryStream(MemoryStream&&) = default; - ~MemoryStream() = default; - - void Clear(); - - bool EndOfStream() const override; - - - const ByteArray& GetBuffer() const; - const UInt8* GetData() const; - UInt64 GetCursorPos() const override; - UInt64 GetSize() const override; - - bool SetCursorPos(UInt64 offset) override; - - MemoryStream& operator=(const MemoryStream&) = default; - MemoryStream& operator=(MemoryStream&&) = default; - - private: - void FlushStream() override; - std::size_t ReadBlock(void* buffer, std::size_t size) override; - std::size_t WriteBlock(const void* buffer, std::size_t size) override; - - ByteArray m_buffer; - UInt64 m_pos; - }; - - class AbstractHash; - - inline bool HashAppend(AbstractHash* hash, const String& string); - NAZARA_CORE_API bool Serialize(SerializationContext& context, const String& string); - NAZARA_CORE_API bool Unserialize(UnserializationContext& context, String* string); -} - -#include - -#endif // NAZARA_MEMORYSTREAM_HPP diff --git a/include/Nazara/Core/MemoryStream.inl b/include/Nazara/Core/MemoryStream.inl deleted file mode 100644 index 61b2f0bb4..000000000 --- a/include/Nazara/Core/MemoryStream.inl +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright (C) 2015 Jérôme Leclercq -// This file is part of the "Nazara Engine - Core module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include - -namespace Nz -{ - inline bool HashAppend(AbstractHash* hash, const MemoryStream& stream) - { - return HashAppend(hash, stream.GetBuffer()); - } -} - -#include diff --git a/include/Nazara/Core/Serializer.hpp b/include/Nazara/Core/Serializer.hpp new file mode 100644 index 000000000..95ca33190 --- /dev/null +++ b/include/Nazara/Core/Serializer.hpp @@ -0,0 +1,44 @@ +// Copyright (C) 2015 Jérôme Leclercq +// This file is part of the "Nazara Engine - Core module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_SERIALIZER_HPP +#define NAZARA_SERIALIZER_HPP + +#include +#include + +namespace Nz +{ + class Stream; + + class Serializer + { + public: + inline Serializer(Stream& stream); + Serializer(const Serializer&) = default; + Serializer(Serializer&&) = default; + ~Serializer() = default; + + inline Endianness GetDataEndianness() const; + inline Stream& GetStream() const; + + inline void SetDataEndianness(Endianness endiannes); + inline void SetStream(Stream& stream); + + template + Serializer& operator<<(const T& value); + + Serializer& operator=(const Serializer&) = default; + Serializer& operator=(Serializer&&) = default; + + private: + SerializationContext m_serializationContext; + }; +} + +#include + +#endif // NAZARA_SERIALIZER_HPP diff --git a/include/Nazara/Core/Serializer.inl b/include/Nazara/Core/Serializer.inl new file mode 100644 index 000000000..a61315090 --- /dev/null +++ b/include/Nazara/Core/Serializer.inl @@ -0,0 +1,45 @@ +// Copyright (C) 2015 Jérôme Leclercq +// This file is part of the "Nazara Engine - Core module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include + +namespace Nz +{ + inline Serializer::Serializer(Stream& stream) + { + m_serializationContext.endianness = Endianness_BigEndian; + m_serializationContext.stream = &stream; + } + + inline Endianness Serializer::GetDataEndianness() const + { + return m_serializationContext.endianness; + } + + inline Stream& Serializer::GetStream() const + { + return *m_serializationContext.stream; + } + + inline void Serializer::SetDataEndianness(Endianness endiannes) + { + m_serializationContext.endianness = endiannes; + } + + inline void Serializer::SetStream(Stream& stream) + { + m_serializationContext.stream = &stream; + } + + template + Serializer& Serializer::operator<<(const T& value) + { + if (!Serialize(m_serializationContext, value)) + NazaraError("Failed to serialize value"); + + return *this; + } +} + +#include diff --git a/include/Nazara/Core/Unserializer.hpp b/include/Nazara/Core/Unserializer.hpp new file mode 100644 index 000000000..359fc1a7d --- /dev/null +++ b/include/Nazara/Core/Unserializer.hpp @@ -0,0 +1,44 @@ +// Copyright (C) 2015 Jérôme Leclercq +// This file is part of the "Nazara Engine - Core module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_UNSERIALIZER_HPP +#define NAZARA_UNSERIALIZER_HPP + +#include +#include + +namespace Nz +{ + class Stream; + + class Unserializer + { + public: + inline Unserializer(Stream& stream); + Unserializer(const Unserializer&) = default; + Unserializer(Unserializer&&) = default; + ~Unserializer() = default; + + inline Endianness GetDataEndianness() const; + inline Stream& GetStream() const; + + inline void SetDataEndianness(Endianness endiannes); + inline void SetStream(Stream& stream); + + template + Unserializer& operator>>(T& value); + + Unserializer& operator=(const Unserializer&) = default; + Unserializer& operator=(Unserializer&&) = default; + + private: + UnserializationContext m_unserializationContext; + }; +} + +#include + +#endif // NAZARA_UNSERIALIZER_HPP diff --git a/include/Nazara/Core/Unserializer.inl b/include/Nazara/Core/Unserializer.inl new file mode 100644 index 000000000..97f91214f --- /dev/null +++ b/include/Nazara/Core/Unserializer.inl @@ -0,0 +1,45 @@ +// Copyright (C) 2015 Jérôme Leclercq +// This file is part of the "Nazara Engine - Core module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include + +namespace Nz +{ + inline Unserializer::Unserializer(Stream& stream) + { + m_unserializationContext.endianness = Endianness_BigEndian; + m_unserializationContext.stream = &stream; + } + + inline Endianness Unserializer::GetDataEndianness() const + { + return m_unserializationContext.endianness; + } + + inline Stream& Unserializer::GetStream() const + { + return *m_unserializationContext.stream; + } + + inline void Unserializer::SetDataEndianness(Endianness endiannes) + { + m_unserializationContext.endianness = endiannes; + } + + inline void Unserializer::SetStream(Stream& stream) + { + m_unserializationContext.stream = &stream; + } + + template + Unserializer& Unserializer::operator>>(T& value) + { + if (!Unserialize(m_unserializationContext, &value)) + NazaraError("Failed to serialize value"); + + return *this; + } +} + +#include diff --git a/src/Nazara/Core/MemoryStream.cpp b/src/Nazara/Core/MemoryStream.cpp deleted file mode 100644 index f92d6a3c0..000000000 --- a/src/Nazara/Core/MemoryStream.cpp +++ /dev/null @@ -1,90 +0,0 @@ -// Copyright (C) 2015 Jérôme Leclercq -// This file is part of the "Nazara Engine - Core module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include -#include -#include - -namespace Nz -{ - MemoryStream::MemoryStream() : - Stream(OpenMode_ReadWrite), - m_pos(0) - { - } - - MemoryStream::MemoryStream(const void* ptr, unsigned int size) : - MemoryStream() - { - m_buffer.Resize(size); - std::memcpy(m_buffer.GetBuffer(), ptr, size); - } - - void MemoryStream::Clear() - { - m_buffer.Clear(); - m_pos = 0; - } - - bool MemoryStream::EndOfStream() const - { - return m_pos >= m_buffer.size(); - } - - const ByteArray& MemoryStream::GetBuffer() const - { - return m_buffer; - } - - UInt64 MemoryStream::GetCursorPos() const - { - return m_pos; - } - - const UInt8* MemoryStream::GetData() const - { - return m_buffer.GetConstBuffer(); - } - - UInt64 MemoryStream::GetSize() const - { - return m_buffer.size(); - } - - bool MemoryStream::SetCursorPos(UInt64 offset) - { - m_pos = std::min(offset, m_buffer.size()); - - return true; - } - - void MemoryStream::FlushStream() - { - // Nothing to flush - } - - std::size_t MemoryStream::ReadBlock(void* buffer, std::size_t size) - { - std::size_t readSize = std::min(size, static_cast(m_buffer.size() - m_pos)); - - if (buffer) - std::memcpy(buffer, m_buffer.GetBuffer() + m_pos, readSize); - - m_pos += readSize; - return readSize; - } - - std::size_t MemoryStream::WriteBlock(const void* buffer, std::size_t size) - { - std::size_t endPos = static_cast(m_pos + size); - if (endPos > m_buffer.size()) - m_buffer.Resize(endPos); - - std::memcpy(m_buffer.GetBuffer(), buffer, size); - - m_pos = endPos; - return size; - } -}