6#ifndef OPENCBDC_TX_SRC_SERIALIZATION_FORMAT_H_
7#define OPENCBDC_TX_SRC_SERIALIZATION_FORMAT_H_
21#include <unordered_map>
22#include <unordered_set>
29 auto operator<<(serializer& packet, std::byte b) -> serializer&;
36 auto operator>>(serializer& packet, std::byte& b) -> serializer&;
54 typename std::enable_if_t<std::is_empty_v<T>,
serializer&> {
62 typename std::enable_if_t<std::is_empty_v<T>,
serializer&> {
74 typename std::enable_if_t<std::is_integral_v<T> && !std::is_enum_v<T>,
76 s.write(&t,
sizeof(t));
87 typename std::enable_if_t<std::is_integral_v<T> && !std::is_enum_v<T>,
89 s.read(&t,
sizeof(t));
101 template<
typename T,
size_t len>
103 typename std::enable_if_t<std::is_integral_v<T>,
serializer&> {
104 packet.write(arr.data(),
sizeof(T) * len);
110 template<
typename T,
size_t len>
112 typename std::enable_if_t<std::is_integral_v<T>,
serializer&> {
113 packet.read(arr.data(),
sizeof(T) * len);
122 if(!(deser >> has_value)) {
128 if(!(deser >> opt_val)) {
131 val = std::move(opt_val);
146 auto has_value = val.has_value();
157 template<
typename A,
typename B>
159 ser << p.first << p.second;
165 template<
typename A,
typename B>
177 p = {std::move(a), std::move(b)};
188 const auto len =
static_cast<uint64_t
>(vec.size());
190 for(uint64_t i = 0; i < len; i++) {
191 packet << static_cast<T>(vec[i]);
200 static_assert(
sizeof(T) <= config::maximum_reservation,
201 "Vector element size too large");
204 if(!(packet >> len)) {
208 uint64_t allocated = 0;
209 while(allocated < len) {
210 allocated = std::min(
212 allocated + config::maximum_reservation /
sizeof(T));
213 vec.reserve(allocated);
214 while(vec.size() < allocated) {
215 if constexpr(std::is_default_constructible_v<T>) {
217 if(!(packet >> val)) {
220 vec.push_back(std::move(val));
222 auto val = T(packet);
226 vec.push_back(std::move(val));
238 template<
typename K,
typename V,
typename... Ts>
240 const std::unordered_map<K, V, Ts...>& map)
242 auto len =
static_cast<uint64_t
>(map.size());
244 for(
const auto& it : map) {
245 ser << static_cast<K>(it.first);
246 ser << static_cast<V>(it.second);
253 template<
typename K,
typename V,
typename... Ts>
256 static_assert(
sizeof(K) +
sizeof(V) <= config::maximum_reservation,
257 "Unordered Map element size too large");
258 auto len = uint64_t();
259 if(!(deser >> len)) {
263 uint64_t allocated = 0;
264 while(allocated < len) {
265 allocated = std::min(len,
267 + config::maximum_reservation
268 / (
sizeof(K) +
sizeof(V)));
269 map.reserve(allocated);
270 while(map.size() < allocated) {
272 if(!(deser >> key)) {
277 if(!(deser >> val)) {
281 map.emplace(std::move(key), std::move(val));
289 template<
typename K,
typename... Ts>
292 auto len =
static_cast<uint64_t
>(set.size());
294 for(
const auto& key : set) {
295 ser << static_cast<K>(key);
302 template<
typename K,
typename... Ts>
305 auto len = uint64_t();
306 if(!(deser >> len)) {
310 for(uint64_t i = 0; i < len; i++) {
312 if(!(deser >> key)) {
315 set.emplace(std::move(key));
322 template<
typename K,
typename... Ts>
325 auto len =
static_cast<uint64_t
>(set.size());
327 for(
const auto& key : set) {
328 ser << static_cast<K>(key);
335 template<
typename K,
typename... Ts>
338 static_assert(
sizeof(K) <= config::maximum_reservation,
339 "Unordered Set element size too large");
340 auto len = uint64_t();
341 if(!(deser >> len)) {
345 uint64_t allocated = 0;
346 while(allocated < len) {
347 allocated = std::min(
349 allocated + config::maximum_reservation /
sizeof(K));
350 while(set.size() < allocated) {
352 if(!(deser >> key)) {
355 set.emplace(std::move(key));
363 template<
typename... Ts>
368 std::variant_size_v<std::remove_reference_t<
decltype(var)>> < std::
369 numeric_limits<S>::max());
370 auto idx =
static_cast<S
>(var.index());
382 template<
typename... Ts>
384 -> std::enable_if_t<(std::is_default_constructible_v<Ts> && ...),
388 std::variant_size_v<std::remove_reference_t<
decltype(var)>> < std::
389 numeric_limits<S>::max());
392 auto var_idx =
static_cast<size_t>(idx);
408 template<
typename... Ts>
410 using T =
typename std::variant<Ts...>;
412 static_assert(std::variant_size_v<T> < std::numeric_limits<S>::max());
416 if constexpr((std::is_default_constructible_v<Ts> && ...)) {
423 auto i =
static_cast<size_t>(idx);
424 assert(i < std::variant_size_v<T>);
425 static constexpr auto t = std::array{+[](
serializer& d) {
426 return T{std::in_place_type<Ts>, d};
429 return t.at(i)(deser);
438 typename std::enable_if_t<std::is_enum_v<T>, serializer&> {
439 return ser << static_cast<std::underlying_type_t<T>>(e);
445 typename std::enable_if_t<std::is_enum_v<T>, serializer&> {
446 std::underlying_type_t<T> val{};
448 e =
static_cast<T
>(val);
Interface for serializing objects into and out of raw bytes representations.
Tools for reading options from a configuration file and building application-specific parameter sets ...
auto get_variant(serializer &deser) -> std::variant< Ts... >
Deserializes a variant where the alternatives are all default constructible or all are not default co...
auto operator>>(serializer &deser, parsec::agent::rpc::request &req) -> serializer &
@ buffer
A singular RLP value (byte array)
auto expand_type(size_t i) -> std::variant< Ts... >
Default-constructs a std::variant from a template parameter pack.
auto operator<<(serializer &ser, const parsec::agent::rpc::request &req) -> serializer &