MayaFlux 1.0.0
Digital-First Multimedia Processing Framework
Loading...
Searching...
No Matches
CompositeDescribe.hpp
Go to the documentation of this file.
1#pragma once
2
4
7
8namespace MayaFlux::Kakshya {
9
10template <Reflect::Described T>
12
13template <Reflect::Described T>
14bool write_described(CompositeInsertion& insertion, size_t row, const T& value,
15 std::string& error);
16
17template <Reflect::Described T>
18bool overlay_described(const Composite& source, T& target, std::string& error);
19
20/**
21 * @brief Mapping of one described member to a native Composite field.
22 * Specialize for application types that need another exact storage mapping.
23 */
24template <typename T>
26 static_assert(always_false_v<T>, "No Composite field mapping for this described member type");
27};
28
29namespace detail {
30
31inline bool described_field_error(std::string_view name, std::string& error)
32{
33 error = "Cannot bind described field '" + std::string(name) + "'";
34 return false;
35}
36
37}
38
39template <typename T>
40 requires(ArithmeticData<T> || GlmType<T>)
42 static bool add(CompositeLayout& layout, std::string name)
43 {
44 return layout.add_field<T>(std::move(name));
45 }
46
47 static bool write(CompositeInsertion& insertion, size_t row,
48 std::string_view name, T value, std::string& error)
49 {
50 return insertion.set(row, name, value)
51 || detail::described_field_error(name, error);
52 }
53
54 static bool read(const Composite& source, std::string_view name,
55 T& value, std::string& error)
56 {
57 const auto decoded = source.get<T>(name);
58 if (!decoded)
59 return detail::described_field_error(name, error);
60 value = *decoded;
61 return true;
62 }
63};
64
65template <>
66struct CompositeFieldCodec<std::string> {
67 static bool add(CompositeLayout& layout, std::string name)
68 {
69 return layout.add_field<std::string>(std::move(name));
70 }
71
72 static bool write(CompositeInsertion& insertion, size_t row,
73 std::string_view name, const std::string& value, std::string& error)
74 {
75 return insertion.set_text(row, name, value)
76 || detail::described_field_error(name, error);
77 }
78
79 static bool read(const Composite& source, std::string_view name,
80 std::string& value, std::string& error)
81 {
82 const auto decoded = source.text(name);
83 if (!decoded)
84 return detail::described_field_error(name, error);
85 value = *decoded;
86 return true;
87 }
88};
89
90template <>
91struct CompositeFieldCodec<std::vector<uint8_t>> {
92 static bool add(CompositeLayout& layout, std::string name)
93 {
94 return layout.add_field<std::vector<uint8_t>>(std::move(name));
95 }
96
97 static bool write(CompositeInsertion& insertion, size_t row,
98 std::string_view name, const std::vector<uint8_t>& value, std::string& error)
99 {
100 return insertion.set_blob(row, name, value)
101 || detail::described_field_error(name, error);
102 }
103
104 static bool read(const Composite& source, std::string_view name,
105 std::vector<uint8_t>& value, std::string& error)
106 {
107 const auto decoded = source.blob(name);
108 if (!decoded)
109 return detail::described_field_error(name, error);
110 value.assign(decoded->begin(), decoded->end());
111 return true;
112 }
113};
114
115template <typename T>
116 requires std::is_enum_v<T>
117struct CompositeFieldCodec<T> {
118 using Underlying = std::underlying_type_t<T>;
119
120 static bool add(CompositeLayout& layout, std::string name)
121 {
122 return layout.add_field<Underlying>(std::move(name));
123 }
124
125 static bool write(CompositeInsertion& insertion, size_t row,
126 std::string_view name, T value, std::string& error)
127 {
129 insertion, row, name, static_cast<Underlying>(value), error);
130 }
131
132 static bool read(const Composite& source, std::string_view name,
133 T& value, std::string& error)
134 {
135 Underlying decoded {};
136 if (!CompositeFieldCodec<Underlying>::read(source, name, decoded, error))
137 return false;
138 value = static_cast<T>(decoded);
139 return true;
140 }
141};
142
143template <Reflect::Described T>
144struct CompositeFieldCodec<T> {
145 static bool add(CompositeLayout& layout, std::string name)
146 {
147 return layout.add_compound_field(std::move(name), described_composite_layout<T>());
148 }
149
150 static bool write(CompositeInsertion& insertion, size_t row,
151 std::string_view name, const T& value, std::string& error)
152 {
154 CompositeInsertion nested_insertion(nested);
155 const size_t nested_row = nested_insertion.append();
156 if (!write_described(nested_insertion, nested_row, value, error))
157 return false;
158 return insertion.set_compound(row, name, *nested.at(nested_row))
159 || detail::described_field_error(name, error);
160 }
161
162 static bool read(const Composite& source, std::string_view name,
163 T& value, std::string& error)
164 {
165 const auto* nested = source.compound(name);
166 static const CompositeLayout expected = described_composite_layout<T>();
167 if (!nested || nested->size() != 1
168 || !nested->layout().same_structure(expected))
169 return detail::described_field_error(name, error);
170 return overlay_described(*nested->at(0), value, error);
171 }
172};
173
174template <Reflect::Described T>
175struct CompositeFieldCodec<std::vector<T>> {
176 static bool add(CompositeLayout& layout, std::string name)
177 {
178 return layout.add_list_field(std::move(name), described_composite_layout<T>());
179 }
180
181 static bool write(CompositeInsertion& insertion, size_t row,
182 std::string_view name, const std::vector<T>& value, std::string& error)
183 {
185 CompositeInsertion nested_insertion(nested);
186 for (const T& item : value) {
187 if (!write_described(nested_insertion, nested_insertion.append(), item, error))
188 return false;
189 }
190 return insertion.set_list(row, name, nested)
191 || detail::described_field_error(name, error);
192 }
193
194 static bool read(const Composite& source, std::string_view name,
195 std::vector<T>& value, std::string& error)
196 {
197 const auto* nested = source.list(name);
198 static const CompositeLayout expected = described_composite_layout<T>();
199 if (!nested || !nested->layout().same_structure(expected))
200 return detail::described_field_error(name, error);
201 std::vector<T> decoded;
202 decoded.reserve(nested->size());
203 for (size_t i = 0; i < nested->size(); ++i) {
204 T item {};
205 const auto record = nested->at(i);
206 if (!record || !overlay_described(*record, item, error))
207 return false;
208 decoded.push_back(std::move(item));
209 }
210 value = std::move(decoded);
211 return true;
212 }
213};
214
215template <typename T>
216 requires(!Reflect::Described<T> && !std::same_as<T, uint8_t>)
217struct CompositeFieldCodec<std::vector<T>> {
219 {
220 CompositeLayout layout;
221 CompositeFieldCodec<T>::add(layout, "value");
222 return layout;
223 }
224
225 static bool add(CompositeLayout& layout, std::string name)
226 {
227 return layout.add_list_field(std::move(name), item_layout());
228 }
229
230 static bool write(CompositeInsertion& insertion, size_t row,
231 std::string_view name, const std::vector<T>& value, std::string& error)
232 {
233 CompositeArray nested(item_layout());
234 CompositeInsertion nested_insertion(nested);
235 for (const T& item : value) {
237 nested_insertion, nested_insertion.append(), "value", item, error))
238 return false;
239 }
240 return insertion.set_list(row, name, nested)
241 || detail::described_field_error(name, error);
242 }
243
244 static bool read(const Composite& source, std::string_view name,
245 std::vector<T>& value, std::string& error)
246 {
247 const auto* nested = source.list(name);
248 static const CompositeLayout expected = item_layout();
249 if (!nested || !nested->layout().same_structure(expected))
250 return detail::described_field_error(name, error);
251 std::vector<T> decoded;
252 decoded.reserve(nested->size());
253 for (size_t i = 0; i < nested->size(); ++i) {
254 const auto record = nested->at(i);
255 if (!record)
256 return detail::described_field_error(name, error);
257 T item {};
258 if (record->has("value")) {
259 if (!CompositeFieldCodec<T>::read(*record, "value", item, error))
260 return false;
261 } else if constexpr (!Reflect::is_optional_v<T>) {
262 return detail::described_field_error(name, error);
263 }
264 decoded.push_back(std::move(item));
265 }
266 value = std::move(decoded);
267 return true;
268 }
269};
270
271template <typename T>
272struct CompositeFieldCodec<std::optional<T>> {
273 static bool add(CompositeLayout& layout, std::string name)
274 {
275 return CompositeFieldCodec<T>::add(layout, std::move(name));
276 }
277
278 static bool write(CompositeInsertion& insertion, size_t row,
279 std::string_view name, const std::optional<T>& value, std::string& error)
280 {
281 if (!value)
282 return insertion.clear(row, name)
283 || detail::described_field_error(name, error);
284 return CompositeFieldCodec<T>::write(insertion, row, name, *value, error);
285 }
286
287 static bool read(const Composite& source, std::string_view name,
288 std::optional<T>& value, std::string& error)
289 {
290 if (value)
291 return CompositeFieldCodec<T>::read(source, name, *value, error);
292 T decoded {};
293 if (!CompositeFieldCodec<T>::read(source, name, decoded, error))
294 return false;
295 value = std::move(decoded);
296 return true;
297 }
298};
299
300/** @brief Derive a Composite layout from a generated member description. */
301template <Reflect::Described T>
303{
304 CompositeLayout layout;
305 bool added = true;
306 std::apply([&](const auto&... members) {
307 ((added = added && CompositeFieldCodec<typename std::remove_cvref_t<decltype(members)>::value_type>
308 ::add(layout, std::string(members.name))), ...);
310 if (!added)
311 throw std::invalid_argument("Cannot derive Composite layout from description");
312 return layout;
313}
314
315/**
316 * @brief Write all described members into an existing Composite row.
317 * @note A failed write may leave earlier members present in the row.
318 */
319template <Reflect::Described T>
320bool write_described(CompositeInsertion& insertion, size_t row, const T& value,
321 std::string& error)
322{
323 error.clear();
324 bool written = true;
325 std::apply([&](const auto&... members) {
326 ((written = written && CompositeFieldCodec<typename std::remove_cvref_t<decltype(members)>::value_type>
327 ::write(insertion, row, members.name, members.get(value), error)), ...);
329 return written;
330}
331
332/**
333 * @brief Apply present Composite fields to a described value, preserving other members.
334 * @note A failed overlay may have applied earlier fields to the target.
335 */
336template <Reflect::Described T>
337bool overlay_described(const Composite& source, T& target, std::string& error)
338{
339 error.clear();
341 [&](const auto& visit) {
342 return source.for_each_present_field([&](const CompositeField& field) {
343 return visit(field.name, field);
344 });
345 },
346 [&](std::string_view, const CompositeField& field, auto& value) {
347 using Value = std::remove_cvref_t<decltype(value)>;
348 return CompositeFieldCodec<Value>::read(source, field.name, value, error);
349 },
350 [&](std::string_view name) {
351 error = "Unknown described field '" + std::string(name) + "'";
352 return false;
353 });
354}
355
356}
std::optional< Composite > at(size_t index) const noexcept
Borrow an element by index.
Owns a sequence of values that share a CompositeLayout.
bool set(size_t index, std::string_view field_name, T value)
Write an arithmetic or GLM field of an existing element.
bool clear(size_t index, std::string_view field_name)
Mark a named field absent in an existing element.
bool set_compound(size_t index, std::string_view field_name, const Composite &value)
Copy one record into a compound field.
bool set_text(size_t index, std::string_view field_name, std::string_view value)
Write UTF-8 bytes to a std::string field.
bool set_blob(size_t index, std::string_view field_name, std::span< const uint8_t > value)
Write binary bytes to a fixed or dynamic BLOB field.
size_t append()
Append an empty element.
bool set_list(size_t index, std::string_view field_name, const CompositeArray &values)
Copy ordered records into a list field.
Mutable insertion adapter for a CompositeArray.
bool add_compound_field(std::string name, CompositeLayout layout)
Declare a compound field containing one nested record.
Definition Composite.cpp:91
bool add_list_field(std::string name, CompositeLayout item_layout)
Declare a list field containing ordered nested records.
Definition Composite.cpp:96
bool add_field(std::string name)
Declare a named arithmetic, GLM, text, or binary field.
Definition Composite.hpp:74
Shared field description and byte layout for a CompositeArray.
Definition Composite.hpp:60
Read view of one value in a CompositeArray.
A type whose generated sidecar defines Generated::Description<T>::members().
Definition Describe.hpp:86
bool described_field_error(std::string_view name, std::string &error)
CompositeLayout described_composite_layout()
Derive a Composite layout from a generated member description.
bool overlay_described(const Composite &source, T &target, std::string &error)
Apply present Composite fields to a described value, preserving other members.
bool write_described(CompositeInsertion &insertion, size_t row, const T &value, std::string &error)
Write all described members into an existing Composite row.
constexpr bool is_optional_v
Definition Mirror.hpp:16
bool overlay_described_fields(T &target, Fields &&fields, Decode &&decode, Unknown &&unknown)
Apply present named fields to a described value.
std::pair< std::shared_ptr< Kriya::BufferPipeline >, std::shared_ptr< Buffers::AudioBuffer > > record(const std::shared_ptr< Kakshya::DynamicSoundStream > &stream, uint32_t input_channel, double seconds, std::optional< uint32_t > monitor, uint32_t channel)
Record a live input channel into a stream for a number of seconds.
Definition Rigs.cpp:262
static bool write(CompositeInsertion &insertion, size_t row, std::string_view name, T value, std::string &error)
static bool read(const Composite &source, std::string_view name, T &value, std::string &error)
static bool add(CompositeLayout &layout, std::string name)
static bool write(CompositeInsertion &insertion, size_t row, std::string_view name, const T &value, std::string &error)
static bool add(CompositeLayout &layout, std::string name)
static bool write(CompositeInsertion &insertion, size_t row, std::string_view name, const std::optional< T > &value, std::string &error)
static bool read(const Composite &source, std::string_view name, std::optional< T > &value, std::string &error)
static bool read(const Composite &source, std::string_view name, std::string &value, std::string &error)
static bool write(CompositeInsertion &insertion, size_t row, std::string_view name, const std::string &value, std::string &error)
static bool add(CompositeLayout &layout, std::string name)
static bool write(CompositeInsertion &insertion, size_t row, std::string_view name, const std::vector< T > &value, std::string &error)
static bool read(const Composite &source, std::string_view name, std::vector< T > &value, std::string &error)
static bool add(CompositeLayout &layout, std::string name)
static bool read(const Composite &source, std::string_view name, std::vector< uint8_t > &value, std::string &error)
static bool add(CompositeLayout &layout, std::string name)
static bool write(CompositeInsertion &insertion, size_t row, std::string_view name, const std::vector< uint8_t > &value, std::string &error)
Mapping of one described member to a native Composite field.
Description of one named value in a Composite.
Definition Composite.hpp:20