2 * Copyright (c) 2020 Philippe Proulx <pproulx@efficios.com>
4 * SPDX-License-Identifier: MIT
7 #ifndef BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP
8 #define BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP
10 #include <type_traits>
12 #include <babeltrace2/babeltrace.h>
14 #include "common/assert.h"
15 #include "internal/borrowed-obj.hpp"
16 #include "internal/shared-obj.hpp"
17 #include "cpp-common/optional.hpp"
18 #include "cpp-common/string_view.hpp"
19 #include "common-iter.hpp"
20 #include "lib-error.hpp"
21 #include "integer-range-set.hpp"
22 #include "field-path.hpp"
29 struct FieldClassRefFuncs final
31 static void get(const bt_field_class * const libObjPtr)
33 bt_field_class_get_ref(libObjPtr);
36 static void put(const bt_field_class * const libObjPtr)
38 bt_field_class_put_ref(libObjPtr);
42 template <typename ObjT, typename LibObjT>
43 using SharedFieldClass = internal::SharedObj<ObjT, LibObjT, internal::FieldClassRefFuncs>;
45 template <typename LibObjT>
46 struct CommonFieldClassSpec;
48 /* Functions specific to mutable field classes */
50 struct CommonFieldClassSpec<bt_field_class> final
52 static bt_value *userAttributes(bt_field_class * const libObjPtr) noexcept
54 return bt_field_class_borrow_user_attributes(libObjPtr);
58 /* Functions specific to constant field classes */
60 struct CommonFieldClassSpec<const bt_field_class> final
62 static const bt_value *userAttributes(const bt_field_class * const libObjPtr) noexcept
64 return bt_field_class_borrow_user_attributes_const(libObjPtr);
68 } /* namespace internal */
70 template <typename LibObjT>
71 class CommonBitArrayFieldClass;
73 template <typename LibObjT>
74 class CommonIntegerFieldClass;
76 template <typename LibObjT>
77 class ConstEnumerationFieldClassMapping;
79 template <typename LibObjT, typename MappingT>
80 class CommonEnumerationFieldClass;
82 template <typename LibObjT>
83 class CommonStructureFieldClass;
85 template <typename LibObjT>
86 class CommonArrayFieldClass;
88 template <typename LibObjT>
89 class CommonStaticArrayFieldClass;
91 template <typename LibObjT>
92 class CommonDynamicArrayWithLengthFieldClass;
94 template <typename LibObjT>
95 class CommonOptionFieldClass;
97 template <typename LibObjT>
98 class CommonOptionWithSelectorFieldClass;
100 template <typename LibObjT>
101 class CommonOptionWithBoolSelectorFieldClass;
103 template <typename LibObjT>
104 class CommonVariantFieldClass;
106 template <typename LibObjT, typename RangeSetT>
107 class CommonOptionWithIntegerSelectorFieldClass;
109 template <typename LibObjT>
110 class CommonVariantWithoutSelectorFieldClass;
112 template <typename LibObjT>
113 class ConstVariantWithIntegerSelectorFieldClassOption;
115 template <typename LibObjT, typename RangeSetT>
116 class CommonVariantWithIntegerSelectorFieldClass;
118 template <typename LibObjT>
119 class CommonEventClass;
121 template <typename LibObjT>
122 class CommonStreamClass;
124 template <typename LibObjT>
125 class CommonTraceClass;
127 enum class FieldClassType
129 BOOL = BT_FIELD_CLASS_TYPE_BOOL,
130 BIT_ARRAY = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
131 UNSIGNED_INTEGER = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER,
132 SIGNED_INTEGER = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER,
133 UNSIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
134 SIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
135 SINGLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL,
136 DOUBLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL,
137 STRING = BT_FIELD_CLASS_TYPE_STRING,
138 STRUCTURE = BT_FIELD_CLASS_TYPE_STRUCTURE,
139 STATIC_ARRAY = BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
140 DYNAMIC_ARRAY_WITHOUT_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD,
141 DYNAMIC_ARRAY_WITH_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD,
142 OPTION_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD,
143 OPTION_WITH_BOOL_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD,
144 OPTION_WITH_UNSIGNED_INTEGER_SELECTOR =
145 BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
146 OPTION_WITH_SIGNED_INTEGER_SELECTOR =
147 BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
148 VARIANT_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD,
149 VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR =
150 BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
151 VARIANT_WITH_SIGNED_INTEGER_SELECTOR =
152 BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
155 template <typename LibObjT>
156 class CommonFieldClass : public internal::BorrowedObj<LibObjT>
158 /* Allow appendMember() to call `fc._libObjPtr()` */
159 friend class CommonStructureFieldClass<bt_field_class>;
161 /* Allow appendOption() to call `fc._libObjPtr()` */
162 friend class CommonVariantWithoutSelectorFieldClass<bt_field_class>;
164 friend class CommonVariantWithIntegerSelectorFieldClass<
166 ConstVariantWithIntegerSelectorFieldClassOption<
167 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>;
169 friend class CommonVariantWithIntegerSelectorFieldClass<
171 ConstVariantWithIntegerSelectorFieldClassOption<
172 const bt_field_class_variant_with_selector_field_integer_signed_option>>;
174 /* Allow *FieldClass() to call `fc._libObjPtr()` */
175 friend class CommonEventClass<bt_event_class>;
176 friend class CommonStreamClass<bt_stream_class>;
178 /* Allow create*FieldClass() to call `fc._libObjPtr()` */
179 friend class CommonTraceClass<bt_trace_class>;
182 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
185 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
186 using _ThisCommonFieldClass = CommonFieldClass<LibObjT>;
189 using Shared = internal::SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
191 using UserAttributes =
192 typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
194 explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
198 template <typename OtherLibObjT>
199 CommonFieldClass(const CommonFieldClass<OtherLibObjT>& fc) noexcept : _ThisBorrowedObj {fc}
203 template <typename OtherLibObjT>
204 _ThisCommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT>& fc) noexcept
206 _ThisBorrowedObj::operator=(fc);
210 FieldClassType type() const noexcept
212 return static_cast<FieldClassType>(bt_field_class_get_type(this->_libObjPtr()));
215 bool isBool() const noexcept
217 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BOOL);
220 bool isBitArray() const noexcept
222 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BIT_ARRAY);
225 bool isInteger() const noexcept
227 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_INTEGER);
230 bool isUnsignedInteger() const noexcept
232 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
235 bool isSignedInteger() const noexcept
237 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
240 bool isEnumeration() const noexcept
242 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ENUMERATION);
245 bool isUnsignedEnumeration() const noexcept
247 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
250 bool isSignedEnumeration() const noexcept
252 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
255 bool isReal() const noexcept
257 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_REAL);
260 bool isSinglePrecisionReal() const noexcept
262 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL);
265 bool isDoublePrecisionReal() const noexcept
267 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL);
270 bool isString() const noexcept
272 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRING);
275 bool isStructure() const noexcept
277 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRUCTURE);
280 bool isArray() const noexcept
282 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ARRAY);
285 bool isStaticArray() const noexcept
287 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STATIC_ARRAY);
290 bool isDynamicArray() const noexcept
292 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY);
295 bool isDynamicArrayWithoutLength() const noexcept
297 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD);
300 bool isDynamicArrayWithLength() const noexcept
302 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
305 bool isOption() const noexcept
307 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION);
310 bool isOptionWithoutSelector() const noexcept
312 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD);
315 bool isOptionWithSelector() const noexcept
317 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD);
320 bool isOptionWithBoolSelector() const noexcept
322 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD);
325 bool isOptionWithIntegerSelector() const noexcept
327 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_INTEGER_SELECTOR_FIELD);
330 bool isOptionWithUnsignedIntegerSelector() const noexcept
332 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
335 bool isOptionWithSignedIntegerSelector() const noexcept
337 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
340 bool isVariant() const noexcept
342 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT);
345 bool isVariantWithoutSelector() const noexcept
347 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD);
350 bool isVariantWithSelector() const noexcept
352 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD);
355 bool isVariantWithIntegerSelector() const noexcept
357 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_INTEGER_SELECTOR_FIELD);
360 bool isVariantWithUnsignedIntegerSelector() const noexcept
362 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
365 bool isVariantWithSignedIntegerSelector() const noexcept
367 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
370 CommonBitArrayFieldClass<LibObjT> asBitArray() const noexcept;
371 CommonIntegerFieldClass<LibObjT> asInteger() const noexcept;
373 CommonEnumerationFieldClass<LibObjT, ConstEnumerationFieldClassMapping<
374 const bt_field_class_enumeration_unsigned_mapping>>
375 asUnsignedEnumeration() const noexcept;
377 CommonEnumerationFieldClass<
378 LibObjT, ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>>
379 asSignedEnumeration() const noexcept;
381 CommonStructureFieldClass<LibObjT> asStructure() const noexcept;
382 CommonArrayFieldClass<LibObjT> asArray() const noexcept;
383 CommonStaticArrayFieldClass<LibObjT> asStaticArray() const noexcept;
384 CommonDynamicArrayWithLengthFieldClass<LibObjT> asDynamicArrayWithLength() const noexcept;
385 CommonOptionFieldClass<LibObjT> asOption() const noexcept;
386 CommonOptionWithSelectorFieldClass<LibObjT> asOptionWithSelector() const noexcept;
387 CommonOptionWithBoolSelectorFieldClass<LibObjT> asOptionWithBoolSelector() const noexcept;
389 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
390 asOptionWithUnsignedIntegerSelector() const noexcept;
392 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
393 asOptionWithSignedIntegerSelector() const noexcept;
395 CommonVariantFieldClass<LibObjT> asVariant() const noexcept;
396 CommonVariantWithoutSelectorFieldClass<LibObjT> asVariantWithoutSelector() const noexcept;
398 CommonVariantWithIntegerSelectorFieldClass<
399 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
400 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>
401 asVariantWithUnsignedIntegerSelector() const noexcept;
403 CommonVariantWithIntegerSelectorFieldClass<
404 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
405 const bt_field_class_variant_with_selector_field_integer_signed_option>>
406 asVariantWithSignedIntegerSelector() const noexcept;
408 template <typename LibValT>
409 void userAttributes(const CommonMapValue<LibValT>& userAttrs)
411 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
413 bt_field_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
416 ConstMapValue userAttributes() const noexcept
418 return ConstMapValue {internal::CommonFieldClassSpec<const bt_field_class>::userAttributes(
419 this->_libObjPtr())};
422 UserAttributes userAttributes() noexcept
424 return UserAttributes {
425 internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->_libObjPtr())};
428 Shared shared() const noexcept
430 return Shared {*this};
434 bool _libTypeIs(const bt_field_class_type type) const noexcept
436 return bt_field_class_type_is(bt_field_class_get_type(this->_libObjPtr()), type);
440 using FieldClass = CommonFieldClass<bt_field_class>;
441 using ConstFieldClass = CommonFieldClass<const bt_field_class>;
443 template <typename LibObjT>
444 class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
447 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
448 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
451 using Shared = internal::SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
453 explicit CommonBitArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
454 _ThisCommonFieldClass {libObjPtr}
456 BT_ASSERT_DBG(this->isBitArray());
459 template <typename OtherLibObjT>
460 CommonBitArrayFieldClass(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept :
461 _ThisCommonFieldClass {fc}
465 template <typename OtherLibObjT>
466 CommonBitArrayFieldClass<LibObjT>&
467 operator=(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept
469 _ThisCommonFieldClass::operator=(fc);
473 std::uint64_t length() const noexcept
475 return bt_field_class_bit_array_get_length(this->_libObjPtr());
478 Shared shared() const noexcept
480 return Shared {*this};
484 using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
485 using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
487 enum class DisplayBase
489 BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
490 OCTAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL,
491 DECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL,
492 HEXADECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL,
495 template <typename LibObjT>
496 class CommonIntegerFieldClass : public CommonFieldClass<LibObjT>
499 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
502 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
503 using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass<LibObjT>;
506 using Shared = internal::SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
508 explicit CommonIntegerFieldClass(const _LibObjPtr libObjPtr) noexcept :
509 _ThisCommonFieldClass {libObjPtr}
511 BT_ASSERT_DBG(this->isInteger());
514 template <typename OtherLibObjT>
515 CommonIntegerFieldClass(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept :
516 _ThisCommonFieldClass {fc}
520 template <typename OtherLibObjT>
521 _ThisCommonIntegerFieldClass&
522 operator=(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept
524 _ThisCommonFieldClass::operator=(fc);
528 void fieldValueRange(const std::uint64_t n) noexcept
530 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
532 bt_field_class_integer_get_field_value_range(this->_libObjPtr(), n);
535 std::uint64_t fieldValueRange() const noexcept
537 return bt_field_class_integer_get_field_value_range(this->_libObjPtr());
540 void preferredDisplayBase(const DisplayBase base) noexcept
542 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
544 bt_field_class_integer_set_preferred_display_base(
545 this->_libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
548 DisplayBase preferredDisplayBase() const noexcept
550 return static_cast<DisplayBase>(
551 bt_field_class_integer_get_preferred_display_base(this->_libObjPtr()));
554 Shared shared() const noexcept
556 return Shared {*this};
560 using IntegerFieldClass = CommonIntegerFieldClass<bt_field_class>;
561 using ConstIntegerFieldClass = CommonIntegerFieldClass<const bt_field_class>;
565 template <typename LibObjT>
566 struct ConstEnumerationFieldClassMappingSpec;
568 /* Functions specific to unsigned enumeration field class mappings */
570 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_unsigned_mapping>
573 static const bt_integer_range_set_unsigned *
574 ranges(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
576 return bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(libObjPtr);
580 label(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
582 return bt_field_class_enumeration_mapping_get_label(
583 bt_field_class_enumeration_unsigned_mapping_as_mapping_const(libObjPtr));
587 /* Functions specific to signed enumeration field class mappings */
589 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_signed_mapping> final
591 static const bt_integer_range_set_signed *
592 ranges(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
594 return bt_field_class_enumeration_signed_mapping_borrow_ranges_const(libObjPtr);
598 label(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
600 return bt_field_class_enumeration_mapping_get_label(
601 bt_field_class_enumeration_signed_mapping_as_mapping_const(libObjPtr));
605 } /* namespace internal */
607 template <typename LibObjT>
608 class ConstEnumerationFieldClassMapping final : public internal::BorrowedObj<LibObjT>
611 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
612 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
613 using _ThisConstEnumerationFieldClassMapping = ConstEnumerationFieldClassMapping<LibObjT>;
616 using RangeSet = typename std::conditional<
617 std::is_same<LibObjT, const bt_field_class_enumeration_unsigned_mapping>::value,
618 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
620 explicit ConstEnumerationFieldClassMapping(const _LibObjPtr libObjPtr) noexcept :
621 _ThisBorrowedObj {libObjPtr}
625 ConstEnumerationFieldClassMapping(
626 const _ThisConstEnumerationFieldClassMapping& mapping) noexcept :
627 _ThisBorrowedObj {mapping}
631 _ThisConstEnumerationFieldClassMapping&
632 operator=(const _ThisConstEnumerationFieldClassMapping& mapping) noexcept
634 _ThisBorrowedObj::operator=(mapping);
638 RangeSet ranges() const noexcept
641 internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->_libObjPtr())};
644 bpstd::string_view label() const noexcept
646 return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->_libObjPtr());
650 using ConstUnsignedEnumerationFieldClassMapping =
651 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_unsigned_mapping>;
653 using ConstSignedEnumerationFieldClassMapping =
654 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>;
658 template <typename MappingT>
659 struct CommonEnumerationFieldClassSpec;
661 /* Functions specific to unsigned enumeration field classes */
663 struct CommonEnumerationFieldClassSpec<ConstUnsignedEnumerationFieldClassMapping> final
665 static const bt_field_class_enumeration_unsigned_mapping *
666 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
668 return bt_field_class_enumeration_unsigned_borrow_mapping_by_index_const(libObjPtr, index);
671 static const bt_field_class_enumeration_unsigned_mapping *
672 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
674 return bt_field_class_enumeration_unsigned_borrow_mapping_by_label_const(libObjPtr, label);
678 /* Functions specific to signed enumeration field classes */
680 struct CommonEnumerationFieldClassSpec<ConstSignedEnumerationFieldClassMapping> final
682 static const bt_field_class_enumeration_signed_mapping *
683 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
685 return bt_field_class_enumeration_signed_borrow_mapping_by_index_const(libObjPtr, index);
688 static const bt_field_class_enumeration_signed_mapping *
689 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
691 return bt_field_class_enumeration_signed_borrow_mapping_by_label_const(libObjPtr, label);
695 } /* namespace internal */
697 template <typename LibObjT, typename MappingT>
698 class CommonEnumerationFieldClass final : public CommonIntegerFieldClass<LibObjT>
701 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
702 using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
703 using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
706 using Shared = internal::SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
707 using Mapping = MappingT;
709 explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
710 _ThisCommonIntegerFieldClass {libObjPtr}
712 BT_ASSERT_DBG(this->isEnumeration());
715 template <typename OtherLibObjT>
716 CommonEnumerationFieldClass(
717 const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept :
718 _ThisCommonIntegerFieldClass {fc}
722 template <typename OtherLibObjT>
723 _ThisCommonEnumerationFieldClass&
724 operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept
726 _ThisCommonIntegerFieldClass::operator=(fc);
730 std::uint64_t size() const noexcept
732 return bt_field_class_enumeration_get_mapping_count(this->_libObjPtr());
735 Mapping operator[](const std::uint64_t index) const noexcept
737 return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
738 this->_libObjPtr(), index)};
741 nonstd::optional<Mapping> operator[](const char * const label) const noexcept
743 const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
744 this->_libObjPtr(), label);
747 return Mapping {libObjPtr};
750 return nonstd::nullopt;
753 nonstd::optional<Mapping> operator[](const std::string& label) const noexcept
755 return (*this)[label.data()];
758 Shared shared() const noexcept
760 return Shared {*this};
764 using UnsignedEnumerationFieldClass =
765 CommonEnumerationFieldClass<bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
767 using ConstUnsignedEnumerationFieldClass =
768 CommonEnumerationFieldClass<const bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
770 using SignedEnumerationFieldClass =
771 CommonEnumerationFieldClass<bt_field_class, ConstSignedEnumerationFieldClassMapping>;
773 using ConstSignedEnumerationFieldClass =
774 CommonEnumerationFieldClass<const bt_field_class, ConstSignedEnumerationFieldClassMapping>;
778 template <typename LibObjT>
779 struct CommonStructureFieldClassMemberSpec;
781 /* Functions specific to mutable structure field class members */
783 struct CommonStructureFieldClassMemberSpec<bt_field_class_structure_member> final
785 static bt_field_class *fieldClass(bt_field_class_structure_member * const libObjPtr) noexcept
787 return bt_field_class_structure_member_borrow_field_class(libObjPtr);
791 /* Functions specific to constant structure field class members */
793 struct CommonStructureFieldClassMemberSpec<const bt_field_class_structure_member> final
795 static const bt_field_class *
796 fieldClass(const bt_field_class_structure_member * const libObjPtr) noexcept
798 return bt_field_class_structure_member_borrow_field_class_const(libObjPtr);
802 } /* namespace internal */
804 template <typename LibObjT>
805 class CommonStructureFieldClassMember final : public internal::BorrowedObj<LibObjT>
808 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
809 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
812 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
815 explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept :
816 _ThisBorrowedObj {libObjPtr}
820 template <typename OtherLibObjT>
821 CommonStructureFieldClassMember(
822 const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept :
823 _ThisBorrowedObj {fc}
827 template <typename OtherLibObjT>
828 CommonStructureFieldClassMember<LibObjT>&
829 operator=(const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept
831 _ThisBorrowedObj::operator=(fc);
835 bpstd::string_view name() const noexcept
837 return bt_field_class_structure_member_get_name(this->_libObjPtr());
840 ConstFieldClass fieldClass() const noexcept
842 return ConstFieldClass {internal::CommonStructureFieldClassMemberSpec<
843 const bt_field_class_structure_member>::fieldClass(this->_libObjPtr())};
846 _FieldClass fieldClass() noexcept
849 internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->_libObjPtr())};
853 using StructureFieldClassMember = CommonStructureFieldClassMember<bt_field_class_structure_member>;
855 using ConstStructureFieldClassMember =
856 CommonStructureFieldClassMember<const bt_field_class_structure_member>;
860 template <typename LibObjT>
861 struct CommonStructureFieldClassSpec;
863 /* Functions specific to mutable structure field classes */
865 struct CommonStructureFieldClassSpec<bt_field_class> final
867 static bt_field_class_structure_member *memberByIndex(bt_field_class * const libObjPtr,
868 const std::uint64_t index) noexcept
870 return bt_field_class_structure_borrow_member_by_index(libObjPtr, index);
873 static bt_field_class_structure_member *memberByName(bt_field_class * const libObjPtr,
874 const char * const name) noexcept
876 return bt_field_class_structure_borrow_member_by_name(libObjPtr, name);
880 /* Functions specific to constant structure field classes */
882 struct CommonStructureFieldClassSpec<const bt_field_class> final
884 static const bt_field_class_structure_member *
885 memberByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
887 return bt_field_class_structure_borrow_member_by_index_const(libObjPtr, index);
890 static const bt_field_class_structure_member *
891 memberByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
893 return bt_field_class_structure_borrow_member_by_name_const(libObjPtr, name);
897 } /* namespace internal */
899 template <typename LibObjT>
900 class CommonStructureFieldClass final : public CommonFieldClass<LibObjT>
903 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
904 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
907 using Shared = internal::SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
909 typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClassMember,
910 StructureFieldClassMember>::type;
912 using Iterator = CommonIterator<CommonStructureFieldClass<LibObjT>, Member>;
914 explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
915 _ThisCommonFieldClass {libObjPtr}
917 BT_ASSERT_DBG(this->isStructure());
920 template <typename OtherLibObjT>
921 CommonStructureFieldClass(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept :
922 _ThisCommonFieldClass {fc}
926 template <typename OtherLibObjT>
927 CommonStructureFieldClass<LibObjT>&
928 operator=(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept
930 _ThisCommonFieldClass::operator=(fc);
934 void appendMember(const char * const name, const FieldClass& fc)
936 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
939 bt_field_class_structure_append_member(this->_libObjPtr(), name, fc._libObjPtr());
941 if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
942 throw LibMemoryError {};
946 void appendMember(const std::string& name, const FieldClass& fc)
948 this->appendMember(name.data(), fc);
951 std::uint64_t size() const noexcept
953 return bt_field_class_structure_get_member_count(this->_libObjPtr());
956 Iterator begin() const noexcept
958 return Iterator {*this, 0};
961 Iterator end() const noexcept
963 return Iterator {*this, this->size()};
966 ConstStructureFieldClassMember operator[](const std::uint64_t index) const noexcept
968 return ConstStructureFieldClassMember {
969 internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByIndex(
970 this->_libObjPtr(), index)};
973 Member operator[](const std::uint64_t index) noexcept
975 return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
976 this->_libObjPtr(), index)};
979 nonstd::optional<ConstStructureFieldClassMember>
980 operator[](const char * const name) const noexcept
982 const auto libObjPtr =
983 internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
984 this->_libObjPtr(), name);
987 return ConstStructureFieldClassMember {libObjPtr};
990 return nonstd::nullopt;
993 nonstd::optional<ConstStructureFieldClassMember>
994 operator[](const std::string& name) const noexcept
996 return (*this)[name.data()];
999 nonstd::optional<Member> operator[](const char * const name) noexcept
1001 const auto libObjPtr = internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(
1002 this->_libObjPtr(), name);
1005 return Member {libObjPtr};
1008 return nonstd::nullopt;
1011 nonstd::optional<Member> operator[](const std::string& name) noexcept
1013 return (*this)[name.data()];
1016 Shared shared() const noexcept
1018 return Shared {*this};
1022 using StructureFieldClass = CommonStructureFieldClass<bt_field_class>;
1023 using ConstStructureFieldClass = CommonStructureFieldClass<const bt_field_class>;
1025 namespace internal {
1027 template <typename LibObjT>
1028 struct CommonArrayFieldClassSpec;
1030 /* Functions specific to mutable array field classes */
1032 struct CommonArrayFieldClassSpec<bt_field_class> final
1034 static bt_field_class *elementFieldClass(bt_field_class * const libObjPtr) noexcept
1036 return bt_field_class_array_borrow_element_field_class(libObjPtr);
1040 /* Functions specific to constant array field classes */
1042 struct CommonArrayFieldClassSpec<const bt_field_class> final
1044 static const bt_field_class *elementFieldClass(const bt_field_class * const libObjPtr) noexcept
1046 return bt_field_class_array_borrow_element_field_class_const(libObjPtr);
1050 } /* namespace internal */
1052 template <typename LibObjT>
1053 class CommonArrayFieldClass : public CommonFieldClass<LibObjT>
1056 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1059 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1062 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1063 using _ThisCommonArrayFieldClass = CommonArrayFieldClass<LibObjT>;
1066 using Shared = internal::SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
1068 explicit CommonArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1069 _ThisCommonFieldClass {libObjPtr}
1071 BT_ASSERT_DBG(this->isArray());
1074 template <typename OtherLibObjT>
1075 CommonArrayFieldClass(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept :
1076 _ThisCommonFieldClass {fc}
1080 template <typename OtherLibObjT>
1081 _ThisCommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept
1083 _ThisCommonFieldClass::operator=(fc);
1087 ConstFieldClass elementFieldClass() const noexcept
1089 return ConstFieldClass {
1090 internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
1091 this->_libObjPtr())};
1094 _FieldClass elementFieldClass() noexcept
1096 return _FieldClass {
1097 internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->_libObjPtr())};
1100 Shared shared() const noexcept
1102 return Shared {*this};
1106 using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
1107 using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
1109 template <typename LibObjT>
1110 class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
1113 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1114 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1117 using Shared = internal::SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
1119 explicit CommonStaticArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1120 _ThisCommonArrayFieldClass {libObjPtr}
1122 BT_ASSERT_DBG(this->isStaticArray());
1125 template <typename OtherLibObjT>
1126 CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept :
1127 _ThisCommonArrayFieldClass {fc}
1131 template <typename OtherLibObjT>
1132 CommonStaticArrayFieldClass<LibObjT>&
1133 operator=(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept
1135 _ThisCommonArrayFieldClass::operator=(fc);
1139 std::uint64_t length() const noexcept
1141 return bt_field_class_array_static_get_length(this->_libObjPtr());
1144 Shared shared() const noexcept
1146 return Shared {*this};
1150 using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
1151 using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
1153 template <typename LibObjT>
1154 class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
1157 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1158 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1162 internal::SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
1164 explicit CommonDynamicArrayWithLengthFieldClass(const _LibObjPtr libObjPtr) noexcept :
1165 _ThisCommonArrayFieldClass {libObjPtr}
1167 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
1170 template <typename OtherLibObjT>
1171 CommonDynamicArrayWithLengthFieldClass(
1172 const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept :
1173 _ThisCommonArrayFieldClass {fc}
1177 template <typename OtherLibObjT>
1178 CommonDynamicArrayWithLengthFieldClass<LibObjT>&
1179 operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept
1181 _ThisCommonArrayFieldClass::operator=(fc);
1185 ConstFieldPath lengthFieldPath() const noexcept
1187 return ConstFieldPath {
1188 bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
1189 this->_libObjPtr())};
1192 Shared shared() const noexcept
1194 return Shared {*this};
1198 using DynamicArrayWithLengthFieldClass = CommonDynamicArrayWithLengthFieldClass<bt_field_class>;
1200 using ConstDynamicArrayWithLengthFieldClass =
1201 CommonDynamicArrayWithLengthFieldClass<const bt_field_class>;
1203 namespace internal {
1205 template <typename LibObjT>
1206 struct CommonOptionFieldClassSpec;
1208 /* Functions specific to mutable option field classes */
1210 struct CommonOptionFieldClassSpec<bt_field_class> final
1212 static bt_field_class *fieldClass(bt_field_class * const libObjPtr) noexcept
1214 return bt_field_class_option_borrow_field_class(libObjPtr);
1218 /* Functions specific to constant option field classes */
1220 struct CommonOptionFieldClassSpec<const bt_field_class> final
1222 static const bt_field_class *fieldClass(const bt_field_class * const libObjPtr) noexcept
1224 return bt_field_class_option_borrow_field_class_const(libObjPtr);
1228 } /* namespace internal */
1230 template <typename LibObjT>
1231 class CommonOptionFieldClass : public CommonFieldClass<LibObjT>
1234 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1237 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1240 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1241 using _ThisCommonOptionFieldClass = CommonOptionFieldClass<LibObjT>;
1244 using Shared = internal::SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
1246 explicit CommonOptionFieldClass(const _LibObjPtr libObjPtr) noexcept :
1247 _ThisCommonFieldClass {libObjPtr}
1249 BT_ASSERT_DBG(this->isOption());
1252 template <typename OtherLibObjT>
1253 CommonOptionFieldClass(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept :
1254 _ThisCommonFieldClass {fc}
1258 template <typename OtherLibObjT>
1259 _ThisCommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept
1261 _ThisCommonFieldClass::operator=(fc);
1265 ConstFieldClass fieldClass() const noexcept
1267 return ConstFieldClass {
1268 internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
1269 this->_libObjPtr())};
1272 _FieldClass fieldClass() noexcept
1274 return _FieldClass {
1275 internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->_libObjPtr())};
1278 Shared shared() const noexcept
1280 return Shared {*this};
1284 using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
1285 using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
1287 template <typename LibObjT>
1288 class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
1291 using typename CommonOptionFieldClass<LibObjT>::_ThisCommonOptionFieldClass;
1294 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1295 using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<LibObjT>;
1298 using Shared = internal::SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
1300 explicit CommonOptionWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1301 _ThisCommonOptionFieldClass {libObjPtr}
1303 BT_ASSERT_DBG(this->isOptionWithSelector());
1306 template <typename OtherLibObjT>
1307 CommonOptionWithSelectorFieldClass(
1308 const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1309 _ThisCommonOptionFieldClass {fc}
1313 template <typename OtherLibObjT>
1314 _ThisCommonOptionWithSelectorFieldClass&
1315 operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept
1317 _ThisCommonOptionFieldClass::operator=(fc);
1321 ConstFieldPath selectorFieldPath() const noexcept
1323 return ConstFieldPath {
1324 bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
1325 this->_libObjPtr())};
1328 Shared shared() const noexcept
1330 return Shared {*this};
1334 using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
1335 using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
1337 template <typename LibObjT>
1338 class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1341 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1343 using typename CommonOptionWithSelectorFieldClass<
1344 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1348 internal::SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
1350 explicit CommonOptionWithBoolSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1351 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1353 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
1356 template <typename OtherLibObjT>
1357 CommonOptionWithBoolSelectorFieldClass(
1358 const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1359 _ThisCommonOptionWithSelectorFieldClass {fc}
1363 template <typename OtherLibObjT>
1364 CommonOptionWithBoolSelectorFieldClass<LibObjT>&
1365 operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept
1367 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1371 bool selectorIsReversed() const noexcept
1373 return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
1374 this->_libObjPtr());
1377 Shared shared() const noexcept
1379 return Shared {*this};
1383 using OptionWithBoolSelectorFieldClass = CommonOptionWithBoolSelectorFieldClass<bt_field_class>;
1385 using ConstOptionWithBoolSelectorFieldClass =
1386 CommonOptionWithBoolSelectorFieldClass<const bt_field_class>;
1388 namespace internal {
1390 template <typename RangeSetT>
1391 struct CommonOptionWithIntegerSelectorFieldClassSpec;
1393 /* Functions specific to option field classes with unsigned integer ranges */
1395 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstUnsignedIntegerRangeSet> final
1397 static const bt_integer_range_set_unsigned *
1398 ranges(const bt_field_class * const libObjPtr) noexcept
1400 return bt_field_class_option_with_selector_field_integer_unsigned_borrow_selector_ranges_const(
1405 /* Functions specific to option field classes with signed ranges */
1407 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstSignedIntegerRangeSet> final
1409 static const bt_integer_range_set_signed *
1410 ranges(const bt_field_class * const libObjPtr) noexcept
1412 return bt_field_class_option_with_selector_field_integer_signed_borrow_selector_ranges_const(
1417 } /* namespace internal */
1419 template <typename LibObjT, typename RangeSetT>
1420 class CommonOptionWithIntegerSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1423 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1425 using typename CommonOptionWithSelectorFieldClass<
1426 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1428 using _ThisCommonOptionWithIntegerSelectorFieldClass =
1429 CommonOptionWithIntegerSelectorFieldClass<LibObjT, RangeSetT>;
1433 internal::SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
1435 using RangeSet = RangeSetT;
1437 explicit CommonOptionWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1438 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1440 BT_ASSERT_DBG(this->isOptionWithIntegerSelector());
1443 template <typename OtherLibObjT>
1444 CommonOptionWithIntegerSelectorFieldClass(
1445 const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept :
1446 _ThisCommonOptionWithSelectorFieldClass {fc}
1450 template <typename OtherLibObjT>
1451 _ThisCommonOptionWithIntegerSelectorFieldClass&
1452 operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept
1454 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1458 RangeSet ranges() const noexcept
1460 return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
1461 this->_libObjPtr())};
1464 Shared shared() const noexcept
1466 return Shared {*this};
1470 using OptionWithUnsignedIntegerSelectorFieldClass =
1471 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstUnsignedIntegerRangeSet>;
1473 using ConstOptionWithUnsignedIntegerSelectorFieldClass =
1474 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstUnsignedIntegerRangeSet>;
1476 using OptionWithSignedIntegerSelectorFieldClass =
1477 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstSignedIntegerRangeSet>;
1479 using ConstOptionWithSignedIntegerSelectorFieldClass =
1480 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstSignedIntegerRangeSet>;
1482 namespace internal {
1484 template <typename LibObjT>
1485 struct CommonVariantFieldClassOptionSpec;
1487 /* Functions specific to mutable variant field class options */
1489 struct CommonVariantFieldClassOptionSpec<bt_field_class_variant_option> final
1491 static bt_field_class *fieldClass(bt_field_class_variant_option * const libObjPtr) noexcept
1493 return bt_field_class_variant_option_borrow_field_class(libObjPtr);
1497 /* Functions specific to constant variant field class options */
1499 struct CommonVariantFieldClassOptionSpec<const bt_field_class_variant_option> final
1501 static const bt_field_class *
1502 fieldClass(const bt_field_class_variant_option * const libObjPtr) noexcept
1504 return bt_field_class_variant_option_borrow_field_class_const(libObjPtr);
1508 } /* namespace internal */
1510 template <typename LibObjT>
1511 class CommonVariantFieldClassOption : public internal::BorrowedObj<LibObjT>
1514 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
1515 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
1518 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1521 explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1522 _ThisBorrowedObj {libObjPtr}
1526 template <typename OtherLibObjT>
1527 CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept :
1528 _ThisBorrowedObj {fc}
1532 template <typename OtherLibObjT>
1533 CommonVariantFieldClassOption<LibObjT>&
1534 operator=(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept
1536 _ThisBorrowedObj::operator=(fc);
1540 bpstd::string_view name() const noexcept
1542 return bt_field_class_variant_option_get_name(this->_libObjPtr());
1545 ConstFieldClass fieldClass() const noexcept
1547 return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
1548 const bt_field_class_variant_option>::fieldClass(this->_libObjPtr())};
1551 _FieldClass fieldClass() noexcept
1553 return _FieldClass {
1554 internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->_libObjPtr())};
1558 using VariantFieldClassOption = CommonVariantFieldClassOption<bt_field_class_variant_option>;
1560 using ConstVariantFieldClassOption =
1561 CommonVariantFieldClassOption<const bt_field_class_variant_option>;
1563 namespace internal {
1565 template <typename LibObjT>
1566 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
1568 /* Functions specific to variant field class options with unsigned integer selector */
1570 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1571 const bt_field_class_variant_with_selector_field_integer_unsigned_option>
1574 static const bt_integer_range_set_unsigned *
1575 ranges(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1576 * const libObjPtr) noexcept
1578 return bt_field_class_variant_with_selector_field_integer_unsigned_option_borrow_ranges_const(
1582 static const bt_field_class_variant_option *
1583 asBaseOption(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1584 * const libObjPtr) noexcept
1586 return bt_field_class_variant_with_selector_field_integer_unsigned_option_as_option_const(
1591 /* Functions specific to variant field class options with signed integer selector */
1593 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1594 const bt_field_class_variant_with_selector_field_integer_signed_option>
1597 static const bt_integer_range_set_signed *
1598 ranges(const bt_field_class_variant_with_selector_field_integer_signed_option
1599 * const libObjPtr) noexcept
1601 return bt_field_class_variant_with_selector_field_integer_signed_option_borrow_ranges_const(
1605 static const bt_field_class_variant_option *
1606 asBaseOption(const bt_field_class_variant_with_selector_field_integer_signed_option
1607 * const libObjPtr) noexcept
1609 return bt_field_class_variant_with_selector_field_integer_signed_option_as_option_const(
1614 } /* namespace internal */
1616 template <typename LibObjT>
1617 class ConstVariantWithIntegerSelectorFieldClassOption : public internal::BorrowedObj<LibObjT>
1620 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
1621 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
1622 using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
1625 using RangeSet = typename std::conditional<
1628 const bt_field_class_variant_with_selector_field_integer_unsigned_option>::value,
1629 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
1631 explicit ConstVariantWithIntegerSelectorFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1632 _ThisBorrowedObj {libObjPtr}
1636 template <typename OtherLibObjT>
1637 ConstVariantWithIntegerSelectorFieldClassOption(
1638 const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept :
1639 _ThisBorrowedObj {fc}
1643 template <typename OtherLibObjT>
1644 ConstVariantWithIntegerSelectorFieldClassOption<LibObjT>&
1645 operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept
1647 _ThisBorrowedObj::operator=(fc);
1651 ConstVariantFieldClassOption asBaseOption() const noexcept
1653 return ConstVariantFieldClassOption {_Spec::asBaseOption(this->_libObjPtr())};
1656 bpstd::string_view name() const noexcept
1658 return this->asBaseOption().name();
1661 ConstFieldClass fieldClass() const noexcept
1663 return this->asBaseOption().fieldClass();
1666 RangeSet ranges() const noexcept
1668 return RangeSet {_Spec::ranges(this->_libObjPtr())};
1672 using ConstVariantWithUnsignedIntegerSelectorFieldClassOption =
1673 ConstVariantWithIntegerSelectorFieldClassOption<
1674 const bt_field_class_variant_with_selector_field_integer_unsigned_option>;
1676 using ConstVariantWithSignedIntegerSelectorFieldClassOption =
1677 ConstVariantWithIntegerSelectorFieldClassOption<
1678 const bt_field_class_variant_with_selector_field_integer_signed_option>;
1680 namespace internal {
1682 template <typename LibObjT>
1683 struct CommonVariantFieldClassSpec;
1685 /* Functions specific to mutable variant field classes */
1687 struct CommonVariantFieldClassSpec<bt_field_class> final
1689 static bt_field_class_variant_option *optionByIndex(bt_field_class * const libObjPtr,
1690 const std::uint64_t index) noexcept
1692 return bt_field_class_variant_borrow_option_by_index(libObjPtr, index);
1695 static bt_field_class_variant_option *optionByName(bt_field_class * const libObjPtr,
1696 const char * const name) noexcept
1698 return bt_field_class_variant_borrow_option_by_name(libObjPtr, name);
1702 /* Functions specific to constant variant field classes */
1704 struct CommonVariantFieldClassSpec<const bt_field_class> final
1706 static const bt_field_class_variant_option *
1707 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1709 return bt_field_class_variant_borrow_option_by_index_const(libObjPtr, index);
1712 static const bt_field_class_variant_option *optionByName(const bt_field_class * const libObjPtr,
1713 const char * const name) noexcept
1715 return bt_field_class_variant_borrow_option_by_name_const(libObjPtr, name);
1719 } /* namespace internal */
1721 template <typename LibObjT>
1722 class CommonVariantFieldClass : public CommonFieldClass<LibObjT>
1725 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1728 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1729 using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
1732 using Shared = internal::SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
1735 typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
1736 VariantFieldClassOption>::type;
1738 using Iterator = CommonIterator<CommonVariantFieldClass<LibObjT>, Option>;
1740 explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
1741 _ThisCommonFieldClass {libObjPtr}
1743 BT_ASSERT_DBG(this->isVariant());
1746 template <typename OtherLibObjT>
1747 CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept :
1748 _ThisCommonFieldClass {fc}
1752 template <typename OtherLibObjT>
1753 _ThisCommonVariantFieldClass&
1754 operator=(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept
1756 _ThisCommonFieldClass::operator=(fc);
1760 std::uint64_t size() const noexcept
1762 return bt_field_class_variant_get_option_count(this->_libObjPtr());
1765 Iterator begin() const noexcept
1767 return Iterator {*this, 0};
1770 Iterator end() const noexcept
1772 return Iterator {*this, this->size()};
1775 ConstVariantFieldClassOption operator[](const std::uint64_t index) const noexcept
1777 return ConstVariantFieldClassOption {
1778 internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
1779 this->_libObjPtr(), index)};
1782 Option operator[](const std::uint64_t index) noexcept
1784 return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
1785 this->_libObjPtr(), index)};
1788 nonstd::optional<ConstVariantFieldClassOption>
1789 operator[](const char * const name) const noexcept
1791 const auto libObjPtr =
1792 internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
1793 this->_libObjPtr(), name);
1796 return ConstVariantFieldClassOption {libObjPtr};
1799 return nonstd::nullopt;
1802 nonstd::optional<ConstVariantFieldClassOption>
1803 operator[](const std::string& name) const noexcept
1805 return (*this)[name.data()];
1808 nonstd::optional<Option> operator[](const char * const name) noexcept
1810 const auto libObjPtr =
1811 internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->_libObjPtr(), name);
1814 return Option {libObjPtr};
1817 return nonstd::nullopt;
1820 nonstd::optional<Option> operator[](const std::string& name) noexcept
1822 return (*this)[name.data()];
1825 Shared shared() const noexcept
1827 return Shared {*this};
1831 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
1832 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
1834 template <typename LibObjT>
1835 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
1838 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
1839 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1843 internal::SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
1845 explicit CommonVariantWithoutSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1846 _ThisCommonVariantFieldClass {libObjPtr}
1848 BT_ASSERT_DBG(this->isVariantWithoutSelector());
1851 template <typename OtherLibObjT>
1852 CommonVariantWithoutSelectorFieldClass(
1853 const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1854 _ThisCommonVariantFieldClass {fc}
1858 template <typename OtherLibObjT>
1859 CommonVariantWithoutSelectorFieldClass<LibObjT>&
1860 operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept
1862 _ThisCommonVariantFieldClass::operator=(fc);
1866 void appendOption(const char * const name, const FieldClass& fc)
1868 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1870 const auto status = bt_field_class_variant_without_selector_append_option(
1871 this->_libObjPtr(), name, fc._libObjPtr());
1874 BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
1875 throw LibMemoryError {};
1879 void appendOption(const std::string& name, const FieldClass& fc)
1881 this->appendOption(name.data(), fc);
1884 Shared shared() const noexcept
1886 return Shared {*this};
1890 using VariantWithoutSelectorFieldClass = CommonVariantWithoutSelectorFieldClass<bt_field_class>;
1891 using ConstVariantWithoutSelectorFieldClass =
1892 CommonVariantWithoutSelectorFieldClass<const bt_field_class>;
1894 namespace internal {
1896 template <typename OptionT>
1897 struct CommonVariantWithIntegerSelectorFieldClassSpec;
1899 /* Functions specific to variant field classes with unsigned integer selector */
1901 struct CommonVariantWithIntegerSelectorFieldClassSpec<
1902 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
1905 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
1906 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1908 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_index_const(
1912 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
1913 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1915 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_name_const(
1919 static bt_field_class_variant_with_selector_field_integer_append_option_status
1920 appendOption(bt_field_class * const libObjPtr, const char * const name,
1921 bt_field_class * const libOptFcPtr,
1922 const bt_integer_range_set_unsigned * const libRangesPtr)
1924 return bt_field_class_variant_with_selector_field_integer_unsigned_append_option(
1925 libObjPtr, name, libOptFcPtr, libRangesPtr);
1929 /* Functions specific to variant field classes with signed integer selector */
1931 struct CommonVariantWithIntegerSelectorFieldClassSpec<
1932 ConstVariantWithSignedIntegerSelectorFieldClassOption>
1935 static const bt_field_class_variant_with_selector_field_integer_signed_option *
1936 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1938 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_index_const(
1942 static const bt_field_class_variant_with_selector_field_integer_signed_option *
1943 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1945 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_name_const(
1949 static bt_field_class_variant_with_selector_field_integer_append_option_status
1950 appendOption(bt_field_class * const libObjPtr, const char * const name,
1951 bt_field_class * const libOptFcPtr,
1952 const bt_integer_range_set_signed * const libRangesPtr)
1954 return bt_field_class_variant_with_selector_field_integer_signed_append_option(
1955 libObjPtr, name, libOptFcPtr, libRangesPtr);
1959 } /* namespace internal */
1961 template <typename LibObjT, typename OptionT>
1962 class CommonVariantWithIntegerSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
1965 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
1966 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1968 using _ThisCommonVariantWithIntegerSelectorFieldClass =
1969 CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
1971 using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
1975 internal::SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
1977 using Option = OptionT;
1979 explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1980 _ThisCommonVariantFieldClass {libObjPtr}
1982 BT_ASSERT_DBG(this->isVariant());
1985 template <typename OtherLibObjT>
1986 CommonVariantWithIntegerSelectorFieldClass(
1987 const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept :
1988 _ThisCommonVariantFieldClass {fc}
1992 template <typename OtherLibObjT>
1993 _ThisCommonVariantWithIntegerSelectorFieldClass&
1994 operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept
1996 _ThisCommonVariantFieldClass::operator=(fc);
2000 ConstFieldPath selectorFieldPath() const noexcept
2002 return ConstFieldPath {
2003 bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
2004 this->_libObjPtr())};
2007 Option operator[](const std::uint64_t index) const noexcept
2009 return Option {_Spec::optionByIndex(this->_libObjPtr(), index)};
2012 nonstd::optional<Option> operator[](const char * const name) const noexcept
2014 const auto libObjPtr = _Spec::optionByName(this->_libObjPtr(), name);
2017 return Option {libObjPtr};
2020 return nonstd::nullopt;
2023 nonstd::optional<Option> operator[](const std::string& name) const noexcept
2025 return (*this)[name.data()];
2028 void appendOption(const char * const name, const FieldClass& fc,
2029 const typename Option::RangeSet& ranges)
2031 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
2034 _Spec::appendOption(this->_libObjPtr(), name, fc._libObjPtr(), ranges._libObjPtr());
2037 BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2038 throw LibMemoryError {};
2042 void appendOption(const std::string& name, const FieldClass& fc)
2044 this->appendOption(name.data(), fc);
2047 Shared shared() const noexcept
2049 return Shared {*this};
2053 using VariantWithUnsignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2054 bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2056 using ConstVariantWithUnsignedIntegerSelectorFieldClass =
2057 CommonVariantWithIntegerSelectorFieldClass<
2058 const bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2060 using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2061 bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2063 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2064 const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2066 template <typename LibObjT>
2067 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
2069 BT_ASSERT_DBG(this->isBitArray());
2070 return CommonBitArrayFieldClass<LibObjT> {this->_libObjPtr()};
2073 template <typename LibObjT>
2074 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
2076 BT_ASSERT_DBG(this->isInteger());
2077 return CommonIntegerFieldClass<LibObjT> {this->_libObjPtr()};
2080 template <typename LibObjT>
2081 CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping>
2082 CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
2084 BT_ASSERT_DBG(this->isUnsignedEnumeration());
2085 return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
2086 this->_libObjPtr()};
2089 template <typename LibObjT>
2090 CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping>
2091 CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
2093 BT_ASSERT_DBG(this->isSignedEnumeration());
2094 return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
2095 this->_libObjPtr()};
2098 template <typename LibObjT>
2099 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
2101 BT_ASSERT_DBG(this->isStructure());
2102 return CommonStructureFieldClass<LibObjT> {this->_libObjPtr()};
2105 template <typename LibObjT>
2106 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
2108 BT_ASSERT_DBG(this->isArray());
2109 return CommonArrayFieldClass<LibObjT> {this->_libObjPtr()};
2112 template <typename LibObjT>
2113 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
2115 BT_ASSERT_DBG(this->isStaticArray());
2116 return CommonStaticArrayFieldClass<LibObjT> {this->_libObjPtr()};
2119 template <typename LibObjT>
2120 CommonDynamicArrayWithLengthFieldClass<LibObjT>
2121 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
2123 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
2124 return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->_libObjPtr()};
2127 template <typename LibObjT>
2128 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
2130 BT_ASSERT_DBG(this->isOption());
2131 return CommonOptionFieldClass<LibObjT> {this->_libObjPtr()};
2134 template <typename LibObjT>
2135 CommonOptionWithSelectorFieldClass<LibObjT>
2136 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
2138 BT_ASSERT_DBG(this->isOptionWithSelector());
2139 return CommonOptionWithSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2142 template <typename LibObjT>
2143 CommonOptionWithBoolSelectorFieldClass<LibObjT>
2144 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
2146 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
2147 return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2150 template <typename LibObjT>
2151 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
2152 CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
2154 BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
2155 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
2156 this->_libObjPtr()};
2159 template <typename LibObjT>
2160 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
2161 CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
2163 BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
2164 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
2165 this->_libObjPtr()};
2168 template <typename LibObjT>
2169 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
2171 BT_ASSERT_DBG(this->isVariant());
2172 return CommonVariantFieldClass<LibObjT> {this->_libObjPtr()};
2175 template <typename LibObjT>
2176 CommonVariantWithoutSelectorFieldClass<LibObjT>
2177 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
2179 BT_ASSERT_DBG(this->isVariantWithoutSelector());
2180 return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2183 template <typename LibObjT>
2184 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2185 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2186 CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
2188 BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
2189 return CommonVariantWithIntegerSelectorFieldClass<
2190 LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
2193 template <typename LibObjT>
2194 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2195 ConstVariantWithSignedIntegerSelectorFieldClassOption>
2196 CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
2198 BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
2199 return CommonVariantWithIntegerSelectorFieldClass<
2200 LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
2203 } /* namespace bt2 */
2205 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP */