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 "lib-error.hpp"
20 #include "integer-range-set.hpp"
21 #include "field-path.hpp"
27 struct FieldClassRefFuncs final
29 static void get(const bt_field_class * const libObjPtr)
31 bt_field_class_get_ref(libObjPtr);
34 static void put(const bt_field_class * const libObjPtr)
36 bt_field_class_put_ref(libObjPtr);
40 template <typename ObjT, typename LibObjT>
41 using SharedFieldClass = internal::SharedObj<ObjT, LibObjT, internal::FieldClassRefFuncs>;
43 template <typename LibObjT>
44 struct CommonFieldClassSpec;
46 // Functions specific to mutable field classes
48 struct CommonFieldClassSpec<bt_field_class> final
50 static bt_value *userAttributes(bt_field_class * const libObjPtr) noexcept
52 return bt_field_class_borrow_user_attributes(libObjPtr);
56 // Functions specific to constant field classes
58 struct CommonFieldClassSpec<const bt_field_class> final
60 static const bt_value *userAttributes(const bt_field_class * const libObjPtr) noexcept
62 return bt_field_class_borrow_user_attributes_const(libObjPtr);
66 } // namespace internal
68 template <typename LibObjT>
69 class CommonBitArrayFieldClass;
71 template <typename LibObjT>
72 class CommonIntegerFieldClass;
74 template <typename LibObjT>
75 class ConstEnumerationFieldClassMapping;
77 template <typename LibObjT, typename MappingT>
78 class CommonEnumerationFieldClass;
80 template <typename LibObjT>
81 class CommonStructureFieldClass;
83 template <typename LibObjT>
84 class CommonArrayFieldClass;
86 template <typename LibObjT>
87 class CommonStaticArrayFieldClass;
89 template <typename LibObjT>
90 class CommonDynamicArrayWithLengthFieldClass;
92 template <typename LibObjT>
93 class CommonOptionFieldClass;
95 template <typename LibObjT>
96 class CommonOptionWithSelectorFieldClass;
98 template <typename LibObjT>
99 class CommonOptionWithBoolSelectorFieldClass;
101 template <typename LibObjT>
102 class CommonVariantFieldClass;
104 template <typename LibObjT, typename RangeSetT>
105 class CommonOptionWithIntegerSelectorFieldClass;
107 template <typename LibObjT>
108 class CommonVariantWithoutSelectorFieldClass;
110 template <typename LibObjT>
111 class ConstVariantWithIntegerSelectorFieldClassOption;
113 template <typename LibObjT, typename RangeSetT>
114 class CommonVariantWithIntegerSelectorFieldClass;
116 enum class FieldClassType
118 BOOL = BT_FIELD_CLASS_TYPE_BOOL,
119 BIT_ARRAY = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
120 UNSIGNED_INTEGER = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER,
121 SIGNED_INTEGER = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER,
122 UNSIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
123 SIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
124 SINGLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL,
125 DOUBLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL,
126 STRING = BT_FIELD_CLASS_TYPE_STRING,
127 STRUCTURE = BT_FIELD_CLASS_TYPE_STRUCTURE,
128 STATIC_ARRAY = BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
129 DYNAMIC_ARRAY_WITHOUT_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD,
130 DYNAMIC_ARRAY_WITH_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD,
131 OPTION_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD,
132 OPTION_WITH_BOOL_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD,
133 OPTION_WITH_UNSIGNED_INTEGER_SELECTOR =
134 BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
135 OPTION_WITH_SIGNED_INTEGER_SELECTOR =
136 BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
137 VARIANT_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD,
138 VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR =
139 BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
140 VARIANT_WITH_SIGNED_INTEGER_SELECTOR =
141 BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
144 template <typename LibObjT>
145 class CommonFieldClass : public internal::BorrowedObj<LibObjT>
147 // Allow appendMember() to call `fc._libObjPtr()`
148 friend class CommonStructureFieldClass<bt_field_class>;
150 // Allow appendOption() to call `fc._libObjPtr()`
151 friend class CommonVariantWithoutSelectorFieldClass<bt_field_class>;
153 friend class CommonVariantWithIntegerSelectorFieldClass<
155 ConstVariantWithIntegerSelectorFieldClassOption<
156 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>;
158 friend class CommonVariantWithIntegerSelectorFieldClass<
160 ConstVariantWithIntegerSelectorFieldClassOption<
161 const bt_field_class_variant_with_selector_field_integer_signed_option>>;
164 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
167 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
168 using _ThisCommonFieldClass = CommonFieldClass<LibObjT>;
171 using Shared = internal::SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
173 using UserAttributes =
174 typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
176 explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
180 template <typename OtherLibObjT>
181 CommonFieldClass(const CommonFieldClass<OtherLibObjT>& fc) noexcept : _ThisBorrowedObj {fc}
185 template <typename OtherLibObjT>
186 _ThisCommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT>& fc) noexcept
188 _ThisBorrowedObj::operator=(fc);
192 FieldClassType type() const noexcept
194 return static_cast<FieldClassType>(bt_field_class_get_type(this->_libObjPtr()));
197 bool isBool() const noexcept
199 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BOOL);
202 bool isBitArray() const noexcept
204 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BIT_ARRAY);
207 bool isInteger() const noexcept
209 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_INTEGER);
212 bool isUnsignedInteger() const noexcept
214 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
217 bool isSignedInteger() const noexcept
219 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
222 bool isEnumeration() const noexcept
224 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ENUMERATION);
227 bool isUnsignedEnumeration() const noexcept
229 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
232 bool isSignedEnumeration() const noexcept
234 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
237 bool isSinglePrecisionReal() const noexcept
239 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL);
242 bool isDoublePrecisionReal() const noexcept
244 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL);
247 bool isString() const noexcept
249 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRING);
252 bool isStructure() const noexcept
254 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRUCTURE);
257 bool isArray() const noexcept
259 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ARRAY);
262 bool isStaticArray() const noexcept
264 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STATIC_ARRAY);
267 bool isDynamicArray() const noexcept
269 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY);
272 bool isDynamicArrayWithoutLength() const noexcept
274 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD);
277 bool isDynamicArrayWithLength() const noexcept
279 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
282 bool isOption() const noexcept
284 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION);
287 bool isOptionWithoutSelector() const noexcept
289 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD);
292 bool isOptionWithSelector() const noexcept
294 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD);
297 bool isOptionWithBoolSelector() const noexcept
299 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD);
302 bool isOptionWithIntegerSelector() const noexcept
304 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_INTEGER_SELECTOR_FIELD);
307 bool isOptionWithUnsignedIntegerSelector() const noexcept
309 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
312 bool isOptionWithSignedIntegerSelector() const noexcept
314 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
317 bool isVariant() const noexcept
319 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT);
322 bool isVariantWithoutSelector() const noexcept
324 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD);
327 bool isVariantWithSelector() const noexcept
329 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD);
332 bool isVariantWithIntegerSelector() const noexcept
334 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_INTEGER_SELECTOR_FIELD);
337 bool isVariantWithUnsignedIntegerSelector() const noexcept
339 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
342 bool isVariantWithSignedIntegerSelector() const noexcept
344 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
347 CommonBitArrayFieldClass<LibObjT> asBitArray() const noexcept;
348 CommonIntegerFieldClass<LibObjT> asInteger() const noexcept;
350 CommonEnumerationFieldClass<LibObjT, ConstEnumerationFieldClassMapping<
351 const bt_field_class_enumeration_unsigned_mapping>>
352 asUnsignedEnumeration() const noexcept;
354 CommonEnumerationFieldClass<
355 LibObjT, ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>>
356 asSignedEnumeration() const noexcept;
358 CommonStructureFieldClass<LibObjT> asStructure() const noexcept;
359 CommonArrayFieldClass<LibObjT> asArray() const noexcept;
360 CommonStaticArrayFieldClass<LibObjT> asStaticArray() const noexcept;
361 CommonDynamicArrayWithLengthFieldClass<LibObjT> asDynamicArrayWithLength() const noexcept;
362 CommonOptionFieldClass<LibObjT> asOption() const noexcept;
363 CommonOptionWithSelectorFieldClass<LibObjT> asOptionWithSelector() const noexcept;
364 CommonOptionWithBoolSelectorFieldClass<LibObjT> asOptionWithBoolSelector() const noexcept;
366 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
367 asOptionWithUnsignedIntegerSelector() const noexcept;
369 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
370 asOptionWithSignedIntegerSelector() const noexcept;
372 CommonVariantFieldClass<LibObjT> asVariant() const noexcept;
373 CommonVariantWithoutSelectorFieldClass<LibObjT> asVariantWithoutSelector() const noexcept;
375 CommonVariantWithIntegerSelectorFieldClass<
376 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
377 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>
378 asVariantWithUnsignedIntegerSelector() const noexcept;
380 CommonVariantWithIntegerSelectorFieldClass<
381 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
382 const bt_field_class_variant_with_selector_field_integer_signed_option>>
383 asVariantWithSignedIntegerSelector() const noexcept;
385 template <typename LibValT>
386 void userAttributes(const CommonMapValue<LibValT>& userAttrs)
388 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
390 bt_field_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
393 ConstMapValue userAttributes() const noexcept
395 return ConstMapValue {internal::CommonFieldClassSpec<const bt_field_class>::userAttributes(
396 this->_libObjPtr())};
399 UserAttributes userAttributes() noexcept
401 return UserAttributes {
402 internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->_libObjPtr())};
405 Shared shared() const noexcept
407 return Shared {*this};
411 bool _libTypeIs(const bt_field_class_type type) const noexcept
413 return bt_field_class_type_is(bt_field_class_get_type(this->_libObjPtr()), type);
417 using FieldClass = CommonFieldClass<bt_field_class>;
418 using ConstFieldClass = CommonFieldClass<const bt_field_class>;
420 template <typename LibObjT>
421 class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
424 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
425 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
428 using Shared = internal::SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
430 explicit CommonBitArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
431 _ThisCommonFieldClass {libObjPtr}
433 BT_ASSERT_DBG(this->isBitArray());
436 template <typename OtherLibObjT>
437 CommonBitArrayFieldClass(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept :
438 _ThisCommonFieldClass {fc}
442 template <typename OtherLibObjT>
443 CommonBitArrayFieldClass<LibObjT>&
444 operator=(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept
446 _ThisCommonFieldClass::operator=(fc);
450 std::uint64_t length() const noexcept
452 return bt_field_class_bit_array_get_length(this->_libObjPtr());
455 Shared shared() const noexcept
457 return Shared {*this};
461 using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
462 using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
464 enum class DisplayBase
466 BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
467 OCTAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL,
468 DECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL,
469 HEXADECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL,
472 template <typename LibObjT>
473 class CommonIntegerFieldClass : public CommonFieldClass<LibObjT>
476 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
479 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
480 using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass<LibObjT>;
483 using Shared = internal::SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
485 explicit CommonIntegerFieldClass(const _LibObjPtr libObjPtr) noexcept :
486 _ThisCommonFieldClass {libObjPtr}
488 BT_ASSERT_DBG(this->isInteger());
491 template <typename OtherLibObjT>
492 CommonIntegerFieldClass(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept :
493 _ThisCommonFieldClass {fc}
497 template <typename OtherLibObjT>
498 _ThisCommonIntegerFieldClass&
499 operator=(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept
501 _ThisCommonFieldClass::operator=(fc);
505 void fieldValueRange(const std::uint64_t n) noexcept
507 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
509 bt_field_class_integer_get_field_value_range(this->_libObjPtr(), n);
512 std::uint64_t fieldValueRange() const noexcept
514 return bt_field_class_integer_get_field_value_range(this->_libObjPtr());
517 void preferredDisplayBase(const DisplayBase base) noexcept
519 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
521 bt_field_class_integer_set_preferred_display_base(
522 this->_libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
525 DisplayBase preferredDisplayBase() const noexcept
527 return static_cast<DisplayBase>(
528 bt_field_class_integer_get_preferred_display_base(this->_libObjPtr()));
531 Shared shared() const noexcept
533 return Shared {*this};
537 using IntegerFieldClass = CommonIntegerFieldClass<bt_field_class>;
538 using ConstIntegerFieldClass = CommonIntegerFieldClass<const bt_field_class>;
542 template <typename LibObjT>
543 struct ConstEnumerationFieldClassMappingSpec;
545 // Functions specific to unsigned enumeration field class mappings
547 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_unsigned_mapping>
550 static const bt_integer_range_set_unsigned *
551 ranges(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
553 return bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(libObjPtr);
557 label(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
559 return bt_field_class_enumeration_mapping_get_label(
560 bt_field_class_enumeration_unsigned_mapping_as_mapping_const(libObjPtr));
564 // Functions specific to signed enumeration field class mappings
566 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_signed_mapping> final
568 static const bt_integer_range_set_signed *
569 ranges(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
571 return bt_field_class_enumeration_signed_mapping_borrow_ranges_const(libObjPtr);
575 label(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
577 return bt_field_class_enumeration_mapping_get_label(
578 bt_field_class_enumeration_signed_mapping_as_mapping_const(libObjPtr));
582 } // namespace internal
584 template <typename LibObjT>
585 class ConstEnumerationFieldClassMapping final : public internal::BorrowedObj<LibObjT>
588 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
589 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
590 using _ThisConstEnumerationFieldClassMapping = ConstEnumerationFieldClassMapping<LibObjT>;
593 using RangeSet = typename std::conditional<
594 std::is_same<LibObjT, const bt_field_class_enumeration_unsigned_mapping>::value,
595 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
597 explicit ConstEnumerationFieldClassMapping(const _LibObjPtr libObjPtr) noexcept :
598 _ThisBorrowedObj {libObjPtr}
602 ConstEnumerationFieldClassMapping(
603 const _ThisConstEnumerationFieldClassMapping& mapping) noexcept :
604 _ThisBorrowedObj {mapping}
608 _ThisConstEnumerationFieldClassMapping&
609 operator=(const _ThisConstEnumerationFieldClassMapping& mapping) noexcept
611 _ThisBorrowedObj::operator=(mapping);
615 RangeSet ranges() const noexcept
618 internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->_libObjPtr())};
621 bpstd::string_view label() const noexcept
623 return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->_libObjPtr());
627 using ConstUnsignedEnumerationFieldClassMapping =
628 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_unsigned_mapping>;
630 using ConstSignedEnumerationFieldClassMapping =
631 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>;
635 template <typename MappingT>
636 struct CommonEnumerationFieldClassSpec;
638 // Functions specific to unsigned enumeration field classes
640 struct CommonEnumerationFieldClassSpec<ConstUnsignedEnumerationFieldClassMapping> final
642 static const bt_field_class_enumeration_unsigned_mapping *
643 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
645 return bt_field_class_enumeration_unsigned_borrow_mapping_by_index_const(libObjPtr, index);
648 static const bt_field_class_enumeration_unsigned_mapping *
649 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
651 return bt_field_class_enumeration_unsigned_borrow_mapping_by_label_const(libObjPtr, label);
655 // Functions specific to signed enumeration field classes
657 struct CommonEnumerationFieldClassSpec<ConstSignedEnumerationFieldClassMapping> final
659 static const bt_field_class_enumeration_signed_mapping *
660 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
662 return bt_field_class_enumeration_signed_borrow_mapping_by_index_const(libObjPtr, index);
665 static const bt_field_class_enumeration_signed_mapping *
666 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
668 return bt_field_class_enumeration_signed_borrow_mapping_by_label_const(libObjPtr, label);
672 } // namespace internal
674 template <typename LibObjT, typename MappingT>
675 class CommonEnumerationFieldClass final : public CommonIntegerFieldClass<LibObjT>
678 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
679 using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
680 using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
683 using Shared = internal::SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
684 using Mapping = MappingT;
686 explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
687 _ThisCommonIntegerFieldClass {libObjPtr}
689 BT_ASSERT_DBG(this->isEnumeration());
692 template <typename OtherLibObjT>
693 CommonEnumerationFieldClass(
694 const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept :
695 _ThisCommonIntegerFieldClass {fc}
699 template <typename OtherLibObjT>
700 _ThisCommonEnumerationFieldClass&
701 operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept
703 _ThisCommonIntegerFieldClass::operator=(fc);
707 std::uint64_t size() const noexcept
709 return bt_field_class_enumeration_get_mapping_count(this->_libObjPtr());
712 Mapping operator[](const std::uint64_t index) const noexcept
714 return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
715 this->_libObjPtr(), index)};
718 nonstd::optional<Mapping> operator[](const char * const label) const noexcept
720 const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
721 this->_libObjPtr(), label);
724 return Mapping {libObjPtr};
727 return nonstd::nullopt;
730 nonstd::optional<Mapping> operator[](const std::string& label) const noexcept
732 return (*this)[label.data()];
735 Shared shared() const noexcept
737 return Shared {*this};
741 using UnsignedEnumerationFieldClass =
742 CommonEnumerationFieldClass<bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
744 using ConstUnsignedEnumerationFieldClass =
745 CommonEnumerationFieldClass<const bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
747 using SignedEnumerationFieldClass =
748 CommonEnumerationFieldClass<bt_field_class, ConstSignedEnumerationFieldClassMapping>;
750 using ConstSignedEnumerationFieldClass =
751 CommonEnumerationFieldClass<const bt_field_class, ConstSignedEnumerationFieldClassMapping>;
755 template <typename LibObjT>
756 struct CommonStructureFieldClassMemberSpec;
758 // Functions specific to mutable structure field class members
760 struct CommonStructureFieldClassMemberSpec<bt_field_class_structure_member> final
762 static bt_field_class *fieldClass(bt_field_class_structure_member * const libObjPtr) noexcept
764 return bt_field_class_structure_member_borrow_field_class(libObjPtr);
768 // Functions specific to constant structure field class members
770 struct CommonStructureFieldClassMemberSpec<const bt_field_class_structure_member> final
772 static const bt_field_class *
773 fieldClass(const bt_field_class_structure_member * const libObjPtr) noexcept
775 return bt_field_class_structure_member_borrow_field_class_const(libObjPtr);
779 } // namespace internal
781 template <typename LibObjT>
782 class CommonStructureFieldClassMember final : public internal::BorrowedObj<LibObjT>
785 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
786 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
789 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
792 explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept :
793 _ThisBorrowedObj {libObjPtr}
797 template <typename OtherLibObjT>
798 CommonStructureFieldClassMember(
799 const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept :
800 _ThisBorrowedObj {fc}
804 template <typename OtherLibObjT>
805 CommonStructureFieldClassMember<LibObjT>&
806 operator=(const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept
808 _ThisBorrowedObj::operator=(fc);
812 bpstd::string_view name() const noexcept
814 return bt_field_class_structure_member_get_name(this->_libObjPtr());
817 ConstFieldClass fieldClass() const noexcept
819 return ConstFieldClass {internal::CommonStructureFieldClassMemberSpec<
820 const bt_field_class_structure_member>::fieldClass(this->_libObjPtr())};
823 _FieldClass fieldClass() noexcept
826 internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->_libObjPtr())};
830 using StructureFieldClassMember = CommonStructureFieldClassMember<bt_field_class_structure_member>;
832 using ConstStructureFieldClassMember =
833 CommonStructureFieldClassMember<const bt_field_class_structure_member>;
837 template <typename LibObjT>
838 struct CommonStructureFieldClassSpec;
840 // Functions specific to mutable structure field classes
842 struct CommonStructureFieldClassSpec<bt_field_class> final
844 static bt_field_class_structure_member *memberByIndex(bt_field_class * const libObjPtr,
845 const std::uint64_t index) noexcept
847 return bt_field_class_structure_borrow_member_by_index(libObjPtr, index);
850 static bt_field_class_structure_member *memberByName(bt_field_class * const libObjPtr,
851 const char * const name) noexcept
853 return bt_field_class_structure_borrow_member_by_name(libObjPtr, name);
857 // Functions specific to constant structure field classes
859 struct CommonStructureFieldClassSpec<const bt_field_class> final
861 static const bt_field_class_structure_member *
862 memberByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
864 return bt_field_class_structure_borrow_member_by_index_const(libObjPtr, index);
867 static const bt_field_class_structure_member *
868 memberByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
870 return bt_field_class_structure_borrow_member_by_name_const(libObjPtr, name);
874 } // namespace internal
876 template <typename LibObjT>
877 class CommonStructureFieldClass final : public CommonFieldClass<LibObjT>
880 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
881 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
884 using Shared = internal::SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
887 typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClassMember,
888 StructureFieldClassMember>::type;
890 explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
891 _ThisCommonFieldClass {libObjPtr}
893 BT_ASSERT_DBG(this->isStructure());
896 template <typename OtherLibObjT>
897 CommonStructureFieldClass(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept :
898 _ThisCommonFieldClass {fc}
902 template <typename OtherLibObjT>
903 CommonStructureFieldClass<LibObjT>&
904 operator=(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept
906 _ThisCommonFieldClass::operator=(fc);
910 void appendMember(const char * const name, const FieldClass& fc)
912 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
915 bt_field_class_structure_append_member(this->_libObjPtr(), name, fc._libObjPtr());
917 if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
918 throw LibMemoryError {};
922 void appendMember(const std::string& name, const FieldClass& fc)
924 this->appendMember(name.data(), fc);
927 std::uint64_t size() const noexcept
929 return bt_field_class_structure_get_member_count(this->_libObjPtr());
932 ConstStructureFieldClassMember operator[](const std::uint64_t index) const noexcept
934 return ConstStructureFieldClassMember {
935 internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByIndex(
936 this->_libObjPtr(), index)};
939 Member operator[](const std::uint64_t index) noexcept
941 return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
942 this->_libObjPtr(), index)};
945 nonstd::optional<ConstStructureFieldClassMember>
946 operator[](const char * const name) const noexcept
948 const auto libObjPtr =
949 internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
950 this->_libObjPtr(), name);
953 return ConstStructureFieldClassMember {libObjPtr};
956 return nonstd::nullopt;
959 nonstd::optional<ConstStructureFieldClassMember>
960 operator[](const std::string& name) const noexcept
962 return (*this)[name.data()];
965 nonstd::optional<Member> operator[](const char * const name) noexcept
967 const auto libObjPtr = internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(
968 this->_libObjPtr(), name);
971 return Member {libObjPtr};
974 return nonstd::nullopt;
977 nonstd::optional<Member> operator[](const std::string& name) noexcept
979 return (*this)[name.data()];
982 Shared shared() const noexcept
984 return Shared {*this};
988 using StructureFieldClass = CommonStructureFieldClass<bt_field_class>;
989 using ConstStructureFieldClass = CommonStructureFieldClass<const bt_field_class>;
993 template <typename LibObjT>
994 struct CommonArrayFieldClassSpec;
996 // Functions specific to mutable array field classes
998 struct CommonArrayFieldClassSpec<bt_field_class> final
1000 static bt_field_class *elementFieldClass(bt_field_class * const libObjPtr) noexcept
1002 return bt_field_class_array_borrow_element_field_class(libObjPtr);
1006 // Functions specific to constant array field classes
1008 struct CommonArrayFieldClassSpec<const bt_field_class> final
1010 static const bt_field_class *elementFieldClass(const bt_field_class * const libObjPtr) noexcept
1012 return bt_field_class_array_borrow_element_field_class_const(libObjPtr);
1016 } // namespace internal
1018 template <typename LibObjT>
1019 class CommonArrayFieldClass : public CommonFieldClass<LibObjT>
1022 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1025 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1028 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1029 using _ThisCommonArrayFieldClass = CommonArrayFieldClass<LibObjT>;
1032 using Shared = internal::SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
1034 explicit CommonArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1035 _ThisCommonFieldClass {libObjPtr}
1037 BT_ASSERT_DBG(this->isArray());
1040 template <typename OtherLibObjT>
1041 CommonArrayFieldClass(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept :
1042 _ThisCommonFieldClass {fc}
1046 template <typename OtherLibObjT>
1047 _ThisCommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept
1049 _ThisCommonFieldClass::operator=(fc);
1053 ConstFieldClass elementFieldClass() const noexcept
1055 return ConstFieldClass {
1056 internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
1057 this->_libObjPtr())};
1060 _FieldClass elementFieldClass() noexcept
1062 return _FieldClass {
1063 internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->_libObjPtr())};
1066 Shared shared() const noexcept
1068 return Shared {*this};
1072 using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
1073 using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
1075 template <typename LibObjT>
1076 class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
1079 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1080 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1083 using Shared = internal::SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
1085 explicit CommonStaticArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1086 _ThisCommonArrayFieldClass {libObjPtr}
1088 BT_ASSERT_DBG(this->isStaticArray());
1091 template <typename OtherLibObjT>
1092 CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept :
1093 _ThisCommonArrayFieldClass {fc}
1097 template <typename OtherLibObjT>
1098 CommonStaticArrayFieldClass<LibObjT>&
1099 operator=(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept
1101 _ThisCommonArrayFieldClass::operator=(fc);
1105 std::uint64_t length() const noexcept
1107 return bt_field_class_array_static_get_length(this->_libObjPtr());
1110 Shared shared() const noexcept
1112 return Shared {*this};
1116 using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
1117 using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
1119 template <typename LibObjT>
1120 class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
1123 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1124 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1128 internal::SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
1130 explicit CommonDynamicArrayWithLengthFieldClass(const _LibObjPtr libObjPtr) noexcept :
1131 _ThisCommonArrayFieldClass {libObjPtr}
1133 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
1136 template <typename OtherLibObjT>
1137 CommonDynamicArrayWithLengthFieldClass(
1138 const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept :
1139 _ThisCommonArrayFieldClass {fc}
1143 template <typename OtherLibObjT>
1144 CommonDynamicArrayWithLengthFieldClass<LibObjT>&
1145 operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept
1147 _ThisCommonArrayFieldClass::operator=(fc);
1151 ConstFieldPath lengthFieldPath() const noexcept
1153 return ConstFieldPath {
1154 bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
1155 this->_libObjPtr())};
1158 Shared shared() const noexcept
1160 return Shared {*this};
1164 using DynamicArrayWithLengthFieldClass = CommonDynamicArrayWithLengthFieldClass<bt_field_class>;
1166 using ConstDynamicArrayWithLengthFieldClass =
1167 CommonDynamicArrayWithLengthFieldClass<const bt_field_class>;
1169 namespace internal {
1171 template <typename LibObjT>
1172 struct CommonOptionFieldClassSpec;
1174 // Functions specific to mutable option field classes
1176 struct CommonOptionFieldClassSpec<bt_field_class> final
1178 static bt_field_class *fieldClass(bt_field_class * const libObjPtr) noexcept
1180 return bt_field_class_option_borrow_field_class(libObjPtr);
1184 // Functions specific to constant option field classes
1186 struct CommonOptionFieldClassSpec<const bt_field_class> final
1188 static const bt_field_class *fieldClass(const bt_field_class * const libObjPtr) noexcept
1190 return bt_field_class_option_borrow_field_class_const(libObjPtr);
1194 } // namespace internal
1196 template <typename LibObjT>
1197 class CommonOptionFieldClass : public CommonFieldClass<LibObjT>
1200 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1203 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1206 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1207 using _ThisCommonOptionFieldClass = CommonOptionFieldClass<LibObjT>;
1210 using Shared = internal::SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
1212 explicit CommonOptionFieldClass(const _LibObjPtr libObjPtr) noexcept :
1213 _ThisCommonFieldClass {libObjPtr}
1215 BT_ASSERT_DBG(this->isOption());
1218 template <typename OtherLibObjT>
1219 CommonOptionFieldClass(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept :
1220 _ThisCommonFieldClass {fc}
1224 template <typename OtherLibObjT>
1225 _ThisCommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept
1227 _ThisCommonFieldClass::operator=(fc);
1231 ConstFieldClass fieldClass() const noexcept
1233 return ConstFieldClass {
1234 internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
1235 this->_libObjPtr())};
1238 _FieldClass fieldClass() noexcept
1240 return _FieldClass {
1241 internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->_libObjPtr())};
1244 Shared shared() const noexcept
1246 return Shared {*this};
1250 using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
1251 using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
1253 template <typename LibObjT>
1254 class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
1257 using typename CommonOptionFieldClass<LibObjT>::_ThisCommonOptionFieldClass;
1260 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1261 using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<LibObjT>;
1264 using Shared = internal::SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
1266 explicit CommonOptionWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1267 _ThisCommonOptionFieldClass {libObjPtr}
1269 BT_ASSERT_DBG(this->isOptionWithSelector());
1272 template <typename OtherLibObjT>
1273 CommonOptionWithSelectorFieldClass(
1274 const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1275 _ThisCommonOptionFieldClass {fc}
1279 template <typename OtherLibObjT>
1280 _ThisCommonOptionWithSelectorFieldClass&
1281 operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept
1283 _ThisCommonOptionFieldClass::operator=(fc);
1287 ConstFieldPath selectorFieldPath() const noexcept
1289 return ConstFieldPath {
1290 bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
1291 this->_libObjPtr())};
1294 Shared shared() const noexcept
1296 return Shared {*this};
1300 using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
1301 using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
1303 template <typename LibObjT>
1304 class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1307 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1309 using typename CommonOptionWithSelectorFieldClass<
1310 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1314 internal::SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
1316 explicit CommonOptionWithBoolSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1317 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1319 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
1322 template <typename OtherLibObjT>
1323 CommonOptionWithBoolSelectorFieldClass(
1324 const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1325 _ThisCommonOptionWithSelectorFieldClass {fc}
1329 template <typename OtherLibObjT>
1330 CommonOptionWithBoolSelectorFieldClass<LibObjT>&
1331 operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept
1333 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1337 bool selectorIsReversed() const noexcept
1339 return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
1340 this->_libObjPtr());
1343 Shared shared() const noexcept
1345 return Shared {*this};
1349 using OptionWithBoolSelectorFieldClass = CommonOptionWithBoolSelectorFieldClass<bt_field_class>;
1351 using ConstOptionWithBoolSelectorFieldClass =
1352 CommonOptionWithBoolSelectorFieldClass<const bt_field_class>;
1354 namespace internal {
1356 template <typename RangeSetT>
1357 struct CommonOptionWithIntegerSelectorFieldClassSpec;
1359 // Functions specific to option field classes with unsigned integer ranges
1361 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstUnsignedIntegerRangeSet> final
1363 static const bt_integer_range_set_unsigned *
1364 ranges(const bt_field_class * const libObjPtr) noexcept
1366 return bt_field_class_option_with_selector_field_integer_unsigned_borrow_selector_ranges_const(
1371 // Functions specific to option field classes with signed ranges
1373 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstSignedIntegerRangeSet> final
1375 static const bt_integer_range_set_signed *
1376 ranges(const bt_field_class * const libObjPtr) noexcept
1378 return bt_field_class_option_with_selector_field_integer_signed_borrow_selector_ranges_const(
1383 } // namespace internal
1385 template <typename LibObjT, typename RangeSetT>
1386 class CommonOptionWithIntegerSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1389 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1391 using typename CommonOptionWithSelectorFieldClass<
1392 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1394 using _ThisCommonOptionWithIntegerSelectorFieldClass =
1395 CommonOptionWithIntegerSelectorFieldClass<LibObjT, RangeSetT>;
1399 internal::SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
1401 using RangeSet = RangeSetT;
1403 explicit CommonOptionWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1404 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1406 BT_ASSERT_DBG(this->isOptionWithIntegerSelector());
1409 template <typename OtherLibObjT>
1410 CommonOptionWithIntegerSelectorFieldClass(
1411 const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept :
1412 _ThisCommonOptionWithSelectorFieldClass {fc}
1416 template <typename OtherLibObjT>
1417 _ThisCommonOptionWithIntegerSelectorFieldClass&
1418 operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept
1420 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1424 RangeSet ranges() const noexcept
1426 return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
1427 this->_libObjPtr())};
1430 Shared shared() const noexcept
1432 return Shared {*this};
1436 using OptionWithUnsignedIntegerSelectorFieldClass =
1437 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstUnsignedIntegerRangeSet>;
1439 using ConstOptionWithUnsignedIntegerSelectorFieldClass =
1440 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstUnsignedIntegerRangeSet>;
1442 using OptionWithSignedIntegerSelectorFieldClass =
1443 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstSignedIntegerRangeSet>;
1445 using ConstOptionWithSignedIntegerSelectorFieldClass =
1446 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstSignedIntegerRangeSet>;
1448 namespace internal {
1450 template <typename LibObjT>
1451 struct CommonVariantFieldClassOptionSpec;
1453 // Functions specific to mutable variant field class options
1455 struct CommonVariantFieldClassOptionSpec<bt_field_class_variant_option> final
1457 static bt_field_class *fieldClass(bt_field_class_variant_option * const libObjPtr) noexcept
1459 return bt_field_class_variant_option_borrow_field_class(libObjPtr);
1463 // Functions specific to constant variant field class options
1465 struct CommonVariantFieldClassOptionSpec<const bt_field_class_variant_option> final
1467 static const bt_field_class *
1468 fieldClass(const bt_field_class_variant_option * const libObjPtr) noexcept
1470 return bt_field_class_variant_option_borrow_field_class_const(libObjPtr);
1474 } // namespace internal
1476 template <typename LibObjT>
1477 class CommonVariantFieldClassOption : public internal::BorrowedObj<LibObjT>
1480 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
1481 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
1484 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1487 explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1488 _ThisBorrowedObj {libObjPtr}
1492 template <typename OtherLibObjT>
1493 CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept :
1494 _ThisBorrowedObj {fc}
1498 template <typename OtherLibObjT>
1499 CommonVariantFieldClassOption<LibObjT>&
1500 operator=(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept
1502 _ThisBorrowedObj::operator=(fc);
1506 bpstd::string_view name() const noexcept
1508 return bt_field_class_variant_option_get_name(this->_libObjPtr());
1511 ConstFieldClass fieldClass() const noexcept
1513 return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
1514 const bt_field_class_variant_option>::fieldClass(this->_libObjPtr())};
1517 _FieldClass fieldClass() noexcept
1519 return _FieldClass {
1520 internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->_libObjPtr())};
1524 using VariantFieldClassOption = CommonVariantFieldClassOption<bt_field_class_variant_option>;
1526 using ConstVariantFieldClassOption =
1527 CommonVariantFieldClassOption<const bt_field_class_variant_option>;
1529 namespace internal {
1531 template <typename LibObjT>
1532 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
1534 // Functions specific to variant field class options with unsigned integer selector
1536 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1537 const bt_field_class_variant_with_selector_field_integer_unsigned_option>
1540 static const bt_integer_range_set_unsigned *
1541 ranges(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1542 * const libObjPtr) noexcept
1544 return bt_field_class_variant_with_selector_field_integer_unsigned_option_borrow_ranges_const(
1548 static const bt_field_class_variant_option *
1549 asBaseOption(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1550 * const libObjPtr) noexcept
1552 return bt_field_class_variant_with_selector_field_integer_unsigned_option_as_option_const(
1557 // Functions specific to variant field class options with signed integer selector
1559 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1560 const bt_field_class_variant_with_selector_field_integer_signed_option>
1563 static const bt_integer_range_set_signed *
1564 ranges(const bt_field_class_variant_with_selector_field_integer_signed_option
1565 * const libObjPtr) noexcept
1567 return bt_field_class_variant_with_selector_field_integer_signed_option_borrow_ranges_const(
1571 static const bt_field_class_variant_option *
1572 asBaseOption(const bt_field_class_variant_with_selector_field_integer_signed_option
1573 * const libObjPtr) noexcept
1575 return bt_field_class_variant_with_selector_field_integer_signed_option_as_option_const(
1580 } // namespace internal
1582 template <typename LibObjT>
1583 class ConstVariantWithIntegerSelectorFieldClassOption : public internal::BorrowedObj<LibObjT>
1586 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
1587 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
1588 using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
1591 using RangeSet = typename std::conditional<
1594 const bt_field_class_variant_with_selector_field_integer_unsigned_option>::value,
1595 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
1597 explicit ConstVariantWithIntegerSelectorFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1598 _ThisBorrowedObj {libObjPtr}
1602 template <typename OtherLibObjT>
1603 ConstVariantWithIntegerSelectorFieldClassOption(
1604 const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept :
1605 _ThisBorrowedObj {fc}
1609 template <typename OtherLibObjT>
1610 ConstVariantWithIntegerSelectorFieldClassOption<LibObjT>&
1611 operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept
1613 _ThisBorrowedObj::operator=(fc);
1617 ConstVariantFieldClassOption asBaseOption() const noexcept
1619 return ConstVariantFieldClassOption {_Spec::asBaseOption(this->_libObjPtr())};
1622 bpstd::string_view name() const noexcept
1624 return this->asBaseOption().name();
1627 ConstFieldClass fieldClass() const noexcept
1629 return this->asBaseOption().fieldClass();
1632 RangeSet ranges() const noexcept
1634 return RangeSet {_Spec::ranges(this->_libObjPtr())};
1638 using ConstVariantWithUnsignedIntegerSelectorFieldClassOption =
1639 ConstVariantWithIntegerSelectorFieldClassOption<
1640 const bt_field_class_variant_with_selector_field_integer_unsigned_option>;
1642 using ConstVariantWithSignedIntegerSelectorFieldClassOption =
1643 ConstVariantWithIntegerSelectorFieldClassOption<
1644 const bt_field_class_variant_with_selector_field_integer_signed_option>;
1646 namespace internal {
1648 template <typename LibObjT>
1649 struct CommonVariantFieldClassSpec;
1651 // Functions specific to mutable variant field classes
1653 struct CommonVariantFieldClassSpec<bt_field_class> final
1655 static bt_field_class_variant_option *optionByIndex(bt_field_class * const libObjPtr,
1656 const std::uint64_t index) noexcept
1658 return bt_field_class_variant_borrow_option_by_index(libObjPtr, index);
1661 static bt_field_class_variant_option *optionByName(bt_field_class * const libObjPtr,
1662 const char * const name) noexcept
1664 return bt_field_class_variant_borrow_option_by_name(libObjPtr, name);
1668 // Functions specific to constant variant field classes
1670 struct CommonVariantFieldClassSpec<const bt_field_class> final
1672 static const bt_field_class_variant_option *
1673 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1675 return bt_field_class_variant_borrow_option_by_index_const(libObjPtr, index);
1678 static const bt_field_class_variant_option *optionByName(const bt_field_class * const libObjPtr,
1679 const char * const name) noexcept
1681 return bt_field_class_variant_borrow_option_by_name_const(libObjPtr, name);
1685 } // namespace internal
1687 template <typename LibObjT>
1688 class CommonVariantFieldClass : public CommonFieldClass<LibObjT>
1691 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1694 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1695 using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
1698 using Shared = internal::SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
1701 typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
1702 VariantFieldClassOption>::type;
1704 explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
1705 _ThisCommonFieldClass {libObjPtr}
1707 BT_ASSERT_DBG(this->isVariant());
1710 template <typename OtherLibObjT>
1711 CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept :
1712 _ThisCommonFieldClass {fc}
1716 template <typename OtherLibObjT>
1717 _ThisCommonVariantFieldClass&
1718 operator=(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept
1720 _ThisCommonFieldClass::operator=(fc);
1724 std::uint64_t size() const noexcept
1726 return bt_field_class_variant_get_option_count(this->_libObjPtr());
1729 ConstVariantFieldClassOption operator[](const std::uint64_t index) const noexcept
1731 return ConstVariantFieldClassOption {
1732 internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
1733 this->_libObjPtr(), index)};
1736 Option operator[](const std::uint64_t index) noexcept
1738 return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
1739 this->_libObjPtr(), index)};
1742 nonstd::optional<ConstVariantFieldClassOption>
1743 operator[](const char * const name) const noexcept
1745 const auto libObjPtr =
1746 internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
1747 this->_libObjPtr(), name);
1750 return ConstVariantFieldClassOption {libObjPtr};
1753 return nonstd::nullopt;
1756 nonstd::optional<ConstVariantFieldClassOption>
1757 operator[](const std::string& name) const noexcept
1759 return (*this)[name.data()];
1762 nonstd::optional<Option> operator[](const char * const name) noexcept
1764 const auto libObjPtr =
1765 internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->_libObjPtr(), name);
1768 return Option {libObjPtr};
1771 return nonstd::nullopt;
1774 nonstd::optional<Option> operator[](const std::string& name) noexcept
1776 return (*this)[name.data()];
1779 Shared shared() const noexcept
1781 return Shared {*this};
1785 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
1786 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
1788 template <typename LibObjT>
1789 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
1792 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
1793 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1797 internal::SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
1799 explicit CommonVariantWithoutSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1800 _ThisCommonVariantFieldClass {libObjPtr}
1802 BT_ASSERT_DBG(this->isVariantWithoutSelector());
1805 template <typename OtherLibObjT>
1806 CommonVariantWithoutSelectorFieldClass(
1807 const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1808 _ThisCommonVariantFieldClass {fc}
1812 template <typename OtherLibObjT>
1813 CommonVariantWithoutSelectorFieldClass<LibObjT>&
1814 operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept
1816 _ThisCommonVariantFieldClass::operator=(fc);
1820 void appendOption(const char * const name, const FieldClass& fc)
1822 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1824 const auto status = bt_field_class_variant_without_selector_append_option(
1825 this->_libObjPtr(), name, fc._libObjPtr());
1828 BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
1829 throw LibMemoryError {};
1833 void appendOption(const std::string& name, const FieldClass& fc)
1835 this->appendOption(name.data(), fc);
1838 Shared shared() const noexcept
1840 return Shared {*this};
1844 using VariantWithoutSelectorFieldClass = CommonVariantWithoutSelectorFieldClass<bt_field_class>;
1845 using ConstVariantWithoutSelectorFieldClass =
1846 CommonVariantWithoutSelectorFieldClass<const bt_field_class>;
1848 namespace internal {
1850 template <typename OptionT>
1851 struct CommonVariantWithIntegerSelectorFieldClassSpec;
1853 // Functions specific to variant field classes with unsigned integer selector
1855 struct CommonVariantWithIntegerSelectorFieldClassSpec<
1856 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
1859 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
1860 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1862 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_index_const(
1866 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
1867 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1869 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_name_const(
1873 static bt_field_class_variant_with_selector_field_integer_append_option_status
1874 appendOption(bt_field_class * const libObjPtr, const char * const name,
1875 bt_field_class * const libOptFcPtr,
1876 const bt_integer_range_set_unsigned * const libRangesPtr)
1878 return bt_field_class_variant_with_selector_field_integer_unsigned_append_option(
1879 libObjPtr, name, libOptFcPtr, libRangesPtr);
1883 // Functions specific to variant field classes with signed integer selector
1885 struct CommonVariantWithIntegerSelectorFieldClassSpec<
1886 ConstVariantWithSignedIntegerSelectorFieldClassOption>
1889 static const bt_field_class_variant_with_selector_field_integer_signed_option *
1890 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1892 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_index_const(
1896 static const bt_field_class_variant_with_selector_field_integer_signed_option *
1897 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1899 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_name_const(
1903 static bt_field_class_variant_with_selector_field_integer_append_option_status
1904 appendOption(bt_field_class * const libObjPtr, const char * const name,
1905 bt_field_class * const libOptFcPtr,
1906 const bt_integer_range_set_signed * const libRangesPtr)
1908 return bt_field_class_variant_with_selector_field_integer_signed_append_option(
1909 libObjPtr, name, libOptFcPtr, libRangesPtr);
1913 } // namespace internal
1915 template <typename LibObjT, typename OptionT>
1916 class CommonVariantWithIntegerSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
1919 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
1920 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1922 using _ThisCommonVariantWithIntegerSelectorFieldClass =
1923 CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
1925 using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
1929 internal::SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
1931 using Option = OptionT;
1933 explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1934 _ThisCommonVariantFieldClass {libObjPtr}
1936 BT_ASSERT_DBG(this->isVariant());
1939 template <typename OtherLibObjT>
1940 CommonVariantWithIntegerSelectorFieldClass(
1941 const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept :
1942 _ThisCommonVariantFieldClass {fc}
1946 template <typename OtherLibObjT>
1947 _ThisCommonVariantWithIntegerSelectorFieldClass&
1948 operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept
1950 _ThisCommonVariantFieldClass::operator=(fc);
1954 ConstFieldPath selectorFieldPath() const noexcept
1956 return ConstFieldPath {
1957 bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
1958 this->_libObjPtr())};
1961 Option operator[](const std::uint64_t index) const noexcept
1963 return Option {_Spec::optionByIndex(this->_libObjPtr(), index)};
1966 nonstd::optional<Option> operator[](const char * const name) const noexcept
1968 const auto libObjPtr = _Spec::optionByName(this->_libObjPtr(), name);
1971 return Option {libObjPtr};
1974 return nonstd::nullopt;
1977 nonstd::optional<Option> operator[](const std::string& name) const noexcept
1979 return (*this)[name.data()];
1982 void appendOption(const char * const name, const FieldClass& fc,
1983 const typename Option::RangeSet& ranges)
1985 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1988 _Spec::appendOption(this->_libObjPtr(), name, fc._libObjPtr(), ranges._libObjPtr());
1991 BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
1992 throw LibMemoryError {};
1996 void appendOption(const std::string& name, const FieldClass& fc)
1998 this->appendOption(name.data(), fc);
2001 Shared shared() const noexcept
2003 return Shared {*this};
2007 using VariantWithUnsignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2008 bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2010 using ConstVariantWithUnsignedIntegerSelectorFieldClass =
2011 CommonVariantWithIntegerSelectorFieldClass<
2012 const bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2014 using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2015 bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2017 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2018 const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2020 template <typename LibObjT>
2021 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
2023 BT_ASSERT_DBG(this->isBitArray());
2024 return CommonBitArrayFieldClass<LibObjT> {this->_libObjPtr()};
2027 template <typename LibObjT>
2028 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
2030 BT_ASSERT_DBG(this->isInteger());
2031 return CommonIntegerFieldClass<LibObjT> {this->_libObjPtr()};
2034 template <typename LibObjT>
2035 CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping>
2036 CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
2038 BT_ASSERT_DBG(this->isUnsignedEnumeration());
2039 return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
2040 this->_libObjPtr()};
2043 template <typename LibObjT>
2044 CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping>
2045 CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
2047 BT_ASSERT_DBG(this->isSignedEnumeration());
2048 return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
2049 this->_libObjPtr()};
2052 template <typename LibObjT>
2053 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
2055 BT_ASSERT_DBG(this->isStructure());
2056 return CommonStructureFieldClass<LibObjT> {this->_libObjPtr()};
2059 template <typename LibObjT>
2060 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
2062 BT_ASSERT_DBG(this->isArray());
2063 return CommonArrayFieldClass<LibObjT> {this->_libObjPtr()};
2066 template <typename LibObjT>
2067 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
2069 BT_ASSERT_DBG(this->isStaticArray());
2070 return CommonStaticArrayFieldClass<LibObjT> {this->_libObjPtr()};
2073 template <typename LibObjT>
2074 CommonDynamicArrayWithLengthFieldClass<LibObjT>
2075 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
2077 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
2078 return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->_libObjPtr()};
2081 template <typename LibObjT>
2082 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
2084 BT_ASSERT_DBG(this->isOption());
2085 return CommonOptionFieldClass<LibObjT> {this->_libObjPtr()};
2088 template <typename LibObjT>
2089 CommonOptionWithSelectorFieldClass<LibObjT>
2090 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
2092 BT_ASSERT_DBG(this->isOptionWithSelector());
2093 return CommonOptionWithSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2096 template <typename LibObjT>
2097 CommonOptionWithBoolSelectorFieldClass<LibObjT>
2098 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
2100 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
2101 return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2104 template <typename LibObjT>
2105 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
2106 CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
2108 BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
2109 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
2110 this->_libObjPtr()};
2113 template <typename LibObjT>
2114 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
2115 CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
2117 BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
2118 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
2119 this->_libObjPtr()};
2122 template <typename LibObjT>
2123 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
2125 BT_ASSERT_DBG(this->isVariant());
2126 return CommonVariantFieldClass<LibObjT> {this->_libObjPtr()};
2129 template <typename LibObjT>
2130 CommonVariantWithoutSelectorFieldClass<LibObjT>
2131 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
2133 BT_ASSERT_DBG(this->isVariantWithoutSelector());
2134 return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2137 template <typename LibObjT>
2138 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2139 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2140 CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
2142 BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
2143 return CommonVariantWithIntegerSelectorFieldClass<
2144 LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
2147 template <typename LibObjT>
2148 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2149 ConstVariantWithSignedIntegerSelectorFieldClassOption>
2150 CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
2152 BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
2153 return CommonVariantWithIntegerSelectorFieldClass<
2154 LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
2159 #endif // BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP