mirror of
https://github.com/privatevoid-net/nix-super.git
synced 2024-11-13 09:46:16 +02:00
be81764320
This introduces some shared infrastructure for our notion of protocols. We can then define multiple protocols in terms of that notion. We an also express how particular protocols depend on each other. For example, we can define a common protocol and a worker protocol, where the second depends on the first in terms of the data types it can read and write. The "serve" protocol can just use the common one for now, but will eventually need its own machinary just like the worker protocol for version-aware serialisers
106 lines
2.7 KiB
C++
106 lines
2.7 KiB
C++
#pragma once
|
|
///@file
|
|
|
|
#include "serialise.hh"
|
|
|
|
namespace nix {
|
|
|
|
class Store;
|
|
struct Source;
|
|
|
|
// items being serialized
|
|
class StorePath;
|
|
struct ContentAddress;
|
|
struct DrvOutput;
|
|
struct Realisation;
|
|
|
|
|
|
/**
|
|
* Shared serializers between the worker protocol, serve protocol, and a
|
|
* few others.
|
|
*
|
|
* This `struct` is basically just a `namespace`; We use a type rather
|
|
* than a namespace just so we can use it as a template argument.
|
|
*/
|
|
struct CommonProto
|
|
{
|
|
/**
|
|
* A unidirectional read connection, to be used by the read half of the
|
|
* canonical serializers below.
|
|
*/
|
|
struct ReadConn {
|
|
Source & from;
|
|
};
|
|
|
|
/**
|
|
* A unidirectional write connection, to be used by the write half of the
|
|
* canonical serializers below.
|
|
*/
|
|
struct WriteConn {
|
|
Sink & to;
|
|
};
|
|
|
|
template<typename T>
|
|
struct Serialise;
|
|
|
|
/**
|
|
* Wrapper function around `CommonProto::Serialise<T>::write` that allows us to
|
|
* infer the type instead of having to write it down explicitly.
|
|
*/
|
|
template<typename T>
|
|
static void write(const Store & store, WriteConn conn, const T & t)
|
|
{
|
|
CommonProto::Serialise<T>::write(store, conn, t);
|
|
}
|
|
};
|
|
|
|
#define DECLARE_COMMON_SERIALISER(T) \
|
|
struct CommonProto::Serialise< T > \
|
|
{ \
|
|
static T read(const Store & store, CommonProto::ReadConn conn); \
|
|
static void write(const Store & store, CommonProto::WriteConn conn, const T & str); \
|
|
}
|
|
|
|
template<>
|
|
DECLARE_COMMON_SERIALISER(std::string);
|
|
template<>
|
|
DECLARE_COMMON_SERIALISER(StorePath);
|
|
template<>
|
|
DECLARE_COMMON_SERIALISER(ContentAddress);
|
|
template<>
|
|
DECLARE_COMMON_SERIALISER(DrvOutput);
|
|
template<>
|
|
DECLARE_COMMON_SERIALISER(Realisation);
|
|
|
|
template<typename T>
|
|
DECLARE_COMMON_SERIALISER(std::vector<T>);
|
|
template<typename T>
|
|
DECLARE_COMMON_SERIALISER(std::set<T>);
|
|
template<typename... Ts>
|
|
DECLARE_COMMON_SERIALISER(std::tuple<Ts...>);
|
|
|
|
#define COMMA_ ,
|
|
template<typename K, typename V>
|
|
DECLARE_COMMON_SERIALISER(std::map<K COMMA_ V>);
|
|
#undef COMMA_
|
|
|
|
/**
|
|
* These use the empty string for the null case, relying on the fact
|
|
* that the underlying types never serialize to the empty string.
|
|
*
|
|
* We do this instead of a generic std::optional<T> instance because
|
|
* ordinal tags (0 or 1, here) are a bit of a compatability hazard. For
|
|
* the same reason, we don't have a std::variant<T..> instances (ordinal
|
|
* tags 0...n).
|
|
*
|
|
* We could the generic instances and then these as specializations for
|
|
* compatability, but that's proven a bit finnicky, and also makes the
|
|
* worker protocol harder to implement in other languages where such
|
|
* specializations may not be allowed.
|
|
*/
|
|
template<>
|
|
DECLARE_COMMON_SERIALISER(std::optional<StorePath>);
|
|
template<>
|
|
DECLARE_COMMON_SERIALISER(std::optional<ContentAddress>);
|
|
|
|
}
|