Core: Rework Serialization

Former-commit-id: d97eedbd3efc92235e3880ad061a5216fa77ebd7

src/Nazara/Core/ByteStream.cpp

@@ -0,0 +1,63 @@
+// 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 <Nazara/Core/ByteStream.hpp>
+#include <Nazara/Core/MemoryStream.hpp>
+#include <Nazara/Core/MemoryView.hpp>
+#include <algorithm>
+#include <cstring>
+#include <Nazara/Core/Debug.hpp>
+
+namespace Nz
+{
+	ByteStream::ByteStream(ByteArray* byteArray, UInt32 openMode) :
+	ByteStream()
+	{
+		SetStream(byteArray, openMode);
+	}
+
+	ByteStream::ByteStream(void* ptr, Nz::UInt64 size) :
+	ByteStream()
+	{
+		SetStream(ptr, size);
+	}
+
+	ByteStream::ByteStream(const void* ptr, Nz::UInt64 size) :
+	ByteStream()
+	{
+		SetStream(ptr, size);
+	}
+
+	void ByteStream::SetStream(ByteArray* byteArray, UInt32 openMode)
+	{
+		std::unique_ptr<Stream> stream(new MemoryStream(byteArray, openMode));
+
+		SetStream(m_ownedStream.get());
+		// SetStream reset our smart pointer, set it after calling it
+		m_ownedStream = std::move(stream);
+	}
+
+	void ByteStream::SetStream(void* ptr, Nz::UInt64 size)
+	{
+		std::unique_ptr<Stream> stream(new MemoryView(ptr, size));
+
+		SetStream(m_ownedStream.get());
+		// SetStream reset our smart pointer, set it after calling it
+		m_ownedStream = std::move(stream);
+	}
+
+	void ByteStream::SetStream(const void* ptr, Nz::UInt64 size)
+	{
+		std::unique_ptr<Stream> stream(new MemoryView(ptr, size));
+
+		SetStream(m_ownedStream.get());
+		// SetStream reset our smart pointer, set it after calling it
+		m_ownedStream = std::move(stream);
+	}
+
+	void ByteStream::OnEmptyStream()
+	{
+		NazaraError("No stream");
+	}
+}

src/Nazara/Core/MemoryStream.cpp

@@ -3,39 +3,22 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Core/MemoryStream.hpp>
+#include <Nazara/Core/ByteArray.hpp>
 #include <algorithm>
 #include <cstring>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz
 {
-	MemoryStream::MemoryStream() :
-	Stream(StreamOption_None, 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_buffer->Clear();
 		m_pos = 0;
 	}
 
 	bool MemoryStream::EndOfStream() const
 	{
-		return m_pos >= m_buffer.size();
-	}
-
-	const ByteArray& MemoryStream::GetBuffer() const
-	{
-		return m_buffer;
+		return m_pos >= m_buffer->size();
 	}
 
 	UInt64 MemoryStream::GetCursorPos() const
@@ -43,19 +26,20 @@ namespace Nz
 		return m_pos;
 	}
 
-	const UInt8* MemoryStream::GetData() const
-	{
-		return m_buffer.GetConstBuffer();
-	}
-
 	UInt64 MemoryStream::GetSize() const
 	{
-		return m_buffer.size();
+		return m_buffer->GetSize();
+	}
+
+	void MemoryStream::SetBuffer(ByteArray* byteArray, UInt32 openMode)
+	{
+		m_buffer = byteArray;
+		m_openMode = openMode;
 	}
 
 	bool MemoryStream::SetCursorPos(UInt64 offset)
 	{
-		m_pos = std::min<UInt64>(offset, m_buffer.size());
+		m_pos = offset;
 
 		return true;
 	}
@@ -67,10 +51,13 @@ namespace Nz
 
 	std::size_t MemoryStream::ReadBlock(void* buffer, std::size_t size)
 	{
-		std::size_t readSize = std::min<std::size_t>(size, static_cast<std::size_t>(m_buffer.size() - m_pos));
+		if (EndOfStream())
+			return 0;
+
+		std::size_t readSize = std::min<std::size_t>(size, static_cast<std::size_t>(m_buffer->GetSize() - m_pos));
 
 		if (buffer)
-			std::memcpy(buffer, &m_buffer[m_pos], readSize);
+			std::memcpy(buffer, m_buffer->GetConstBuffer() + m_pos, readSize);
 
 		m_pos += readSize;
 		return readSize;
@@ -79,10 +66,10 @@ namespace Nz
 	std::size_t MemoryStream::WriteBlock(const void* buffer, std::size_t size)
 	{
 		std::size_t endPos = static_cast<std::size_t>(m_pos + size);
-		if (endPos > m_buffer.size())
-			m_buffer.Resize(endPos);
+		if (endPos > m_buffer->GetSize())
+			m_buffer->Resize(endPos);
 
-		std::memcpy(&m_buffer[m_pos], buffer, size);
+		std::memcpy(m_buffer->GetBuffer() + m_pos, buffer, size);
 		
 		m_pos = endPos;
 		return size;

src/Nazara/Core/MemoryView.cpp

@@ -9,9 +9,17 @@
 
 namespace Nz
 {
+	MemoryView::MemoryView(void* ptr, UInt64 size) :
+	Stream(StreamOption_None, OpenMode_ReadWrite),
+	m_ptr(reinterpret_cast<UInt8*>(ptr)), 
+	m_pos(0),
+	m_size(size)
+	{
+	}
+
 	MemoryView::MemoryView(const void* ptr, UInt64 size) :
 	Stream(StreamOption_None, OpenMode_ReadOnly),
-	m_ptr(reinterpret_cast<const UInt8*>(ptr)),
+	m_ptr(reinterpret_cast<UInt8*>(const_cast<void*>(ptr))), //< Okay, right, const_cast is bad, but this pointer is still read-only
 	m_pos(0),
 	m_size(size)
 	{
@@ -41,7 +49,7 @@ namespace Nz
 
 	void MemoryView::FlushStream()
 	{
-		NazaraInternalError("FlushStream has been called on a MemoryView");
+		// Nothing to do
 	}
 
 	std::size_t MemoryView::ReadBlock(void* buffer, std::size_t size)
@@ -57,7 +65,13 @@ namespace Nz
 
 	std::size_t MemoryView::WriteBlock(const void* buffer, std::size_t size)
 	{
-		NazaraInternalError("WriteBlock has been called on a MemoryView");
-		return 0;
+		std::size_t endPos = static_cast<std::size_t>(m_pos + size);
+		if (endPos > m_size)
+			size = m_size - m_pos;
+
+		std::memcpy(&m_ptr[m_pos], buffer, size);
+
+		m_pos += size;
+		return size;
 	}
 }

src/Nazara/Core/String.cpp

@@ -4226,7 +4226,7 @@ namespace Nz
 		return context.stream->Write(string.GetConstBuffer(), string.GetSize()) == string.GetSize();
 	}
 
-	bool Unserialize(UnserializationContext& context, String* string)
+	bool Unserialize(SerializationContext& context, String* string)
 	{
 		UInt32 size;
 		if (!Unserialize(context, &size))