1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
#pragma once
#include "Utils/IO/DataStream.hpp"
#include <tsl/robin_map.h>
#include <tsl/robin_set.h>
#include <type_traits>
namespace DataStreamAdapters {
template <class TKeyAdapter = void, class TValueAdapter = void>
struct TslRobinMap
{
template <class TKey, class TValue>
static void ReadFromDataStream(InputDataStream& s, tsl::robin_map<TKey, TValue>& map)
{
static_assert(std::is_default_constructible_v<TValue>);
static_assert(std::is_move_constructible_v<TValue>);
uint64_t size;
s.Read(size);
map.reserve(size);
for (uint64_t i = 0; i < size; ++i) {
TKey key;
if constexpr (std::is_same_v<TKeyAdapter, void>) {
s.ReadGeneric(key);
} else {
s.ReadObjectAdapted<TKeyAdapter>(key);
}
TValue value;
if constexpr (std::is_same_v<TValueAdapter, void>) {
s.ReadGeneric(value);
} else {
s.ReadObjectAdapted<TValueAdapter>(value);
}
map.insert(std::move(key), std::move(value));
}
}
template <class TKey, class TValue>
static void WriteToDataStream(OutputDataStream& s, const tsl::robin_map<TKey, TValue>& map)
{
s.Write((uint64_t)map.size());
for (auto it = map.begin(); it != map.end(); ++it) {
if constexpr (std::is_same_v<TKeyAdapter, void>) {
s.WriteGeneric(it.key());
} else {
s.WriteObjectAdapted<TKeyAdapter>(it.key());
}
if constexpr (std::is_same_v<TValueAdapter, void>) {
s.WriteGeneric(it.value());
} else {
s.WriteObjectAdapted<TValueAdapter>(it.value());
}
}
}
};
template <class TAdapter = void>
struct TslRobinSet
{
template <class TElement>
static void ReadFromDataStream(InputDataStream& s, tsl::robin_set<TElement>& set)
{
static_assert(std::is_default_constructible_v<TElement>);
static_assert(std::is_move_constructible_v<TElement>);
uint64_t size;
s.Read(size);
set.reserve(size);
for (uint64_t i = 0; i < size; ++i) {
TElement element;
if constexpr (std::is_same_v<TAdapter, void>) {
s.ReadGeneric(element);
} else {
s.ReadObjectAdapted<TAdapter>(element);
}
set.insert(std::move(element));
}
}
template <class TElement>
static void WriteToDataStream(OutputDataStream& s, const tsl::array_set<TElement>& set)
{
s.Write((uint64_t)set.size());
for (auto& element : set) {
if constexpr (std::is_same_v<TAdapter, void>) {
s.WriteGeneric(element);
} else {
s.WriteObjectAdapted<TAdapter>(element);
}
}
}
};
} // namespace DataStreamAdapters
|
