inplace memory buffer used for serialization

Author: malytomas

sources/include/cage-core/memoryInplaceBuffer.h

@@ -0,0 +1,20 @@
+#ifndef guard_memoryInplaceBuffer_h_w9a8erft7gzkl
+#define guard_memoryInplaceBuffer_h_w9a8erft7gzkl
+
+#include <cage-core/core.h>
+
+namespace cage
+{
+	template<uintPtr Capacity_ = 128>
+	struct InplaceBuffer : private Immovable
+	{
+		static constexpr uintPtr Capacity = Capacity_;
+		char data[Capacity];
+		uintPtr size = 0;
+
+		CAGE_FORCE_INLINE operator PointerRange<char>() { return { data, data + size }; }
+		CAGE_FORCE_INLINE operator PointerRange<const char>() const { return { data, data + size }; }
+	};
+}
+
+#endif // guard_memoryInplaceBuffer_h_w9a8erft7gzkl

sources/include/cage-core/serialization.h

@@ -1,31 +1,58 @@
 #ifndef guard_serialization_h_edsg45df4h654fdr56h4gfd564h
 #define guard_serialization_h_edsg45df4h654fdr56h4gfd564h
 
-#include <cage-core/core.h>
+#include <cage-core/memoryInplaceBuffer.h>
 
 namespace cage
 {
 	struct MemoryBuffer;
 
+	namespace privat
+	{
+		struct CAGE_CORE_API SerializationInterface
+		{
+		public:
+			SerializationInterface(PointerRange<char> buffer);
+			SerializationInterface(MemoryBuffer &buffer);
+			template<uintPtr Capacity>
+			SerializationInterface(InplaceBuffer<Capacity> &inplace)
+			{
+				origin = &inplace;
+				getData = +[](void *origin) -> char * { return ((InplaceBuffer<Capacity> *)origin)->data; };
+				getSize = +[](void *origin) -> uintPtr { return ((InplaceBuffer<Capacity> *)origin)->size; };
+				setSize = +[](void *origin, uintPtr size) -> void { ((InplaceBuffer<Capacity> *)origin)->size = size; };
+			}
+
+			using GetData = char *(*)(void *);
+			using GetSize = uintPtr (*)(void *);
+			using SetSize = void (*)(void *, uintPtr);
+			GetData getData = nullptr;
+			GetSize getSize = nullptr;
+			SetSize setSize = nullptr;
+			void *origin = nullptr;
+		};
+
+	}
+
 	struct CAGE_CORE_API Serializer : private Noncopyable
 	{
 		explicit Serializer(PointerRange<char> buffer);
-		explicit Serializer(MemoryBuffer &buffer, uintPtr size = m);
+		explicit Serializer(MemoryBuffer &buffer, uintPtr capacity = m);
+		template<uintPtr Capacity>
+		explicit Serializer(InplaceBuffer<Capacity> &inplace) : Serializer(inplace, 0, Capacity)
+		{}
+		explicit Serializer(privat::SerializationInterface interface, uintPtr offset, uintPtr capacity);
 
-		uintPtr available() const; // number of bytes still available in the buffer (valid only if the maximum size was given in the constructor)
+		uintPtr available() const; // number of bytes still available in the buffer (valid only if the capacity was provided in the constructor)
 		void write(PointerRange<const char> buffer);
-		PointerRange<char> write(uintPtr size); // use with care!
+		PointerRange<char> write(uintPtr size); // use with care! - future writes may invalidate the pointer
 		void writeLine(const String &line);
 		Serializer reserve(uintPtr s);
 
 	private:
-		explicit Serializer(MemoryBuffer *buffer, char *data, uintPtr offset, uintPtr size);
-		PointerRange<char> advance(uintPtr s); // future writes may cause the MemoryBuffer to reallocate invalidating the PointerRange
-
-		MemoryBuffer *buffer = nullptr;
-		char *data = nullptr;
+		privat::SerializationInterface interface;
 		uintPtr offset = 0; // current position in the buffer
-		uintPtr size = 0; // max size of the buffer
+		uintPtr capacity = 0; // max size of the buffer
 	};
 
 	struct CAGE_CORE_API Deserializer : private Noncopyable

sources/libcore/serialization.cpp

@@ -4,28 +4,55 @@
 
 namespace cage
 {
-	Serializer::Serializer(PointerRange<char> buffer) : data(buffer.data()), size(buffer.size()) {}
+	namespace privat
+	{
+		SerializationInterface::SerializationInterface(PointerRange<char> buffer)
+		{
+			origin = buffer.data();
+			getData = +[](void *origin) -> char * { return (char *)origin; };
+		}
+
+		SerializationInterface::SerializationInterface(MemoryBuffer &buffer)
+		{
+			origin = &buffer;
+			getData = +[](void *origin) -> char * { return ((MemoryBuffer *)origin)->data(); };
+			getSize = +[](void *origin) -> uintPtr { return ((MemoryBuffer *)origin)->size(); };
+			setSize = +[](void *origin, uintPtr size) -> void { ((MemoryBuffer *)origin)->resizeSmart(size); };
+		}
+	}
+
+	Serializer::Serializer(PointerRange<char> buffer) : interface(buffer), capacity(buffer.size()) {}
 
-	Serializer::Serializer(MemoryBuffer &buffer, uintPtr size) : buffer(&buffer), size(size == m && buffer.size() != 0 ? buffer.size() : size) {}
+	Serializer::Serializer(MemoryBuffer &buffer, uintPtr capacity) : interface(buffer), capacity(capacity == m && buffer.size() != 0 ? buffer.size() : capacity) {}
 
-	Serializer::Serializer(MemoryBuffer *buffer, char *data, uintPtr offset, uintPtr size) : buffer(buffer), data(data), offset(offset), size(size) {}
+	Serializer::Serializer(privat::SerializationInterface interface, uintPtr offset, uintPtr capacity) : interface(interface), offset(offset), capacity(capacity) {}
 
 	uintPtr Serializer::available() const
 	{
-		CAGE_ASSERT(size >= offset);
-		return size - offset;
+		CAGE_ASSERT(capacity >= offset);
+		return capacity - offset;
 	}
 
 	void Serializer::write(PointerRange<const char> buffer)
 	{
-		auto dst = advance(buffer.size());
-		if (!buffer.empty())
-			detail::memcpy(dst.data(), buffer.data(), buffer.size());
+		if (buffer.empty())
+			return;
+		auto dst = write(buffer.size());
+		detail::memcpy(dst.data(), buffer.data(), buffer.size());
 	}
 
 	PointerRange<char> Serializer::write(uintPtr size)
 	{
-		return advance(size);
+		if (available() < size)
+			CAGE_THROW_ERROR(Exception, "serialization beyond available space");
+		if (interface.getSize && interface.getSize(interface.origin) < offset + size)
+		{
+			CAGE_ASSERT(interface.setSize);
+			interface.setSize(interface.origin, offset + size);
+		}
+		char *dst = interface.getData(interface.origin) + offset;
+		offset += size;
+		return { dst, dst + size };
 	}
 
 	void Serializer::writeLine(const String &line)
@@ -36,23 +63,9 @@ namespace cage
 
 	Serializer Serializer::reserve(uintPtr s)
 	{
-		uintPtr o = offset;
-		advance(s);
-		return Serializer(buffer, data, o, offset);
-	}
-
-	PointerRange<char> Serializer::advance(uintPtr s)
-	{
-		if (available() < s)
-			CAGE_THROW_ERROR(Exception, "serialization beyond available space");
-		if (!data)
-		{
-			if (buffer->size() < offset + s)
-				buffer->resizeSmart(offset + s);
-		}
-		char *dst = (data ? data : buffer->data()) + offset;
-		offset += s;
-		return { dst, dst + s };
+		const uintPtr o = offset;
+		write(s);
+		return Serializer(interface, o, offset);
 	}
 
 	Deserializer::Deserializer(PointerRange<const char> buffer) : data(buffer.data()), size(buffer.size()) {}
@@ -85,7 +98,7 @@ namespace cage
 	{
 		const uintPtr a = available();
 		PointerRange<const char> pr = { data + offset, data + offset + a };
-		uintPtr l = detail::readLine(line, pr, false);
+		const uintPtr l = detail::readLine(line, pr, false);
 		if (l)
 		{
 			offset += l;
@@ -98,7 +111,7 @@ namespace cage
 	{
 		const uintPtr a = available();
 		PointerRange<const char> pr = { data + offset, data + offset + a };
-		uintPtr l = detail::readLine(line, pr, false);
+		const uintPtr l = detail::readLine(line, pr, false);
 		if (l)
 		{
 			offset += l;
@@ -109,7 +122,7 @@ namespace cage
 
 	Deserializer Deserializer::subview(uintPtr s)
 	{
-		uintPtr o = offset;
+		const uintPtr o = offset;
 		read(s);
 		return Deserializer(data, o, offset);
 	}

sources/test-core/serialization.cpp

@@ -191,4 +191,16 @@ void testSerialization()
 			functionTakingCharPointer(items.data(), items.size());
 		}
 	}
+
+	{
+		CAGE_TESTCASE("inplace buffer");
+		InplaceBuffer b1;
+		Serializer ser(b1);
+		int arr[3] = { 1, 2, 3 };
+		ser << arr;
+		arr[0] = arr[1] = arr[2] = 0;
+		Deserializer des(b1);
+		des >> arr;
+		CAGE_TEST(arr[0] == 1 && arr[1] == 2 && arr[2] == 3);
+	}
 }