resolver.cpp

#include <string>

#include <theg/serialization.hpp>
#include <theg/serialization/vector_sink.hpp>
#include <theg/serialization/data_source.hpp>

class Entity
{
public:
	// Returns some unique identifier of this entity
	std::string_view identifier() const;
};

class Database
{
public:
	// Returns a pointer to the entity object with the given identifier
	const Entity* resolve(std::string_view) const;
};

class Widget
{
	// ...
private:
	const Entity* m_entity = nullptr; // Raw pointers cannot be serialized by default
};

// Define a resolver that can take care of `const Entity*` pointers.
// Trait functions could also be implemented in `Database` class directly
struct WidgetResolver
{
	// During serialization, write the identifier string
	template <class Serialization>
	void write(const Entity* entity, Serialization serialization)
	{
		serialization.write(entity->identifier());
	}

	// During deserialization, read the identifier string and resolve it via the database
	template <class Deserialization>
	const Entity* read(theg::type_t<const Entity*>, Deserialization deserialization)
	{
		return database->resolve(deserialization.read(theg::type<std::string>));
	}

	Database* database = nullptr;
};

static void foo()
{
	Database database;
	Widget w;

	WidgetResolver resolver = { &database };

	// Pass the resolver to the serialization
	theg::serialization_vector_sink sink;
	sink.write(w, &resolver);

	// Get the raw bytes at the end of the serialization
	std::vector<std::byte> rawBytes = sink.release();

	// Store the bytes and read them again, send it across the network or to some other process

	// Re-construct the widget using the resolver again
	theg::serialization_data_source source(rawBytes.data(), rawBytes.size());
	auto w2 = source.read<Widget>(&resolver);
}