Mesen-SX/Utilities/Serializer.h

#pragma once

#include "stdafx.h"

class Serializer;
class ISerializable;

template <typename T>
struct ArrayInfo
{
	T* Array;
	uint32_t ElementCount;
};

template <typename T>
struct VectorInfo
{
	vector<T>* Vector;
};

template <typename T>
struct ValueInfo
{
	T* Value;
	T DefaultValue;
};

struct BlockData
{
	vector<uint8_t> Data;
	uint32_t Position;
};

class Serializer
{
private:
	vector<unique_ptr<BlockData>> _blocks;
	unique_ptr<BlockData> _block;

	uint32_t _version = 0;
	bool _saving = false;

private:
	void EnsureCapacity(uint32_t typeSize);

	template <typename T>
	void StreamElement(T& value, T defaultValue = T());

	template <typename T>
	void InternalStream(ArrayInfo<T>& info);
	template <typename T>
	void InternalStream(VectorInfo<T>& info);
	template <typename T>
	void InternalStream(ValueInfo<T>& info);
	template <typename T>
	void InternalStream(T& value);
	void InternalStream(string& str);
	void RecursiveStream();

	template <typename T, typename... T2>
	void RecursiveStream(T& value, T2&... args);

	void StreamStartBlock();
	void StreamEndBlock();

public:
	Serializer(uint32_t version);
	Serializer(istream& file, uint32_t version, bool compressed = true);

	uint32_t GetVersion() { return _version; }
	bool IsSaving() { return _saving; }

	template <typename... T>
	void Stream(T&... args);
	template <typename T>
	void StreamArray(T* array, uint32_t size);
	template <typename T>
	void StreamVector(vector<T>& list);

	void Save(ostream& file, int compressionLevel = 1);

	void Stream(ISerializable& obj);
	void Stream(ISerializable* obj);

	void WriteEmptyBlock(ostream* file);
	void SkipBlock(istream* file);
};

template <typename T>
void Serializer::StreamElement(T& value, T defaultValue)
{
	if (_saving)
	{
		uint8_t* bytes = (uint8_t*)&value;
		int typeSize = sizeof(T);

		EnsureCapacity(typeSize);
		for (int i = 0; i < typeSize; i++)
		{
			_block->Data[_block->Position++] = bytes[i];
		}
	}
	else
	{
		if (_block->Position + sizeof(T) <= _block->Data.size())
		{
			memcpy(&value, _block->Data.data() + _block->Position, sizeof(T));
			_block->Position += sizeof(T);
		}
		else
		{
			value = defaultValue;
			_block->Position = (uint32_t)_block->Data.size();
		}
	}
}

template <typename T>
void Serializer::InternalStream(ArrayInfo<T>& info)
{
	uint32_t count = info.ElementCount;
	StreamElement<uint32_t>(count);

	if (!_saving)
	{
		//Reset array to 0 before loading from file
		memset(info.Array, 0, info.ElementCount * sizeof(T));
	}

	//Load the number of elements requested, or the maximum possible (based on what is present in the save state)
	EnsureCapacity(info.ElementCount * sizeof(T));

	if (_saving)
	{
		memcpy(_block->Data.data() + _block->Position, info.Array, info.ElementCount * sizeof(T));
	}
	else
	{
		memcpy(info.Array, _block->Data.data() + _block->Position, info.ElementCount * sizeof(T));
	}
	_block->Position += info.ElementCount * sizeof(T);
}

template <typename T>
void Serializer::InternalStream(VectorInfo<T>& info)
{
	vector<T>* vector = info.Vector;

	uint32_t count = (uint32_t)vector->size();
	StreamElement<uint32_t>(count);

	if (!_saving)
	{
		if (count > 0xFFFFFF)
		{
			throw std::runtime_error("Invalid save state");
		}
		vector->resize(count);
		memset(vector->data(), 0, sizeof(T) * count);
	}

	//Load the number of elements requested
	T* pointer = vector->data();
	for (uint32_t i = 0; i < count; i++)
	{
		StreamElement<T>(*pointer);
		pointer++;
	}
}

template <typename T>
void Serializer::InternalStream(ValueInfo<T>& info)
{
	StreamElement<T>(*info.Value, info.DefaultValue);
}

template <typename T>
void Serializer::InternalStream(T& value)
{
	StreamElement<T>(value);
}

template <typename T, typename... T2>
void Serializer::RecursiveStream(T& value, T2&... args)
{
	InternalStream(value);
	RecursiveStream(args...);
}

template <typename... T>
void Serializer::Stream(T&... args)
{
	StreamStartBlock();
	RecursiveStream(args...);
	StreamEndBlock();
}

template <typename T>
void Serializer::StreamArray(T* array, uint32_t size)
{
	ArrayInfo<T> info;
	info.Array = array;
	info.ElementCount = size;
	InternalStream(info);
}

template <typename T>
void Serializer::StreamVector(vector<T>& list)
{
	VectorInfo<T> info;
	info.Vector = &list;
	InternalStream(info);
}