OGLplus  (0.59.0) a C++ wrapper for rendering APIs
data_buffer.hpp
Go to the documentation of this file.
1 
9 #ifndef EAGINE_SERIALIZE_DATA_BUFFER_HPP
10 #define EAGINE_SERIALIZE_DATA_BUFFER_HPP
11 
12 #include "../identifier.hpp"
13 #include "../int_constant.hpp"
14 #include "../reflect/data_members.hpp"
15 #include "../reflect/enumerators.hpp"
16 #include "../types.hpp"
17 #include <array>
18 #include <cstdint>
19 #include <string>
20 #include <vector>
21 
22 namespace eagine {
23 //------------------------------------------------------------------------------
24 template <std::size_t S, bool C = true>
25 struct serialize_size_constant : size_constant<S> {
26 
27  static constexpr bool is_constant = C;
28 
29  template <typename X>
30  static constexpr auto get(const X&) noexcept {
31  return std_size(S);
32  }
33 };
34 //------------------------------------------------------------------------------
35 template <identifier_t SerializerId, typename T, typename Selector>
36 struct get_serialize_buffer_size;
37 
38 template <identifier_t SerializerId, typename T, typename Selector>
39 constexpr const auto serialize_buffer_size_v =
40  get_serialize_buffer_size<SerializerId, T, Selector>::value;
41 
42 template <identifier_t SerializerId, typename T, typename Selector>
43 constexpr const auto serialize_buffer_is_constant_v =
44  get_serialize_buffer_size<SerializerId, T, Selector>::value;
45 //------------------------------------------------------------------------------
46 template <identifier_t Sid, typename T, typename Selector>
47 struct get_serialize_buffer_size<Sid, T&, Selector>
48  : get_serialize_buffer_size<Sid, T, Selector> {};
49 
50 template <identifier_t Sid, typename T, typename Selector>
51 struct get_serialize_buffer_size<Sid, const T, Selector>
52  : get_serialize_buffer_size<Sid, T, Selector> {};
53 
54 template <identifier_t Sid, typename T, typename Selector>
55 struct get_serialize_buffer_size<Sid, const T&, Selector>
56  : get_serialize_buffer_size<Sid, T, Selector> {};
57 //------------------------------------------------------------------------------
58 template <identifier_t Sid, typename Selector>
59 struct get_serialize_buffer_size<Sid, bool, Selector>
60  : serialize_size_constant<8> {};
61 
62 template <identifier_t Sid, typename Selector>
63 struct get_serialize_buffer_size<Sid, byte, Selector>
64  : serialize_size_constant<4> {};
65 
66 template <identifier_t Sid, typename Selector>
67 struct get_serialize_buffer_size<Sid, char, Selector>
68  : serialize_size_constant<4> {};
69 
70 template <identifier_t Sid, typename Selector>
71 struct get_serialize_buffer_size<Sid, std::int16_t, Selector>
72  : serialize_size_constant<6> {};
73 
74 template <identifier_t Sid, typename Selector>
75 struct get_serialize_buffer_size<Sid, std::uint16_t, Selector>
76  : serialize_size_constant<6> {};
77 
78 template <identifier_t Sid, typename Selector>
79 struct get_serialize_buffer_size<Sid, std::int32_t, Selector>
80  : serialize_size_constant<12> {};
81 
82 template <identifier_t Sid, typename Selector>
83 struct get_serialize_buffer_size<Sid, std::uint32_t, Selector>
84  : serialize_size_constant<12> {};
85 
86 template <identifier_t Sid, typename Selector>
87 struct get_serialize_buffer_size<Sid, std::int64_t, Selector>
88  : serialize_size_constant<24> {};
89 
90 template <identifier_t Sid, typename Selector>
91 struct get_serialize_buffer_size<Sid, std::uint64_t, Selector>
92  : serialize_size_constant<24> {};
93 
94 template <identifier_t Sid, typename Selector>
95 struct get_serialize_buffer_size<Sid, float, Selector>
96  : serialize_size_constant<24> {};
97 
98 template <identifier_t Sid, typename Selector>
99 struct get_serialize_buffer_size<Sid, double, Selector>
100  : serialize_size_constant<48> {};
101 
102 template <identifier_t Sid, typename Selector>
103 struct get_serialize_buffer_size<Sid, identifier, Selector>
104  : serialize_size_constant<12> {};
105 
106 template <identifier_t Sid, typename Selector>
107 struct get_serialize_buffer_size<Sid, std::string, Selector>
108  : serialize_size_constant<0, false> {
109 
110  static constexpr auto
111  get(std::pair<string_view, const std::string&> mapped) noexcept {
112  return std_size(
113  12 + mapped.first.size() + 2 + span_size(mapped.second.size()));
114  }
115 };
116 //------------------------------------------------------------------------------
117 template <identifier_t Sid, typename T, std::size_t N, typename Selector>
118 struct get_serialize_buffer_size<Sid, std::array<T, N>, Selector>
119  : serialize_size_constant<
120  (4 + (2 + serialize_buffer_size_v<Sid, T, Selector>)*N),
121  (get_serialize_buffer_size<Sid, T, Selector>::is_constant)> {
122 
123  static constexpr auto
124  get(std::pair<string_view, const std::array<T, N>&> mapped) noexcept {
125  auto result = std_size(12 + mapped.first.size());
126  for(auto& e : mapped.second) {
127  result +=
128  2 + get_serialize_buffer_size<Sid, T, Selector>::get({{}, e});
129  }
130  return result;
131  }
132 };
133 //------------------------------------------------------------------------------
134 template <identifier_t Sid, typename... T, typename Selector>
135 struct get_serialize_buffer_size<Sid, std::tuple<T...>, Selector>
136  : serialize_size_constant<
137  (4 + ... + (2 + serialize_buffer_size_v<Sid, T, Selector>)),
138  (true && ... && (serialize_buffer_is_constant_v<Sid, T, Selector>))> {
139 
140  template <typename Tup>
141  static constexpr auto
142  get(std::pair<string_view, const Tup&> mapped) noexcept {
143  return std_size(
144  12 + mapped.first.size() + 2 +
145  _do_get(mapped.second, std::make_index_sequence<sizeof...(T)>()));
146  }
147 
148 private:
149  template <typename Tup, std::size_t... I>
150  static constexpr auto
151  _do_get(const Tup& t, std::index_sequence<I...>) noexcept {
152  return (
153  0 + ... +
154  (2 + get_serialize_buffer_size<Sid, T, Selector>::get(
155  {string_view(), std::get<I>(t)})));
156  }
157 };
158 //------------------------------------------------------------------------------
159 template <identifier_t Sid, typename T, typename Selector>
160 struct get_struct_serialize_buffer_size : serialize_size_constant<0, false> {
161 
162  static constexpr auto get(std::pair<string_view, const T&> mapped) noexcept {
163  return std_size(
164  12 + mapped.first.size() + 2 + _get(map_data_members(mapped.second)));
165  }
166 
167 private:
168  template <typename Mapped>
169  static constexpr auto _get(const Mapped& mapped) noexcept {
170  return _do_get(
171  mapped, std::make_index_sequence<std::tuple_size_v<Mapped>>());
172  }
173 
174  template <typename... M, std::size_t... I>
175  static constexpr auto _do_get(
176  const std::tuple<std::pair<string_view, const M&>...>& mapped,
177  std::index_sequence<I...>) noexcept {
178  return span_size(
179  (0 + ... +
180  (2 + get_serialize_buffer_size<Sid, M, Selector>::get(
181  std::pair<string_view, const M&>{
182  std::get<I>(mapped).first, std::get<I>(mapped).second}))));
183  }
184 };
185 //------------------------------------------------------------------------------
186 template <identifier_t Sid, typename T, typename Selector>
187 struct get_serialize_buffer_size
188  : std::conditional_t<
189  has_data_member_mapping_v<T>,
190  get_struct_serialize_buffer_size<Sid, T, Selector>,
191  std::conditional_t<
192  has_enumerator_mapping_v<T>,
193  serialize_size_constant<96>,
194  void>> {};
195 //------------------------------------------------------------------------------
196 template <identifier_t SerializerId, typename T, typename Selector>
197 constexpr auto get_serialize_array_for(const T&, Selector) noexcept
198  -> std::array<byte, serialize_buffer_size_v<SerializerId, T, Selector>> {
199  return {};
200 }
201 //------------------------------------------------------------------------------
202 template <identifier_t SerializerId, typename T, typename Selector>
203 inline auto get_serialize_vector_for(const T& inst, Selector) noexcept
204  -> std::vector<byte> {
205  std::vector<byte> result;
206  result.resize(get_serialize_buffer_size<SerializerId, T, Selector>::get(
207  std::pair<string_view, const T&>({}, inst)));
208  return result;
209 }
210 //------------------------------------------------------------------------------
213 template <
214  identifier_t SerializerId,
215  typename T,
216  typename Selector = default_selector_t>
217 constexpr auto serialize_buffer_for(const T& inst, Selector sel = {}) {
218  if constexpr(get_serialize_buffer_size<SerializerId, T, Selector>::
219  is_constant) {
220  return get_serialize_array_for<SerializerId>(inst, sel);
221  } else {
222  return get_serialize_vector_for<SerializerId>(inst, sel);
223  }
224 }
225 //------------------------------------------------------------------------------
226 } // namespace eagine
227 
228 #endif
eagine::string_view
basic_string_span< const char > string_view
Alias for const string views.
Definition: string_span.hpp:116
eagine::default_selector_t
selector< 0U > default_selector_t
Type alias for the default overload selector type.
Definition: selector.hpp:29
eagine::span_size
static constexpr auto span_size(T v) noexcept
Converts argument to span size type.
Definition: types.hpp:59
eagine
Common code is placed in this namespace.
Definition: eagine.hpp:21
eagine::std_size
static constexpr auto std_size(T v) noexcept
Converts argument to std size type.
Definition: types.hpp:52
eagine::serialize_buffer_for
constexpr auto serialize_buffer_for(const T &inst, Selector sel={})
Returns a buffer large enough for the serialization of the specified instance.
Definition: data_buffer.hpp:217
eagine::byte
unsigned char byte
Byte type alias.
Definition: types.hpp:24
eagine::identifier_t
std::uint64_t identifier_t
The underlying integer type for eagine::identifier.
Definition: identifier_t.hpp:19
eagine::size_constant
std::integral_constant< std::size_t, S > size_constant
Alias for size_t constant type.
Definition: int_constant.hpp:35
eagine::identifier
basic_identifier< 10, 6, default_identifier_char_set, identifier_t > identifier
Default identifier type used throughout the project.
Definition: identifier.hpp:346

Copyright © 2015-2021 Matúš Chochlík.
<chochlik -at -gmail.com>
Documentation generated on Tue Apr 13 2021 by Doxygen (version 1.8.17).