#include <string>
#include <vector>
#include <iostream>
#include <cstddef>
#include <iomanip>

struct test
{
	int x;
	float y;
	std::string z;

	template <typename Serializer>
	void serialize (Serializer & s)
	{
		s(x);
		s(y);
		s(z);
	}
};

template <typename T, typename ReadBuffer>
void read (T & x, ReadBuffer & buffer)
{
	buffer.read(reinterpret_cast<std::byte *>(std::addressof(x)), sizeof(x));
}

template <typename T, typename WriteBuffer>
void write (T const & x, WriteBuffer & buffer)
{
	buffer.write(reinterpret_cast<std::byte const *>(std::addressof(x)), sizeof(x));
}

template <typename A, typename ReadBuffer>
void read_array (A & a, ReadBuffer & buffer)
{
	std::size_t size;
	read(size, buffer);
	a.resize(size);
	buffer.read(reinterpret_cast<std::byte *>(a.data()), size * sizeof(*std::begin(a)));
}

template <typename A, typename WriteBuffer>
void write_array (A const & a, WriteBuffer & buffer)
{
	write(a.size(), buffer);
	buffer.write(reinterpret_cast<std::byte const *>(a.data()), a.size() * sizeof(*std::begin(a)));
}

template <typename ReadBuffer>
void read (std::string & x, ReadBuffer & buffer)
{
	read_array(x, buffer);
}

template <typename WriteBuffer>
void write (std::string const & x, WriteBuffer & buffer)
{
	write_array(x, buffer);
}

template <std::size_t ChunkSize>
struct chunk_buffer
{
	using chunk = std::array<std::byte, ChunkSize>;

	std::vector<chunk> chunks;

	std::size_t write_chunk, write_offset;
	std::size_t read_chunk, read_offset;

	chunk_buffer ( )
	{
		clear();
	}

	void clear ( )
	{
		reset();

		chunks.resize(1);
	}

	void reset ( )
	{
		write_chunk = 0;
		write_offset = 0;
		read_chunk = 0;
		read_offset = 0;
	}

	void write (std::byte const * data, std::size_t size)
	{
		while (size > 0)
		{
			std::size_t s = std::min(chunks[write_chunk].size() - write_offset, size);
			std::copy(data, data + s, chunks[write_chunk].data() + write_offset);
			write_offset += s;
			data += s;
			size -= s;

			if (size > 0)
			{
				++write_chunk;
				write_offset = 0;
				if (chunks.size() <= write_chunk)
					chunks.resize(write_chunk + 1);
			}
		}
	}

	void read (std::byte * data, std::size_t size)
	{
		while (size > 0)
		{
			std::size_t s = std::min(chunks[read_chunk].size() - read_offset, size);
			std::copy(chunks[read_chunk].data() + read_offset, chunks[read_chunk].data() + s + read_offset, data);
			read_offset += s;
			data += s;
			size -= s;

			if (size > 0)
			{
				++read_chunk;
				read_offset = 0;
				if (chunks.size() <= read_chunk)
				{
					throw std::runtime_error("Insufficient data in buffer for deserializing");
				}
			}
		}
	}
};

template <typename WriteBuffer>
struct serializer
{
	WriteBuffer & buf;

	serializer (WriteBuffer & buf) : buf(buf) { }

	template <typename T>
	serializer & operator() (T const & x)
	{
		write(x, buf);
		return *this;
	}
};

template <typename ReadBuffer>
struct deserializer
{
	ReadBuffer & buf;

	deserializer (ReadBuffer & buf) : buf(buf) { }

	template <typename T>
	deserializer & operator() (T & x)
	{
		read(x, buf);
		return *this;
	}
};

int main ( )
{
	chunk_buffer<0x400> buffer;

	{
		test t { 42, 3.141592f, "Hello, world!" };

		serializer s { buffer };
		t.serialize(s);
	}

	{
		deserializer s { buffer };

		test t;
		t.serialize(s);

		std::cout << t.x << ' ' << t.y << ' ' << t.z << std::endl;
	}
}