cpp-common/bt2: field.hpp: Add assignment operator for Enum field
[babeltrace.git] / src / cpp-common / bt2 / field.hpp
CommitLineData
a1e31878
PP
1/*
2 * Copyright (c) 2020 Philippe Proulx <pproulx@efficios.com>
3 *
4 * SPDX-License-Identifier: MIT
5 */
6
7#ifndef BABELTRACE_CPP_COMMON_BT2_FIELD_HPP
8#define BABELTRACE_CPP_COMMON_BT2_FIELD_HPP
9
10#include <type_traits>
11#include <cstdint>
12#include <babeltrace2/babeltrace.h>
13
14#include "common/assert.h"
15#include "internal/borrowed-obj.hpp"
4927bae7 16#include "internal/utils.hpp"
a1e31878
PP
17#include "cpp-common/optional.hpp"
18#include "cpp-common/string_view.hpp"
19#include "field-class.hpp"
20
21namespace bt2 {
22
23template <typename LibObjT>
24class CommonBoolField;
25
26template <typename LibObjT>
27class CommonBitArrayField;
28
29template <typename LibObjT>
30class CommonUnsignedIntegerField;
31
32template <typename LibObjT>
33class CommonSignedIntegerField;
34
35template <typename LibObjT>
36class CommonUnsignedEnumerationField;
37
38template <typename LibObjT>
39class CommonSignedEnumerationField;
40
41template <typename LibObjT>
42class CommonSinglePrecisionRealField;
43
44template <typename LibObjT>
45class CommonDoublePrecisionRealField;
46
47template <typename LibObjT>
48class CommonStringField;
49
50template <typename LibObjT>
51class CommonStructureField;
52
53template <typename LibObjT>
54class CommonArrayField;
55
56template <typename LibObjT>
57class CommonDynamicArrayField;
58
59template <typename LibObjT>
60class CommonOptionField;
61
62template <typename LibObjT>
63class CommonVariantField;
64
65namespace internal {
66
67template <typename LibObjT>
68struct CommonFieldSpec;
69
b5f55e9f 70/* Functions specific to mutable fields */
a1e31878
PP
71template <>
72struct CommonFieldSpec<bt_field> final
73{
74 static bt_field_class *cls(bt_field * const libObjPtr) noexcept
75 {
76 return bt_field_borrow_class(libObjPtr);
77 }
78};
79
b5f55e9f 80/* Functions specific to constant fields */
a1e31878
PP
81template <>
82struct CommonFieldSpec<const bt_field> final
83{
84 static const bt_field_class *cls(const bt_field * const libObjPtr) noexcept
85 {
86 return bt_field_borrow_class_const(libObjPtr);
87 }
88};
89
b5f55e9f 90} /* namespace internal */
a1e31878
PP
91
92template <typename LibObjT>
93class CommonField : public internal::BorrowedObj<LibObjT>
94{
95private:
96 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
97
98protected:
99 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
100 using _ThisCommonField = CommonField<LibObjT>;
101
102public:
103 using Class =
104 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
105
106 explicit CommonField(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
107 {
108 }
109
110 template <typename OtherLibObjT>
100fa861 111 CommonField(const CommonField<OtherLibObjT> val) noexcept : _ThisBorrowedObj {val}
a1e31878
PP
112 {
113 }
114
115 template <typename OtherLibObjT>
100fa861 116 _ThisCommonField& operator=(const CommonField<OtherLibObjT> val) noexcept
a1e31878
PP
117 {
118 _ThisBorrowedObj::operator=(val);
119 return *this;
120 }
121
122 FieldClassType classType() const noexcept
123 {
341a67c4 124 return static_cast<FieldClassType>(bt_field_get_class_type(this->libObjPtr()));
a1e31878
PP
125 }
126
127 ConstFieldClass cls() const noexcept
128 {
341a67c4 129 return ConstFieldClass {internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
130 }
131
132 Class cls() noexcept
133 {
341a67c4 134 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
135 }
136
137 bool isBool() const noexcept
138 {
139 return this->cls().isBool();
140 }
141
142 bool isBitArray() const noexcept
143 {
144 return this->cls().isBitArray();
145 }
146
147 bool isUnsignedInteger() const noexcept
148 {
149 return this->cls().isUnsignedInteger();
150 }
151
152 bool isSignedInteger() const noexcept
153 {
154 return this->cls().isSignedInteger();
155 }
156
157 bool isUnsignedEnumeration() const noexcept
158 {
159 return this->cls().isUnsignedEnumeration();
160 }
161
162 bool isSignedEnumeration() const noexcept
163 {
164 return this->cls().isSignedEnumeration();
165 }
166
167 bool isSinglePrecisionReal() const noexcept
168 {
169 return this->cls().isSinglePrecisionReal();
170 }
171
172 bool isDoublePrecisionReal() const noexcept
173 {
174 return this->cls().isDoublePrecisionReal();
175 }
176
177 bool isString() const noexcept
178 {
179 return this->cls().isString();
180 }
181
182 bool isStructure() const noexcept
183 {
184 return this->cls().isStructure();
185 }
186
187 bool isArray() const noexcept
188 {
189 return this->cls().isArray();
190 }
191
192 bool isDynamicArray() const noexcept
193 {
194 return this->cls().isDynamicArray();
195 }
196
197 bool isOption() const noexcept
198 {
199 return this->cls().isOption();
200 }
201
202 bool isVariant() const noexcept
203 {
204 return this->cls().isVariant();
205 }
206
45e0ded5
PP
207 template <typename FieldT>
208 FieldT as() const noexcept
209 {
210 return FieldT {this->libObjPtr()};
211 }
212
a1e31878
PP
213 CommonBoolField<LibObjT> asBool() const noexcept;
214 CommonBitArrayField<LibObjT> asBitArray() const noexcept;
215 CommonUnsignedIntegerField<LibObjT> asUnsignedInteger() const noexcept;
216 CommonSignedIntegerField<LibObjT> asSignedInteger() const noexcept;
217 CommonUnsignedEnumerationField<LibObjT> asUnsignedEnumeration() const noexcept;
218 CommonSignedEnumerationField<LibObjT> asSignedEnumeration() const noexcept;
219 CommonSinglePrecisionRealField<LibObjT> asSinglePrecisionReal() const noexcept;
220 CommonDoublePrecisionRealField<LibObjT> asDoublePrecisionReal() const noexcept;
221 CommonStringField<LibObjT> asString() const noexcept;
222 CommonStructureField<LibObjT> asStructure() const noexcept;
223 CommonArrayField<LibObjT> asArray() const noexcept;
224 CommonDynamicArrayField<LibObjT> asDynamicArray() const noexcept;
225 CommonOptionField<LibObjT> asOption() const noexcept;
226 CommonVariantField<LibObjT> asVariant() const noexcept;
227};
228
229using Field = CommonField<bt_field>;
230using ConstField = CommonField<const bt_field>;
231
4927bae7
PP
232namespace internal {
233
234struct FieldTypeDescr
235{
236 using Const = ConstField;
237 using NonConst = Field;
238};
239
240template <>
241struct TypeDescr<Field> : public FieldTypeDescr
242{
243};
244
245template <>
246struct TypeDescr<ConstField> : public FieldTypeDescr
247{
248};
249
250} /* namespace internal */
251
a1e31878
PP
252template <typename LibObjT>
253class CommonBoolField final : public CommonField<LibObjT>
254{
255private:
256 using typename CommonField<LibObjT>::_LibObjPtr;
257 using typename CommonField<LibObjT>::_ThisCommonField;
258
259public:
260 using Value = bool;
261
262 explicit CommonBoolField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
263 {
264 BT_ASSERT_DBG(this->isBool());
265 }
266
267 template <typename OtherLibObjT>
100fa861 268 CommonBoolField(const CommonBoolField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
a1e31878
PP
269 {
270 }
271
272 template <typename OtherLibObjT>
100fa861 273 CommonBoolField<LibObjT>& operator=(const CommonBoolField<OtherLibObjT> val) noexcept
a1e31878
PP
274 {
275 _ThisCommonField::operator=(val);
276 return *this;
277 }
278
279 CommonBoolField<LibObjT>& operator=(const Value val) noexcept
280 {
281 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
282
341a67c4 283 bt_field_bool_set_value(this->libObjPtr(), static_cast<bt_bool>(val));
a1e31878
PP
284 return *this;
285 }
286
287 Value value() const noexcept
288 {
341a67c4 289 return static_cast<Value>(bt_field_bool_get_value(this->libObjPtr()));
a1e31878
PP
290 }
291
292 operator Value() const noexcept
293 {
294 return this->value();
295 }
296};
297
298using BoolField = CommonBoolField<bt_field>;
299using ConstBoolField = CommonBoolField<const bt_field>;
300
4927bae7
PP
301namespace internal {
302
303struct BoolFieldTypeDescr
304{
305 using Const = ConstBoolField;
306 using NonConst = BoolField;
307};
308
309template <>
310struct TypeDescr<BoolField> : public BoolFieldTypeDescr
311{
312};
313
314template <>
315struct TypeDescr<ConstBoolField> : public BoolFieldTypeDescr
316{
317};
318
319} /* namespace internal */
320
a1e31878
PP
321template <typename LibObjT>
322class CommonBitArrayField final : public CommonField<LibObjT>
323{
324private:
325 using typename CommonField<LibObjT>::_LibObjPtr;
326 using typename CommonField<LibObjT>::_ThisCommonField;
327
328public:
329 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstBitArrayFieldClass,
330 BitArrayFieldClass>::type;
331
332 explicit CommonBitArrayField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
333 {
334 BT_ASSERT_DBG(this->isBitArray());
335 }
336
337 template <typename OtherLibObjT>
100fa861 338 CommonBitArrayField(const CommonBitArrayField<OtherLibObjT> val) noexcept :
a1e31878
PP
339 _ThisCommonField {val}
340 {
341 }
342
343 template <typename OtherLibObjT>
100fa861 344 CommonBitArrayField<LibObjT>& operator=(const CommonBitArrayField<OtherLibObjT> val) noexcept
a1e31878
PP
345 {
346 _ThisCommonField::operator=(val);
347 return *this;
348 }
349
350 ConstBitArrayFieldClass cls() const noexcept
351 {
352 return ConstBitArrayFieldClass {
341a67c4 353 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
354 }
355
356 Class cls() noexcept
357 {
341a67c4 358 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
359 }
360
361 CommonBitArrayField<LibObjT>& operator=(const std::uint64_t bits) noexcept
362 {
363 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
364
341a67c4 365 bt_field_bit_array_set_value_as_integer(this->libObjPtr(), bits);
a1e31878
PP
366 return *this;
367 }
368
369 std::uint64_t valueAsInteger() const noexcept
370 {
341a67c4 371 return bt_field_bit_array_get_value_as_integer(this->libObjPtr());
a1e31878
PP
372 }
373
374 bool bitValue(const std::uint64_t index) const noexcept
375 {
376 BT_ASSERT_DBG(index < this->cls().length());
377 return static_cast<bool>(this->valueAsInteger() & (1ULL << index));
378 }
379};
380
381using BitArrayField = CommonBitArrayField<bt_field>;
382using ConstBitArrayField = CommonBitArrayField<const bt_field>;
383
4927bae7
PP
384namespace internal {
385
386struct BitArrayFieldTypeDescr
387{
388 using Const = ConstBitArrayField;
389 using NonConst = BitArrayField;
390};
391
392template <>
393struct TypeDescr<BitArrayField> : public BitArrayFieldTypeDescr
394{
395};
396
397template <>
398struct TypeDescr<ConstBitArrayField> : public BitArrayFieldTypeDescr
399{
400};
401
402} /* namespace internal */
403
a1e31878 404template <typename LibObjT>
edfe13aa 405class CommonUnsignedIntegerField : public CommonField<LibObjT>
a1e31878
PP
406{
407private:
408 using typename CommonField<LibObjT>::_ThisCommonField;
409
410protected:
411 using typename CommonField<LibObjT>::_LibObjPtr;
412 using _ThisCommonUnsignedIntegerField = CommonUnsignedIntegerField<LibObjT>;
413
414public:
415 using Value = std::uint64_t;
416
417 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstIntegerFieldClass,
418 IntegerFieldClass>::type;
419
420 explicit CommonUnsignedIntegerField(const _LibObjPtr libObjPtr) noexcept :
421 _ThisCommonField {libObjPtr}
422 {
423 BT_ASSERT_DBG(this->isUnsignedInteger());
424 }
425
426 template <typename OtherLibObjT>
100fa861 427 CommonUnsignedIntegerField(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept :
a1e31878
PP
428 _ThisCommonField {val}
429 {
430 }
431
432 template <typename OtherLibObjT>
433 _ThisCommonUnsignedIntegerField&
100fa861 434 operator=(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept
a1e31878
PP
435 {
436 _ThisCommonField::operator=(val);
437 return *this;
438 }
439
440 ConstIntegerFieldClass cls() const noexcept
441 {
442 return ConstIntegerFieldClass {
341a67c4 443 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
444 }
445
446 Class cls() noexcept
447 {
341a67c4 448 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
449 }
450
451 CommonUnsignedIntegerField<LibObjT>& operator=(const Value val) noexcept
452 {
453 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
454
341a67c4 455 bt_field_integer_unsigned_set_value(this->libObjPtr(), val);
a1e31878
PP
456 return *this;
457 }
458
459 Value value() const noexcept
460 {
341a67c4 461 return bt_field_integer_unsigned_get_value(this->libObjPtr());
a1e31878
PP
462 }
463
464 operator Value() const noexcept
465 {
466 return this->value();
467 }
468};
469
470using UnsignedIntegerField = CommonUnsignedIntegerField<bt_field>;
471using ConstUnsignedIntegerField = CommonUnsignedIntegerField<const bt_field>;
472
4927bae7
PP
473namespace internal {
474
475struct UnsignedIntegerFieldTypeDescr
476{
477 using Const = ConstUnsignedIntegerField;
478 using NonConst = UnsignedIntegerField;
479};
480
481template <>
482struct TypeDescr<UnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
483{
484};
485
486template <>
487struct TypeDescr<ConstUnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
488{
489};
490
491} /* namespace internal */
492
a1e31878 493template <typename LibObjT>
edfe13aa 494class CommonSignedIntegerField : public CommonField<LibObjT>
a1e31878
PP
495{
496private:
497 using typename CommonField<LibObjT>::_ThisCommonField;
498
499protected:
500 using typename CommonField<LibObjT>::_LibObjPtr;
501 using _ThisCommonSignedIntegerField = CommonSignedIntegerField<LibObjT>;
502
503public:
edfe13aa 504 using Value = std::int64_t;
a1e31878
PP
505
506 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstIntegerFieldClass,
507 IntegerFieldClass>::type;
508
509 explicit CommonSignedIntegerField(const _LibObjPtr libObjPtr) noexcept :
510 _ThisCommonField {libObjPtr}
511 {
512 BT_ASSERT_DBG(this->isSignedInteger());
513 }
514
515 template <typename OtherLibObjT>
100fa861 516 CommonSignedIntegerField(const CommonSignedIntegerField<OtherLibObjT> val) noexcept :
a1e31878
PP
517 _ThisCommonField {val}
518 {
519 }
520
521 template <typename OtherLibObjT>
522 _ThisCommonSignedIntegerField&
100fa861 523 operator=(const CommonSignedIntegerField<OtherLibObjT> val) noexcept
a1e31878
PP
524 {
525 _ThisCommonField::operator=(val);
526 return *this;
527 }
528
529 ConstIntegerFieldClass cls() const noexcept
530 {
531 return ConstIntegerFieldClass {
341a67c4 532 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
533 }
534
535 Class cls() noexcept
536 {
341a67c4 537 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
538 }
539
540 CommonSignedIntegerField<LibObjT>& operator=(const Value val) noexcept
541 {
542 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
543
341a67c4 544 bt_field_integer_signed_set_value(this->libObjPtr(), val);
a1e31878
PP
545 return *this;
546 }
547
548 Value value() const noexcept
549 {
341a67c4 550 return bt_field_integer_signed_get_value(this->libObjPtr());
a1e31878
PP
551 }
552
553 operator Value() const noexcept
554 {
555 return this->value();
556 }
557};
558
559using SignedIntegerField = CommonSignedIntegerField<bt_field>;
560using ConstSignedIntegerField = CommonSignedIntegerField<const bt_field>;
561
4927bae7
PP
562namespace internal {
563
564struct SignedIntegerFieldTypeDescr
565{
566 using Const = ConstSignedIntegerField;
567 using NonConst = SignedIntegerField;
568};
569
570template <>
571struct TypeDescr<SignedIntegerField> : public SignedIntegerFieldTypeDescr
572{
573};
574
575template <>
576struct TypeDescr<ConstSignedIntegerField> : public SignedIntegerFieldTypeDescr
577{
578};
579
580} /* namespace internal */
581
a1e31878
PP
582class EnumerationFieldClassMappingLabels
583{
584public:
585 explicit EnumerationFieldClassMappingLabels(
586 const bt_field_class_enumeration_mapping_label_array labels, const std::uint64_t size) :
587 _mLabels {labels},
588 _mSize {size}
589 {
590 }
591
592 EnumerationFieldClassMappingLabels(const EnumerationFieldClassMappingLabels&) noexcept =
593 default;
594
595 EnumerationFieldClassMappingLabels&
596 operator=(const EnumerationFieldClassMappingLabels&) noexcept = default;
597
598 std::uint64_t size() const noexcept
599 {
600 return _mSize;
601 }
602
603 bpstd::string_view operator[](const std::uint64_t index) const noexcept
604 {
605 return _mLabels[index];
606 }
607
608private:
609 bt_field_class_enumeration_mapping_label_array _mLabels;
610 std::uint64_t _mSize;
611};
612
613template <typename LibObjT>
614class CommonUnsignedEnumerationField final : public CommonUnsignedIntegerField<LibObjT>
615{
616private:
617 using typename CommonUnsignedIntegerField<LibObjT>::_ThisCommonUnsignedIntegerField;
618 using typename CommonField<LibObjT>::_LibObjPtr;
619
620public:
621 using Class =
622 typename std::conditional<std::is_const<LibObjT>::value, ConstUnsignedEnumerationFieldClass,
623 UnsignedEnumerationFieldClass>::type;
624
625 explicit CommonUnsignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
626 _ThisCommonUnsignedIntegerField {libObjPtr}
627 {
628 BT_ASSERT_DBG(this->isUnsignedEnumeration());
629 }
630
631 template <typename OtherLibObjT>
100fa861 632 CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
a1e31878
PP
633 :
634 _ThisCommonUnsignedIntegerField {val}
635 {
636 }
637
638 template <typename OtherLibObjT>
639 CommonUnsignedEnumerationField<LibObjT>&
100fa861 640 operator=(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
a1e31878
PP
641 {
642 _ThisCommonUnsignedIntegerField::operator=(val);
643 return *this;
644 }
645
646 ConstUnsignedEnumerationFieldClass cls() const noexcept
647 {
648 return ConstUnsignedEnumerationFieldClass {
341a67c4 649 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
650 }
651
a44a9938
FD
652 using CommonUnsignedIntegerField<LibObjT>::operator=;
653
a1e31878
PP
654 Class cls() noexcept
655 {
341a67c4 656 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
657 }
658
659 EnumerationFieldClassMappingLabels labels() const
660 {
661 bt_field_class_enumeration_mapping_label_array labelArray;
662 std::uint64_t count;
341a67c4 663 const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->libObjPtr(),
a1e31878
PP
664 &labelArray, &count);
665
666 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
39278ebc 667 throw MemoryError {};
a1e31878
PP
668 }
669
670 return EnumerationFieldClassMappingLabels {labelArray, count};
671 }
672};
673
674using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
675using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
676
4927bae7
PP
677namespace internal {
678
679struct UnsignedEnumerationFieldTypeDescr
680{
681 using Const = ConstUnsignedEnumerationField;
682 using NonConst = UnsignedEnumerationField;
683};
684
685template <>
686struct TypeDescr<UnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
687{
688};
689
690template <>
691struct TypeDescr<ConstUnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
692{
693};
694
695} /* namespace internal */
696
a1e31878
PP
697template <typename LibObjT>
698class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
699{
700private:
701 using typename CommonSignedIntegerField<LibObjT>::_ThisCommonSignedIntegerField;
702 using typename CommonField<LibObjT>::_LibObjPtr;
703
704public:
705 using Class =
706 typename std::conditional<std::is_const<LibObjT>::value, ConstSignedEnumerationFieldClass,
707 SignedEnumerationFieldClass>::type;
708
709 explicit CommonSignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
710 _ThisCommonSignedIntegerField {libObjPtr}
711 {
712 BT_ASSERT_DBG(this->isSignedEnumeration());
713 }
714
715 template <typename OtherLibObjT>
100fa861 716 CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept :
a1e31878
PP
717 _ThisCommonSignedIntegerField {val}
718 {
719 }
720
721 template <typename OtherLibObjT>
722 CommonSignedEnumerationField<LibObjT>&
100fa861 723 operator=(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept
a1e31878
PP
724 {
725 _ThisCommonSignedIntegerField::operator=(val);
726 return *this;
727 }
728
a44a9938
FD
729 using CommonSignedIntegerField<LibObjT>::operator=;
730
a1e31878
PP
731 ConstSignedEnumerationFieldClass cls() const noexcept
732 {
733 return ConstSignedEnumerationFieldClass {
341a67c4 734 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
735 }
736
737 Class cls() noexcept
738 {
341a67c4 739 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
740 }
741
742 EnumerationFieldClassMappingLabels labels() const
743 {
744 bt_field_class_enumeration_mapping_label_array labelArray;
745 std::uint64_t count;
746 const auto status =
341a67c4 747 bt_field_enumeration_signed_get_mapping_labels(this->libObjPtr(), &labelArray, &count);
a1e31878
PP
748
749 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
39278ebc 750 throw MemoryError {};
a1e31878
PP
751 }
752
753 return EnumerationFieldClassMappingLabels {labelArray, count};
754 }
755};
756
757using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
758using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
759
4927bae7
PP
760namespace internal {
761
762struct SignedEnumerationFieldTypeDescr
763{
764 using Const = ConstSignedEnumerationField;
765 using NonConst = SignedEnumerationField;
766};
767
768template <>
769struct TypeDescr<SignedEnumerationField> : public SignedEnumerationFieldTypeDescr
770{
771};
772
773template <>
774struct TypeDescr<ConstSignedEnumerationField> : public SignedEnumerationFieldTypeDescr
775{
776};
777
778} /* namespace internal */
779
a1e31878
PP
780template <typename LibObjT>
781class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
782{
783private:
784 using typename CommonField<LibObjT>::_LibObjPtr;
785 using typename CommonField<LibObjT>::_ThisCommonField;
786
787public:
788 using Value = float;
789
790 explicit CommonSinglePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
791 _ThisCommonField {libObjPtr}
792 {
793 BT_ASSERT_DBG(this->isSinglePrecisionReal());
794 }
795
796 template <typename OtherLibObjT>
100fa861 797 CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
a1e31878
PP
798 :
799 _ThisCommonField {val}
800 {
801 }
802
803 template <typename OtherLibObjT>
804 CommonSinglePrecisionRealField<LibObjT>&
100fa861 805 operator=(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
a1e31878
PP
806 {
807 _ThisCommonField::operator=(val);
808 return *this;
809 }
810
811 CommonSinglePrecisionRealField<LibObjT>& operator=(const Value val) noexcept
812 {
813 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
814
341a67c4 815 bt_field_real_single_precision_set_value(this->libObjPtr(), val);
a1e31878
PP
816 return *this;
817 }
818
819 Value value() const noexcept
820 {
341a67c4 821 return bt_field_real_single_precision_get_value(this->libObjPtr());
a1e31878
PP
822 }
823
824 operator Value() const noexcept
825 {
826 return this->value();
827 }
828};
829
830using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
831using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
832
4927bae7
PP
833namespace internal {
834
835struct SinglePrecisionRealFieldTypeDescr
836{
837 using Const = ConstSinglePrecisionRealField;
838 using NonConst = SinglePrecisionRealField;
839};
840
841template <>
842struct TypeDescr<SinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
843{
844};
845
846template <>
847struct TypeDescr<ConstSinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
848{
849};
850
851} /* namespace internal */
852
a1e31878
PP
853template <typename LibObjT>
854class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
855{
856private:
857 using typename CommonField<LibObjT>::_LibObjPtr;
858 using typename CommonField<LibObjT>::_ThisCommonField;
859
860public:
861 using Value = double;
862
863 explicit CommonDoublePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
864 _ThisCommonField {libObjPtr}
865 {
866 BT_ASSERT_DBG(this->isDoublePrecisionReal());
867 }
868
869 template <typename OtherLibObjT>
100fa861 870 CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
a1e31878
PP
871 :
872 _ThisCommonField {val}
873 {
874 }
875
876 template <typename OtherLibObjT>
877 CommonDoublePrecisionRealField<LibObjT>&
100fa861 878 operator=(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
a1e31878
PP
879 {
880 _ThisCommonField::operator=(val);
881 return *this;
882 }
883
884 CommonDoublePrecisionRealField<LibObjT>& operator=(const Value val) noexcept
885 {
886 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
887
edfe13aa 888 bt_field_real_double_precision_set_value(this->libObjPtr(), val);
a1e31878
PP
889 return *this;
890 }
891
892 Value value() const noexcept
893 {
edfe13aa 894 return bt_field_real_double_precision_get_value(this->libObjPtr());
a1e31878
PP
895 }
896
897 operator Value() const noexcept
898 {
899 return this->value();
900 }
901};
902
903using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
904using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
905
4927bae7
PP
906namespace internal {
907
908struct DoublePrecisionRealFieldTypeDescr
909{
910 using Const = ConstDoublePrecisionRealField;
911 using NonConst = DoublePrecisionRealField;
912};
913
914template <>
915struct TypeDescr<DoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
916{
917};
918
919template <>
920struct TypeDescr<ConstDoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
921{
922};
923
924} /* namespace internal */
925
a1e31878
PP
926template <typename LibObjT>
927class CommonStringField final : public CommonField<LibObjT>
928{
929private:
930 using typename CommonField<LibObjT>::_LibObjPtr;
931 using typename CommonField<LibObjT>::_ThisCommonField;
932
933public:
934 explicit CommonStringField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
935 {
936 BT_ASSERT_DBG(this->isString());
937 }
938
939 template <typename OtherLibObjT>
100fa861 940 CommonStringField(const CommonStringField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
a1e31878
PP
941 {
942 }
943
944 template <typename OtherLibObjT>
100fa861 945 CommonStringField<LibObjT>& operator=(const CommonStringField<OtherLibObjT> val) noexcept
a1e31878
PP
946 {
947 _ThisCommonField::operator=(val);
948 return *this;
949 }
950
edfe13aa 951 CommonStringField<LibObjT>& operator=(const char * const val)
a1e31878
PP
952 {
953 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
954
341a67c4 955 const auto status = bt_field_string_set_value(this->libObjPtr(), val);
a1e31878
PP
956
957 if (status == BT_FIELD_STRING_SET_VALUE_STATUS_MEMORY_ERROR) {
39278ebc 958 throw MemoryError {};
a1e31878
PP
959 }
960
961 return *this;
962 }
963
edfe13aa 964 CommonStringField<LibObjT>& operator=(const std::string& val)
a1e31878
PP
965 {
966 return *this = val.data();
967 }
968
8a79c777
FD
969 void append(const char * const begin, const std::uint64_t len)
970 {
971 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
972
973 const auto status = bt_field_string_append_with_length(this->libObjPtr(), begin, len);
974
975 if (status == BT_FIELD_STRING_APPEND_STATUS_MEMORY_ERROR) {
976 throw MemoryError {};
977 }
978 }
979
980 void append(const std::string& val)
981 {
982 this->append(val.data(), val.size());
983 }
984
a1e31878
PP
985 void clear() noexcept
986 {
987 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
988
341a67c4 989 bt_field_string_clear(this->libObjPtr());
a1e31878
PP
990 }
991
992 bpstd::string_view value() const noexcept
993 {
341a67c4 994 return bt_field_string_get_value(this->libObjPtr());
a1e31878
PP
995 }
996};
997
998using StringField = CommonStringField<bt_field>;
999using ConstStringField = CommonStringField<const bt_field>;
1000
1001namespace internal {
1002
4927bae7
PP
1003struct StringFieldTypeDescr
1004{
1005 using Const = ConstStringField;
1006 using NonConst = StringField;
1007};
1008
1009template <>
1010struct TypeDescr<StringField> : public StringFieldTypeDescr
1011{
1012};
1013
1014template <>
1015struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
1016{
1017};
1018
a1e31878
PP
1019template <typename LibObjT>
1020struct CommonStructureFieldSpec;
1021
b5f55e9f 1022/* Functions specific to mutable structure fields */
a1e31878
PP
1023template <>
1024struct CommonStructureFieldSpec<bt_field> final
1025{
1026 static bt_field *memberFieldByIndex(bt_field * const libObjPtr,
1027 const std::uint64_t index) noexcept
1028 {
1029 return bt_field_structure_borrow_member_field_by_index(libObjPtr, index);
1030 }
1031
1032 static bt_field *memberFieldByName(bt_field * const libObjPtr, const char * const name) noexcept
1033 {
1034 return bt_field_structure_borrow_member_field_by_name(libObjPtr, name);
1035 }
1036};
1037
b5f55e9f 1038/* Functions specific to constant structure fields */
a1e31878
PP
1039template <>
1040struct CommonStructureFieldSpec<const bt_field> final
1041{
1042 static const bt_field *memberFieldByIndex(const bt_field * const libObjPtr,
1043 const std::uint64_t index) noexcept
1044 {
1045 return bt_field_structure_borrow_member_field_by_index_const(libObjPtr, index);
1046 }
1047
1048 static const bt_field *memberFieldByName(const bt_field * const libObjPtr,
1049 const char * const name) noexcept
1050 {
1051 return bt_field_structure_borrow_member_field_by_name_const(libObjPtr, name);
1052 }
1053};
1054
b5f55e9f 1055} /* namespace internal */
a1e31878
PP
1056
1057template <typename LibObjT>
1058class CommonStructureField final : public CommonField<LibObjT>
1059{
1060private:
1061 using typename CommonField<LibObjT>::_LibObjPtr;
1062 using typename CommonField<LibObjT>::_ThisCommonField;
1063 using _Spec = internal::CommonStructureFieldSpec<LibObjT>;
1064
1065public:
1066 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClass,
1067 StructureFieldClass>::type;
1068
1069 explicit CommonStructureField(const _LibObjPtr libObjPtr) noexcept :
1070 _ThisCommonField {libObjPtr}
1071 {
1072 BT_ASSERT_DBG(this->isStructure());
1073 }
1074
1075 template <typename OtherLibObjT>
100fa861 1076 CommonStructureField(const CommonStructureField<OtherLibObjT> val) noexcept :
a1e31878
PP
1077 _ThisCommonField {val}
1078 {
1079 }
1080
1081 template <typename OtherLibObjT>
100fa861 1082 CommonStructureField<LibObjT>& operator=(const CommonStructureField<OtherLibObjT> val) noexcept
a1e31878
PP
1083 {
1084 _ThisCommonField::operator=(val);
1085 return *this;
1086 }
1087
1088 ConstStructureFieldClass cls() const noexcept
1089 {
1090 return ConstStructureFieldClass {
341a67c4 1091 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
1092 }
1093
1094 Class cls() noexcept
1095 {
341a67c4 1096 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
1097 }
1098
1099 std::uint64_t size() const noexcept
1100 {
1101 return this->cls().size();
1102 }
1103
1104 ConstField operator[](const std::uint64_t index) const noexcept
1105 {
1106 return ConstField {internal::CommonStructureFieldSpec<const bt_field>::memberFieldByIndex(
341a67c4 1107 this->libObjPtr(), index)};
a1e31878
PP
1108 }
1109
1110 CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
1111 {
341a67c4 1112 return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
a1e31878
PP
1113 }
1114
1115 nonstd::optional<ConstField> operator[](const char * const name) const noexcept
1116 {
1117 const auto libObjPtr =
341a67c4
FD
1118 internal::CommonStructureFieldSpec<const bt_field>::memberFieldByName(this->libObjPtr(),
1119 name);
a1e31878
PP
1120
1121 if (libObjPtr) {
1122 return ConstField {libObjPtr};
1123 }
1124
1125 return nonstd::nullopt;
1126 }
1127
1128 nonstd::optional<ConstField> operator[](const std::string& name) const noexcept
1129 {
1130 return (*this)[name.data()];
1131 }
1132
1133 nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) noexcept
1134 {
341a67c4 1135 const auto libObjPtr = _Spec::memberFieldByName(this->libObjPtr(), name);
a1e31878
PP
1136
1137 if (libObjPtr) {
1138 return CommonField<LibObjT> {libObjPtr};
1139 }
1140
1141 return nonstd::nullopt;
1142 }
1143
1144 nonstd::optional<CommonField<LibObjT>> operator[](const std::string& name) noexcept
1145 {
1146 return (*this)[name.data()];
1147 }
1148};
1149
1150using StructureField = CommonStructureField<bt_field>;
1151using ConstStructureField = CommonStructureField<const bt_field>;
1152
1153namespace internal {
1154
4927bae7
PP
1155struct StructureFieldTypeDescr
1156{
1157 using Const = ConstStructureField;
1158 using NonConst = StructureField;
1159};
1160
1161template <>
1162struct TypeDescr<StructureField> : public StructureFieldTypeDescr
1163{
1164};
1165
1166template <>
1167struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
1168{
1169};
1170
a1e31878
PP
1171template <typename LibObjT>
1172struct CommonArrayFieldSpec;
1173
b5f55e9f 1174/* Functions specific to mutable array fields */
a1e31878
PP
1175template <>
1176struct CommonArrayFieldSpec<bt_field> final
1177{
1178 static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
1179 const std::uint64_t index) noexcept
1180 {
1181 return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
1182 }
1183};
1184
b5f55e9f 1185/* Functions specific to constant array fields */
a1e31878
PP
1186template <>
1187struct CommonArrayFieldSpec<const bt_field> final
1188{
1189 static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
1190 const std::uint64_t index) noexcept
1191 {
1192 return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
1193 }
1194};
1195
b5f55e9f 1196} /* namespace internal */
a1e31878
PP
1197
1198template <typename LibObjT>
1199class CommonArrayField : public CommonField<LibObjT>
1200{
1201private:
1202 using typename CommonField<LibObjT>::_ThisCommonField;
1203 using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
1204
1205protected:
1206 using typename CommonField<LibObjT>::_LibObjPtr;
1207 using _ThisCommonArrayField = CommonArrayField<LibObjT>;
1208
1209public:
1210 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstArrayFieldClass,
1211 ArrayFieldClass>::type;
1212
1213 explicit CommonArrayField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1214 {
1215 BT_ASSERT_DBG(this->isArray());
1216 }
1217
1218 template <typename OtherLibObjT>
100fa861 1219 CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
a1e31878
PP
1220 {
1221 }
1222
1223 template <typename OtherLibObjT>
100fa861 1224 _ThisCommonArrayField& operator=(const CommonArrayField<OtherLibObjT> val) noexcept
a1e31878
PP
1225 {
1226 _ThisCommonField::operator=(val);
1227 return *this;
1228 }
1229
1230 ConstArrayFieldClass cls() const noexcept
1231 {
1232 return ConstArrayFieldClass {
341a67c4 1233 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
1234 }
1235
1236 Class cls() noexcept
1237 {
341a67c4 1238 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
1239 }
1240
1241 std::uint64_t length() const noexcept
1242 {
341a67c4 1243 return bt_field_array_get_length(this->libObjPtr());
a1e31878
PP
1244 }
1245
1246 ConstField operator[](const std::uint64_t index) const noexcept
1247 {
1248 return ConstField {internal::CommonArrayFieldSpec<const bt_field>::elementFieldByIndex(
341a67c4 1249 this->libObjPtr(), index)};
a1e31878
PP
1250 }
1251
1252 CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
1253 {
341a67c4 1254 return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
a1e31878
PP
1255 }
1256};
1257
1258using ArrayField = CommonArrayField<bt_field>;
1259using ConstArrayField = CommonArrayField<const bt_field>;
1260
4927bae7
PP
1261namespace internal {
1262
1263struct ArrayFieldTypeDescr
1264{
1265 using Const = ConstArrayField;
1266 using NonConst = ArrayField;
1267};
1268
1269template <>
1270struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
1271{
1272};
1273
1274template <>
1275struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
1276{
1277};
1278
1279} /* namespace internal */
1280
a1e31878
PP
1281template <typename LibObjT>
1282class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1283{
1284private:
1285 using typename CommonField<LibObjT>::_LibObjPtr;
1286 using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1287
1288public:
1289 explicit CommonDynamicArrayField(const _LibObjPtr libObjPtr) noexcept :
1290 _ThisCommonArrayField {libObjPtr}
1291 {
1292 BT_ASSERT_DBG(this->isDynamicArray());
1293 }
1294
1295 template <typename OtherLibObjT>
100fa861 1296 CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT> val) noexcept :
a1e31878
PP
1297 _ThisCommonArrayField {val}
1298 {
1299 }
1300
1301 template <typename OtherLibObjT>
1302 CommonDynamicArrayField<LibObjT>&
100fa861 1303 operator=(const CommonDynamicArrayField<OtherLibObjT> val) noexcept
a1e31878
PP
1304 {
1305 _ThisCommonArrayField::operator=(val);
1306 return *this;
1307 }
1308
1309 std::uint64_t length() const noexcept
1310 {
1311 return _ThisCommonArrayField::length();
1312 }
1313
1314 void length(const std::uint64_t length)
1315 {
1316 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1317
341a67c4 1318 const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
a1e31878
PP
1319
1320 if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
39278ebc 1321 throw MemoryError {};
a1e31878
PP
1322 }
1323 }
1324};
1325
1326using DynamicArrayField = CommonDynamicArrayField<bt_field>;
1327using ConstDynamicArrayField = CommonDynamicArrayField<const bt_field>;
1328
1329namespace internal {
1330
4927bae7
PP
1331struct DynamicArrayFieldTypeDescr
1332{
1333 using Const = ConstDynamicArrayField;
1334 using NonConst = DynamicArrayField;
1335};
1336
1337template <>
1338struct TypeDescr<DynamicArrayField> : public DynamicArrayFieldTypeDescr
1339{
1340};
1341
1342template <>
1343struct TypeDescr<ConstDynamicArrayField> : public DynamicArrayFieldTypeDescr
1344{
1345};
1346
a1e31878
PP
1347template <typename LibObjT>
1348struct CommonOptionFieldSpec;
1349
b5f55e9f 1350/* Functions specific to mutable option fields */
a1e31878
PP
1351template <>
1352struct CommonOptionFieldSpec<bt_field> final
1353{
1354 static bt_field *field(bt_field * const libObjPtr) noexcept
1355 {
1356 return bt_field_option_borrow_field(libObjPtr);
1357 }
1358};
1359
b5f55e9f 1360/* Functions specific to constant option fields */
a1e31878
PP
1361template <>
1362struct CommonOptionFieldSpec<const bt_field> final
1363{
1364 static const bt_field *field(const bt_field * const libObjPtr) noexcept
1365 {
1366 return bt_field_option_borrow_field_const(libObjPtr);
1367 }
1368};
1369
b5f55e9f 1370} /* namespace internal */
a1e31878
PP
1371
1372template <typename LibObjT>
1373class CommonOptionField : public CommonField<LibObjT>
1374{
1375private:
1376 using typename CommonField<LibObjT>::_LibObjPtr;
1377 using typename CommonField<LibObjT>::_ThisCommonField;
1378 using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1379
1380public:
1381 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstOptionFieldClass,
1382 OptionFieldClass>::type;
1383
1384 explicit CommonOptionField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1385 {
1386 BT_ASSERT_DBG(this->isOption());
1387 }
1388
1389 template <typename OtherLibObjT>
100fa861 1390 CommonOptionField(const CommonOptionField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
a1e31878
PP
1391 {
1392 }
1393
1394 template <typename OtherLibObjT>
100fa861 1395 CommonOptionField<LibObjT>& operator=(const CommonOptionField<OtherLibObjT> val) noexcept
a1e31878
PP
1396 {
1397 _ThisCommonField::operator=(val);
1398 return *this;
1399 }
1400
1401 ConstOptionFieldClass cls() const noexcept
1402 {
1403 return ConstOptionFieldClass {
341a67c4 1404 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
1405 }
1406
1407 Class cls() noexcept
1408 {
341a67c4 1409 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
1410 }
1411
1412 void hasField(const bool hasField) noexcept
1413 {
1414 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1415
341a67c4 1416 bt_field_option_set_has_field(this->libObjPtr(), static_cast<bt_bool>(hasField));
a1e31878
PP
1417 }
1418
1419 bool hasField() const noexcept
1420 {
1421 return this->field();
1422 }
1423
1424 nonstd::optional<ConstField> field() const noexcept
1425 {
1426 const auto libObjPtr =
341a67c4 1427 internal::CommonOptionFieldSpec<const bt_field>::field(this->libObjPtr());
a1e31878
PP
1428
1429 if (libObjPtr) {
1430 return ConstField {libObjPtr};
1431 }
1432
1433 return nonstd::nullopt;
1434 }
1435
1436 nonstd::optional<CommonField<LibObjT>> field() noexcept
1437 {
341a67c4 1438 const auto libObjPtr = _Spec::field(this->libObjPtr());
a1e31878
PP
1439
1440 if (libObjPtr) {
1441 return CommonField<LibObjT> {libObjPtr};
1442 }
1443
1444 return nonstd::nullopt;
1445 }
1446};
1447
1448using OptionField = CommonOptionField<bt_field>;
1449using ConstOptionField = CommonOptionField<const bt_field>;
1450
1451namespace internal {
1452
4927bae7
PP
1453struct OptionFieldTypeDescr
1454{
1455 using Const = ConstOptionField;
1456 using NonConst = OptionField;
1457};
1458
1459template <>
1460struct TypeDescr<OptionField> : public OptionFieldTypeDescr
1461{
1462};
1463
1464template <>
1465struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
1466{
1467};
1468
a1e31878
PP
1469template <typename LibObjT>
1470struct CommonVariantFieldSpec;
1471
b5f55e9f 1472/* Functions specific to mutable variant fields */
a1e31878
PP
1473template <>
1474struct CommonVariantFieldSpec<bt_field> final
1475{
1476 static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1477 {
1478 return bt_field_variant_borrow_selected_option_field(libObjPtr);
1479 }
1480};
1481
b5f55e9f 1482/* Functions specific to constant variant fields */
a1e31878
PP
1483template <>
1484struct CommonVariantFieldSpec<const bt_field> final
1485{
1486 static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1487 {
1488 return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1489 }
1490};
1491
b5f55e9f 1492} /* namespace internal */
a1e31878
PP
1493
1494template <typename LibObjT>
1495class CommonVariantField : public CommonField<LibObjT>
1496{
1497private:
1498 using typename CommonField<LibObjT>::_LibObjPtr;
1499 using typename CommonField<LibObjT>::_ThisCommonField;
1500 using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1501
1502public:
1503 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClass,
1504 VariantFieldClass>::type;
1505
1506 explicit CommonVariantField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1507 {
1508 BT_ASSERT_DBG(this->isVariant());
1509 }
1510
1511 template <typename OtherLibObjT>
100fa861 1512 CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
a1e31878
PP
1513 {
1514 }
1515
1516 template <typename OtherLibObjT>
100fa861 1517 CommonVariantField<LibObjT>& operator=(const CommonVariantField<OtherLibObjT> val) noexcept
a1e31878
PP
1518 {
1519 _ThisCommonField::operator=(val);
1520 return *this;
1521 }
1522
1523 ConstVariantFieldClass cls() const noexcept
1524 {
1525 return ConstVariantFieldClass {
341a67c4 1526 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
a1e31878
PP
1527 }
1528
1529 Class cls() noexcept
1530 {
341a67c4 1531 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
a1e31878
PP
1532 }
1533
1534 void selectOption(const std::uint64_t index) noexcept
1535 {
1536 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1537
341a67c4 1538 static_cast<void>(bt_field_variant_select_option_by_index(this->libObjPtr(), index));
a1e31878
PP
1539 }
1540
1541 ConstField selectedOptionField() const noexcept
1542 {
1543 return ConstField {internal::CommonVariantFieldSpec<const bt_field>::selectedOptionField(
341a67c4 1544 this->libObjPtr())};
a1e31878
PP
1545 }
1546
1547 CommonField<LibObjT> selectedOptionField() noexcept
1548 {
341a67c4 1549 return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
a1e31878
PP
1550 }
1551
1552 std::uint64_t selectedOptionIndex() const noexcept
1553 {
341a67c4 1554 return bt_field_variant_get_selected_option_index(this->libObjPtr());
a1e31878
PP
1555 }
1556};
1557
1558using VariantField = CommonVariantField<bt_field>;
1559using ConstVariantField = CommonVariantField<const bt_field>;
1560
4927bae7
PP
1561namespace internal {
1562
1563struct VariantFieldTypeDescr
1564{
1565 using Const = ConstVariantField;
1566 using NonConst = VariantField;
1567};
1568
1569template <>
1570struct TypeDescr<VariantField> : public VariantFieldTypeDescr
1571{
1572};
1573
1574template <>
1575struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
1576{
1577};
1578
1579} /* namespace internal */
1580
a1e31878
PP
1581template <typename LibObjT>
1582CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1583{
1584 BT_ASSERT_DBG(this->isBool());
341a67c4 1585 return CommonBoolField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1586}
1587
1588template <typename LibObjT>
1589CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1590{
1591 BT_ASSERT_DBG(this->isBitArray());
341a67c4 1592 return CommonBitArrayField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1593}
1594
1595template <typename LibObjT>
1596CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1597{
1598 BT_ASSERT_DBG(this->isUnsignedInteger());
341a67c4 1599 return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1600}
1601
1602template <typename LibObjT>
1603CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1604{
1605 BT_ASSERT_DBG(this->isSignedInteger());
341a67c4 1606 return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1607}
1608
1609template <typename LibObjT>
1610CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1611{
1612 BT_ASSERT_DBG(this->isUnsignedEnumeration());
341a67c4 1613 return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1614}
1615
1616template <typename LibObjT>
1617CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1618{
1619 BT_ASSERT_DBG(this->isSignedEnumeration());
341a67c4 1620 return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1621}
1622
1623template <typename LibObjT>
1624CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1625{
1626 BT_ASSERT_DBG(this->isSinglePrecisionReal());
341a67c4 1627 return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1628}
1629
1630template <typename LibObjT>
1631CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1632{
1633 BT_ASSERT_DBG(this->isDoublePrecisionReal());
341a67c4 1634 return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1635}
1636
1637template <typename LibObjT>
1638CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1639{
1640 BT_ASSERT_DBG(this->isString());
341a67c4 1641 return CommonStringField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1642}
1643
1644template <typename LibObjT>
1645CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1646{
1647 BT_ASSERT_DBG(this->isStructure());
341a67c4 1648 return CommonStructureField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1649}
1650
1651template <typename LibObjT>
1652CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1653{
1654 BT_ASSERT_DBG(this->isArray());
341a67c4 1655 return CommonArrayField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1656}
1657
1658template <typename LibObjT>
1659CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1660{
1661 BT_ASSERT_DBG(this->isDynamicArray());
341a67c4 1662 return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1663}
1664
1665template <typename LibObjT>
1666CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1667{
1668 BT_ASSERT_DBG(this->isOption());
341a67c4 1669 return CommonOptionField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1670}
1671
1672template <typename LibObjT>
1673CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1674{
1675 BT_ASSERT_DBG(this->isVariant());
341a67c4 1676 return CommonVariantField<LibObjT> {this->libObjPtr()};
a1e31878
PP
1677}
1678
b5f55e9f 1679} /* namespace bt2 */
a1e31878 1680
b5f55e9f 1681#endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_HPP */
This page took 0.097764 seconds and 4 git commands to generate.