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 template <typename LibObjT>
117 class CommonEventClass;
119 template <typename LibObjT>
120 class CommonStreamClass;
122 template <typename LibObjT>
123 class CommonTraceClass;
125 enum class FieldClassType
127 BOOL = BT_FIELD_CLASS_TYPE_BOOL,
128 BIT_ARRAY = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
129 UNSIGNED_INTEGER = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER,
130 SIGNED_INTEGER = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER,
131 UNSIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
132 SIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
133 SINGLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL,
134 DOUBLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL,
135 STRING = BT_FIELD_CLASS_TYPE_STRING,
136 STRUCTURE = BT_FIELD_CLASS_TYPE_STRUCTURE,
137 STATIC_ARRAY = BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
138 DYNAMIC_ARRAY_WITHOUT_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD,
139 DYNAMIC_ARRAY_WITH_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD,
140 OPTION_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD,
141 OPTION_WITH_BOOL_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD,
142 OPTION_WITH_UNSIGNED_INTEGER_SELECTOR =
143 BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
144 OPTION_WITH_SIGNED_INTEGER_SELECTOR =
145 BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
146 VARIANT_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD,
147 VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR =
148 BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
149 VARIANT_WITH_SIGNED_INTEGER_SELECTOR =
150 BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
153 template <typename LibObjT>
154 class CommonFieldClass : public internal::BorrowedObj<LibObjT>
156 // Allow appendMember() to call `fc._libObjPtr()`
157 friend class CommonStructureFieldClass<bt_field_class>;
159 // Allow appendOption() to call `fc._libObjPtr()`
160 friend class CommonVariantWithoutSelectorFieldClass<bt_field_class>;
162 friend class CommonVariantWithIntegerSelectorFieldClass<
164 ConstVariantWithIntegerSelectorFieldClassOption<
165 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>;
167 friend class CommonVariantWithIntegerSelectorFieldClass<
169 ConstVariantWithIntegerSelectorFieldClassOption<
170 const bt_field_class_variant_with_selector_field_integer_signed_option>>;
172 // Allow *FieldClass() to call `fc._libObjPtr()`
173 friend class CommonEventClass<bt_event_class>;
174 friend class CommonStreamClass<bt_stream_class>;
176 // Allow create*FieldClass() to call `fc._libObjPtr()`
177 friend class CommonTraceClass<bt_trace_class>;
180 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
183 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
184 using _ThisCommonFieldClass = CommonFieldClass<LibObjT>;
187 using Shared = internal::SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
189 using UserAttributes =
190 typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
192 explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
196 template <typename OtherLibObjT>
197 CommonFieldClass(const CommonFieldClass<OtherLibObjT>& fc) noexcept : _ThisBorrowedObj {fc}
201 template <typename OtherLibObjT>
202 _ThisCommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT>& fc) noexcept
204 _ThisBorrowedObj::operator=(fc);
208 FieldClassType type() const noexcept
210 return static_cast<FieldClassType>(bt_field_class_get_type(this->_libObjPtr()));
213 bool isBool() const noexcept
215 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BOOL);
218 bool isBitArray() const noexcept
220 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BIT_ARRAY);
223 bool isInteger() const noexcept
225 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_INTEGER);
228 bool isUnsignedInteger() const noexcept
230 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
233 bool isSignedInteger() const noexcept
235 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
238 bool isEnumeration() const noexcept
240 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ENUMERATION);
243 bool isUnsignedEnumeration() const noexcept
245 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
248 bool isSignedEnumeration() const noexcept
250 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
253 bool isSinglePrecisionReal() const noexcept
255 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL);
258 bool isDoublePrecisionReal() const noexcept
260 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL);
263 bool isString() const noexcept
265 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRING);
268 bool isStructure() const noexcept
270 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRUCTURE);
273 bool isArray() const noexcept
275 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ARRAY);
278 bool isStaticArray() const noexcept
280 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STATIC_ARRAY);
283 bool isDynamicArray() const noexcept
285 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY);
288 bool isDynamicArrayWithoutLength() const noexcept
290 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD);
293 bool isDynamicArrayWithLength() const noexcept
295 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
298 bool isOption() const noexcept
300 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION);
303 bool isOptionWithoutSelector() const noexcept
305 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD);
308 bool isOptionWithSelector() const noexcept
310 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD);
313 bool isOptionWithBoolSelector() const noexcept
315 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD);
318 bool isOptionWithIntegerSelector() const noexcept
320 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_INTEGER_SELECTOR_FIELD);
323 bool isOptionWithUnsignedIntegerSelector() const noexcept
325 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
328 bool isOptionWithSignedIntegerSelector() const noexcept
330 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
333 bool isVariant() const noexcept
335 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT);
338 bool isVariantWithoutSelector() const noexcept
340 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD);
343 bool isVariantWithSelector() const noexcept
345 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD);
348 bool isVariantWithIntegerSelector() const noexcept
350 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_INTEGER_SELECTOR_FIELD);
353 bool isVariantWithUnsignedIntegerSelector() const noexcept
355 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
358 bool isVariantWithSignedIntegerSelector() const noexcept
360 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
363 CommonBitArrayFieldClass<LibObjT> asBitArray() const noexcept;
364 CommonIntegerFieldClass<LibObjT> asInteger() const noexcept;
366 CommonEnumerationFieldClass<LibObjT, ConstEnumerationFieldClassMapping<
367 const bt_field_class_enumeration_unsigned_mapping>>
368 asUnsignedEnumeration() const noexcept;
370 CommonEnumerationFieldClass<
371 LibObjT, ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>>
372 asSignedEnumeration() const noexcept;
374 CommonStructureFieldClass<LibObjT> asStructure() const noexcept;
375 CommonArrayFieldClass<LibObjT> asArray() const noexcept;
376 CommonStaticArrayFieldClass<LibObjT> asStaticArray() const noexcept;
377 CommonDynamicArrayWithLengthFieldClass<LibObjT> asDynamicArrayWithLength() const noexcept;
378 CommonOptionFieldClass<LibObjT> asOption() const noexcept;
379 CommonOptionWithSelectorFieldClass<LibObjT> asOptionWithSelector() const noexcept;
380 CommonOptionWithBoolSelectorFieldClass<LibObjT> asOptionWithBoolSelector() const noexcept;
382 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
383 asOptionWithUnsignedIntegerSelector() const noexcept;
385 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
386 asOptionWithSignedIntegerSelector() const noexcept;
388 CommonVariantFieldClass<LibObjT> asVariant() const noexcept;
389 CommonVariantWithoutSelectorFieldClass<LibObjT> asVariantWithoutSelector() const noexcept;
391 CommonVariantWithIntegerSelectorFieldClass<
392 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
393 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>
394 asVariantWithUnsignedIntegerSelector() const noexcept;
396 CommonVariantWithIntegerSelectorFieldClass<
397 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
398 const bt_field_class_variant_with_selector_field_integer_signed_option>>
399 asVariantWithSignedIntegerSelector() const noexcept;
401 template <typename LibValT>
402 void userAttributes(const CommonMapValue<LibValT>& userAttrs)
404 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
406 bt_field_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
409 ConstMapValue userAttributes() const noexcept
411 return ConstMapValue {internal::CommonFieldClassSpec<const bt_field_class>::userAttributes(
412 this->_libObjPtr())};
415 UserAttributes userAttributes() noexcept
417 return UserAttributes {
418 internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->_libObjPtr())};
421 Shared shared() const noexcept
423 return Shared {*this};
427 bool _libTypeIs(const bt_field_class_type type) const noexcept
429 return bt_field_class_type_is(bt_field_class_get_type(this->_libObjPtr()), type);
433 using FieldClass = CommonFieldClass<bt_field_class>;
434 using ConstFieldClass = CommonFieldClass<const bt_field_class>;
436 template <typename LibObjT>
437 class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
440 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
441 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
444 using Shared = internal::SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
446 explicit CommonBitArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
447 _ThisCommonFieldClass {libObjPtr}
449 BT_ASSERT_DBG(this->isBitArray());
452 template <typename OtherLibObjT>
453 CommonBitArrayFieldClass(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept :
454 _ThisCommonFieldClass {fc}
458 template <typename OtherLibObjT>
459 CommonBitArrayFieldClass<LibObjT>&
460 operator=(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept
462 _ThisCommonFieldClass::operator=(fc);
466 std::uint64_t length() const noexcept
468 return bt_field_class_bit_array_get_length(this->_libObjPtr());
471 Shared shared() const noexcept
473 return Shared {*this};
477 using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
478 using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
480 enum class DisplayBase
482 BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
483 OCTAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL,
484 DECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL,
485 HEXADECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL,
488 template <typename LibObjT>
489 class CommonIntegerFieldClass : public CommonFieldClass<LibObjT>
492 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
495 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
496 using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass<LibObjT>;
499 using Shared = internal::SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
501 explicit CommonIntegerFieldClass(const _LibObjPtr libObjPtr) noexcept :
502 _ThisCommonFieldClass {libObjPtr}
504 BT_ASSERT_DBG(this->isInteger());
507 template <typename OtherLibObjT>
508 CommonIntegerFieldClass(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept :
509 _ThisCommonFieldClass {fc}
513 template <typename OtherLibObjT>
514 _ThisCommonIntegerFieldClass&
515 operator=(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept
517 _ThisCommonFieldClass::operator=(fc);
521 void fieldValueRange(const std::uint64_t n) noexcept
523 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
525 bt_field_class_integer_get_field_value_range(this->_libObjPtr(), n);
528 std::uint64_t fieldValueRange() const noexcept
530 return bt_field_class_integer_get_field_value_range(this->_libObjPtr());
533 void preferredDisplayBase(const DisplayBase base) noexcept
535 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
537 bt_field_class_integer_set_preferred_display_base(
538 this->_libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
541 DisplayBase preferredDisplayBase() const noexcept
543 return static_cast<DisplayBase>(
544 bt_field_class_integer_get_preferred_display_base(this->_libObjPtr()));
547 Shared shared() const noexcept
549 return Shared {*this};
553 using IntegerFieldClass = CommonIntegerFieldClass<bt_field_class>;
554 using ConstIntegerFieldClass = CommonIntegerFieldClass<const bt_field_class>;
558 template <typename LibObjT>
559 struct ConstEnumerationFieldClassMappingSpec;
561 // Functions specific to unsigned enumeration field class mappings
563 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_unsigned_mapping>
566 static const bt_integer_range_set_unsigned *
567 ranges(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
569 return bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(libObjPtr);
573 label(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
575 return bt_field_class_enumeration_mapping_get_label(
576 bt_field_class_enumeration_unsigned_mapping_as_mapping_const(libObjPtr));
580 // Functions specific to signed enumeration field class mappings
582 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_signed_mapping> final
584 static const bt_integer_range_set_signed *
585 ranges(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
587 return bt_field_class_enumeration_signed_mapping_borrow_ranges_const(libObjPtr);
591 label(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
593 return bt_field_class_enumeration_mapping_get_label(
594 bt_field_class_enumeration_signed_mapping_as_mapping_const(libObjPtr));
598 } // namespace internal
600 template <typename LibObjT>
601 class ConstEnumerationFieldClassMapping final : public internal::BorrowedObj<LibObjT>
604 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
605 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
606 using _ThisConstEnumerationFieldClassMapping = ConstEnumerationFieldClassMapping<LibObjT>;
609 using RangeSet = typename std::conditional<
610 std::is_same<LibObjT, const bt_field_class_enumeration_unsigned_mapping>::value,
611 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
613 explicit ConstEnumerationFieldClassMapping(const _LibObjPtr libObjPtr) noexcept :
614 _ThisBorrowedObj {libObjPtr}
618 ConstEnumerationFieldClassMapping(
619 const _ThisConstEnumerationFieldClassMapping& mapping) noexcept :
620 _ThisBorrowedObj {mapping}
624 _ThisConstEnumerationFieldClassMapping&
625 operator=(const _ThisConstEnumerationFieldClassMapping& mapping) noexcept
627 _ThisBorrowedObj::operator=(mapping);
631 RangeSet ranges() const noexcept
634 internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->_libObjPtr())};
637 bpstd::string_view label() const noexcept
639 return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->_libObjPtr());
643 using ConstUnsignedEnumerationFieldClassMapping =
644 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_unsigned_mapping>;
646 using ConstSignedEnumerationFieldClassMapping =
647 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>;
651 template <typename MappingT>
652 struct CommonEnumerationFieldClassSpec;
654 // Functions specific to unsigned enumeration field classes
656 struct CommonEnumerationFieldClassSpec<ConstUnsignedEnumerationFieldClassMapping> final
658 static const bt_field_class_enumeration_unsigned_mapping *
659 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
661 return bt_field_class_enumeration_unsigned_borrow_mapping_by_index_const(libObjPtr, index);
664 static const bt_field_class_enumeration_unsigned_mapping *
665 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
667 return bt_field_class_enumeration_unsigned_borrow_mapping_by_label_const(libObjPtr, label);
671 // Functions specific to signed enumeration field classes
673 struct CommonEnumerationFieldClassSpec<ConstSignedEnumerationFieldClassMapping> final
675 static const bt_field_class_enumeration_signed_mapping *
676 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
678 return bt_field_class_enumeration_signed_borrow_mapping_by_index_const(libObjPtr, index);
681 static const bt_field_class_enumeration_signed_mapping *
682 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
684 return bt_field_class_enumeration_signed_borrow_mapping_by_label_const(libObjPtr, label);
688 } // namespace internal
690 template <typename LibObjT, typename MappingT>
691 class CommonEnumerationFieldClass final : public CommonIntegerFieldClass<LibObjT>
694 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
695 using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
696 using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
699 using Shared = internal::SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
700 using Mapping = MappingT;
702 explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
703 _ThisCommonIntegerFieldClass {libObjPtr}
705 BT_ASSERT_DBG(this->isEnumeration());
708 template <typename OtherLibObjT>
709 CommonEnumerationFieldClass(
710 const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept :
711 _ThisCommonIntegerFieldClass {fc}
715 template <typename OtherLibObjT>
716 _ThisCommonEnumerationFieldClass&
717 operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept
719 _ThisCommonIntegerFieldClass::operator=(fc);
723 std::uint64_t size() const noexcept
725 return bt_field_class_enumeration_get_mapping_count(this->_libObjPtr());
728 Mapping operator[](const std::uint64_t index) const noexcept
730 return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
731 this->_libObjPtr(), index)};
734 nonstd::optional<Mapping> operator[](const char * const label) const noexcept
736 const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
737 this->_libObjPtr(), label);
740 return Mapping {libObjPtr};
743 return nonstd::nullopt;
746 nonstd::optional<Mapping> operator[](const std::string& label) const noexcept
748 return (*this)[label.data()];
751 Shared shared() const noexcept
753 return Shared {*this};
757 using UnsignedEnumerationFieldClass =
758 CommonEnumerationFieldClass<bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
760 using ConstUnsignedEnumerationFieldClass =
761 CommonEnumerationFieldClass<const bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
763 using SignedEnumerationFieldClass =
764 CommonEnumerationFieldClass<bt_field_class, ConstSignedEnumerationFieldClassMapping>;
766 using ConstSignedEnumerationFieldClass =
767 CommonEnumerationFieldClass<const bt_field_class, ConstSignedEnumerationFieldClassMapping>;
771 template <typename LibObjT>
772 struct CommonStructureFieldClassMemberSpec;
774 // Functions specific to mutable structure field class members
776 struct CommonStructureFieldClassMemberSpec<bt_field_class_structure_member> final
778 static bt_field_class *fieldClass(bt_field_class_structure_member * const libObjPtr) noexcept
780 return bt_field_class_structure_member_borrow_field_class(libObjPtr);
784 // Functions specific to constant structure field class members
786 struct CommonStructureFieldClassMemberSpec<const bt_field_class_structure_member> final
788 static const bt_field_class *
789 fieldClass(const bt_field_class_structure_member * const libObjPtr) noexcept
791 return bt_field_class_structure_member_borrow_field_class_const(libObjPtr);
795 } // namespace internal
797 template <typename LibObjT>
798 class CommonStructureFieldClassMember final : public internal::BorrowedObj<LibObjT>
801 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
802 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
805 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
808 explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept :
809 _ThisBorrowedObj {libObjPtr}
813 template <typename OtherLibObjT>
814 CommonStructureFieldClassMember(
815 const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept :
816 _ThisBorrowedObj {fc}
820 template <typename OtherLibObjT>
821 CommonStructureFieldClassMember<LibObjT>&
822 operator=(const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept
824 _ThisBorrowedObj::operator=(fc);
828 bpstd::string_view name() const noexcept
830 return bt_field_class_structure_member_get_name(this->_libObjPtr());
833 ConstFieldClass fieldClass() const noexcept
835 return ConstFieldClass {internal::CommonStructureFieldClassMemberSpec<
836 const bt_field_class_structure_member>::fieldClass(this->_libObjPtr())};
839 _FieldClass fieldClass() noexcept
842 internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->_libObjPtr())};
846 using StructureFieldClassMember = CommonStructureFieldClassMember<bt_field_class_structure_member>;
848 using ConstStructureFieldClassMember =
849 CommonStructureFieldClassMember<const bt_field_class_structure_member>;
853 template <typename LibObjT>
854 struct CommonStructureFieldClassSpec;
856 // Functions specific to mutable structure field classes
858 struct CommonStructureFieldClassSpec<bt_field_class> final
860 static bt_field_class_structure_member *memberByIndex(bt_field_class * const libObjPtr,
861 const std::uint64_t index) noexcept
863 return bt_field_class_structure_borrow_member_by_index(libObjPtr, index);
866 static bt_field_class_structure_member *memberByName(bt_field_class * const libObjPtr,
867 const char * const name) noexcept
869 return bt_field_class_structure_borrow_member_by_name(libObjPtr, name);
873 // Functions specific to constant structure field classes
875 struct CommonStructureFieldClassSpec<const bt_field_class> final
877 static const bt_field_class_structure_member *
878 memberByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
880 return bt_field_class_structure_borrow_member_by_index_const(libObjPtr, index);
883 static const bt_field_class_structure_member *
884 memberByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
886 return bt_field_class_structure_borrow_member_by_name_const(libObjPtr, name);
890 } // namespace internal
892 template <typename LibObjT>
893 class CommonStructureFieldClass final : public CommonFieldClass<LibObjT>
896 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
897 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
900 using Shared = internal::SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
903 typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClassMember,
904 StructureFieldClassMember>::type;
906 explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
907 _ThisCommonFieldClass {libObjPtr}
909 BT_ASSERT_DBG(this->isStructure());
912 template <typename OtherLibObjT>
913 CommonStructureFieldClass(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept :
914 _ThisCommonFieldClass {fc}
918 template <typename OtherLibObjT>
919 CommonStructureFieldClass<LibObjT>&
920 operator=(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept
922 _ThisCommonFieldClass::operator=(fc);
926 void appendMember(const char * const name, const FieldClass& fc)
928 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
931 bt_field_class_structure_append_member(this->_libObjPtr(), name, fc._libObjPtr());
933 if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
934 throw LibMemoryError {};
938 void appendMember(const std::string& name, const FieldClass& fc)
940 this->appendMember(name.data(), fc);
943 std::uint64_t size() const noexcept
945 return bt_field_class_structure_get_member_count(this->_libObjPtr());
948 ConstStructureFieldClassMember operator[](const std::uint64_t index) const noexcept
950 return ConstStructureFieldClassMember {
951 internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByIndex(
952 this->_libObjPtr(), index)};
955 Member operator[](const std::uint64_t index) noexcept
957 return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
958 this->_libObjPtr(), index)};
961 nonstd::optional<ConstStructureFieldClassMember>
962 operator[](const char * const name) const noexcept
964 const auto libObjPtr =
965 internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
966 this->_libObjPtr(), name);
969 return ConstStructureFieldClassMember {libObjPtr};
972 return nonstd::nullopt;
975 nonstd::optional<ConstStructureFieldClassMember>
976 operator[](const std::string& name) const noexcept
978 return (*this)[name.data()];
981 nonstd::optional<Member> operator[](const char * const name) noexcept
983 const auto libObjPtr = internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(
984 this->_libObjPtr(), name);
987 return Member {libObjPtr};
990 return nonstd::nullopt;
993 nonstd::optional<Member> operator[](const std::string& name) noexcept
995 return (*this)[name.data()];
998 Shared shared() const noexcept
1000 return Shared {*this};
1004 using StructureFieldClass = CommonStructureFieldClass<bt_field_class>;
1005 using ConstStructureFieldClass = CommonStructureFieldClass<const bt_field_class>;
1007 namespace internal {
1009 template <typename LibObjT>
1010 struct CommonArrayFieldClassSpec;
1012 // Functions specific to mutable array field classes
1014 struct CommonArrayFieldClassSpec<bt_field_class> final
1016 static bt_field_class *elementFieldClass(bt_field_class * const libObjPtr) noexcept
1018 return bt_field_class_array_borrow_element_field_class(libObjPtr);
1022 // Functions specific to constant array field classes
1024 struct CommonArrayFieldClassSpec<const bt_field_class> final
1026 static const bt_field_class *elementFieldClass(const bt_field_class * const libObjPtr) noexcept
1028 return bt_field_class_array_borrow_element_field_class_const(libObjPtr);
1032 } // namespace internal
1034 template <typename LibObjT>
1035 class CommonArrayFieldClass : public CommonFieldClass<LibObjT>
1038 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1041 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1044 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1045 using _ThisCommonArrayFieldClass = CommonArrayFieldClass<LibObjT>;
1048 using Shared = internal::SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
1050 explicit CommonArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1051 _ThisCommonFieldClass {libObjPtr}
1053 BT_ASSERT_DBG(this->isArray());
1056 template <typename OtherLibObjT>
1057 CommonArrayFieldClass(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept :
1058 _ThisCommonFieldClass {fc}
1062 template <typename OtherLibObjT>
1063 _ThisCommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept
1065 _ThisCommonFieldClass::operator=(fc);
1069 ConstFieldClass elementFieldClass() const noexcept
1071 return ConstFieldClass {
1072 internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
1073 this->_libObjPtr())};
1076 _FieldClass elementFieldClass() noexcept
1078 return _FieldClass {
1079 internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->_libObjPtr())};
1082 Shared shared() const noexcept
1084 return Shared {*this};
1088 using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
1089 using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
1091 template <typename LibObjT>
1092 class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
1095 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1096 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1099 using Shared = internal::SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
1101 explicit CommonStaticArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1102 _ThisCommonArrayFieldClass {libObjPtr}
1104 BT_ASSERT_DBG(this->isStaticArray());
1107 template <typename OtherLibObjT>
1108 CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept :
1109 _ThisCommonArrayFieldClass {fc}
1113 template <typename OtherLibObjT>
1114 CommonStaticArrayFieldClass<LibObjT>&
1115 operator=(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept
1117 _ThisCommonArrayFieldClass::operator=(fc);
1121 std::uint64_t length() const noexcept
1123 return bt_field_class_array_static_get_length(this->_libObjPtr());
1126 Shared shared() const noexcept
1128 return Shared {*this};
1132 using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
1133 using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
1135 template <typename LibObjT>
1136 class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
1139 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1140 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1144 internal::SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
1146 explicit CommonDynamicArrayWithLengthFieldClass(const _LibObjPtr libObjPtr) noexcept :
1147 _ThisCommonArrayFieldClass {libObjPtr}
1149 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
1152 template <typename OtherLibObjT>
1153 CommonDynamicArrayWithLengthFieldClass(
1154 const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept :
1155 _ThisCommonArrayFieldClass {fc}
1159 template <typename OtherLibObjT>
1160 CommonDynamicArrayWithLengthFieldClass<LibObjT>&
1161 operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept
1163 _ThisCommonArrayFieldClass::operator=(fc);
1167 ConstFieldPath lengthFieldPath() const noexcept
1169 return ConstFieldPath {
1170 bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
1171 this->_libObjPtr())};
1174 Shared shared() const noexcept
1176 return Shared {*this};
1180 using DynamicArrayWithLengthFieldClass = CommonDynamicArrayWithLengthFieldClass<bt_field_class>;
1182 using ConstDynamicArrayWithLengthFieldClass =
1183 CommonDynamicArrayWithLengthFieldClass<const bt_field_class>;
1185 namespace internal {
1187 template <typename LibObjT>
1188 struct CommonOptionFieldClassSpec;
1190 // Functions specific to mutable option field classes
1192 struct CommonOptionFieldClassSpec<bt_field_class> final
1194 static bt_field_class *fieldClass(bt_field_class * const libObjPtr) noexcept
1196 return bt_field_class_option_borrow_field_class(libObjPtr);
1200 // Functions specific to constant option field classes
1202 struct CommonOptionFieldClassSpec<const bt_field_class> final
1204 static const bt_field_class *fieldClass(const bt_field_class * const libObjPtr) noexcept
1206 return bt_field_class_option_borrow_field_class_const(libObjPtr);
1210 } // namespace internal
1212 template <typename LibObjT>
1213 class CommonOptionFieldClass : public CommonFieldClass<LibObjT>
1216 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1219 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1222 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1223 using _ThisCommonOptionFieldClass = CommonOptionFieldClass<LibObjT>;
1226 using Shared = internal::SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
1228 explicit CommonOptionFieldClass(const _LibObjPtr libObjPtr) noexcept :
1229 _ThisCommonFieldClass {libObjPtr}
1231 BT_ASSERT_DBG(this->isOption());
1234 template <typename OtherLibObjT>
1235 CommonOptionFieldClass(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept :
1236 _ThisCommonFieldClass {fc}
1240 template <typename OtherLibObjT>
1241 _ThisCommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept
1243 _ThisCommonFieldClass::operator=(fc);
1247 ConstFieldClass fieldClass() const noexcept
1249 return ConstFieldClass {
1250 internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
1251 this->_libObjPtr())};
1254 _FieldClass fieldClass() noexcept
1256 return _FieldClass {
1257 internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->_libObjPtr())};
1260 Shared shared() const noexcept
1262 return Shared {*this};
1266 using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
1267 using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
1269 template <typename LibObjT>
1270 class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
1273 using typename CommonOptionFieldClass<LibObjT>::_ThisCommonOptionFieldClass;
1276 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1277 using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<LibObjT>;
1280 using Shared = internal::SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
1282 explicit CommonOptionWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1283 _ThisCommonOptionFieldClass {libObjPtr}
1285 BT_ASSERT_DBG(this->isOptionWithSelector());
1288 template <typename OtherLibObjT>
1289 CommonOptionWithSelectorFieldClass(
1290 const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1291 _ThisCommonOptionFieldClass {fc}
1295 template <typename OtherLibObjT>
1296 _ThisCommonOptionWithSelectorFieldClass&
1297 operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept
1299 _ThisCommonOptionFieldClass::operator=(fc);
1303 ConstFieldPath selectorFieldPath() const noexcept
1305 return ConstFieldPath {
1306 bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
1307 this->_libObjPtr())};
1310 Shared shared() const noexcept
1312 return Shared {*this};
1316 using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
1317 using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
1319 template <typename LibObjT>
1320 class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1323 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1325 using typename CommonOptionWithSelectorFieldClass<
1326 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1330 internal::SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
1332 explicit CommonOptionWithBoolSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1333 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1335 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
1338 template <typename OtherLibObjT>
1339 CommonOptionWithBoolSelectorFieldClass(
1340 const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1341 _ThisCommonOptionWithSelectorFieldClass {fc}
1345 template <typename OtherLibObjT>
1346 CommonOptionWithBoolSelectorFieldClass<LibObjT>&
1347 operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept
1349 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1353 bool selectorIsReversed() const noexcept
1355 return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
1356 this->_libObjPtr());
1359 Shared shared() const noexcept
1361 return Shared {*this};
1365 using OptionWithBoolSelectorFieldClass = CommonOptionWithBoolSelectorFieldClass<bt_field_class>;
1367 using ConstOptionWithBoolSelectorFieldClass =
1368 CommonOptionWithBoolSelectorFieldClass<const bt_field_class>;
1370 namespace internal {
1372 template <typename RangeSetT>
1373 struct CommonOptionWithIntegerSelectorFieldClassSpec;
1375 // Functions specific to option field classes with unsigned integer ranges
1377 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstUnsignedIntegerRangeSet> final
1379 static const bt_integer_range_set_unsigned *
1380 ranges(const bt_field_class * const libObjPtr) noexcept
1382 return bt_field_class_option_with_selector_field_integer_unsigned_borrow_selector_ranges_const(
1387 // Functions specific to option field classes with signed ranges
1389 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstSignedIntegerRangeSet> final
1391 static const bt_integer_range_set_signed *
1392 ranges(const bt_field_class * const libObjPtr) noexcept
1394 return bt_field_class_option_with_selector_field_integer_signed_borrow_selector_ranges_const(
1399 } // namespace internal
1401 template <typename LibObjT, typename RangeSetT>
1402 class CommonOptionWithIntegerSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1405 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1407 using typename CommonOptionWithSelectorFieldClass<
1408 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1410 using _ThisCommonOptionWithIntegerSelectorFieldClass =
1411 CommonOptionWithIntegerSelectorFieldClass<LibObjT, RangeSetT>;
1415 internal::SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
1417 using RangeSet = RangeSetT;
1419 explicit CommonOptionWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1420 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1422 BT_ASSERT_DBG(this->isOptionWithIntegerSelector());
1425 template <typename OtherLibObjT>
1426 CommonOptionWithIntegerSelectorFieldClass(
1427 const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept :
1428 _ThisCommonOptionWithSelectorFieldClass {fc}
1432 template <typename OtherLibObjT>
1433 _ThisCommonOptionWithIntegerSelectorFieldClass&
1434 operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept
1436 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1440 RangeSet ranges() const noexcept
1442 return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
1443 this->_libObjPtr())};
1446 Shared shared() const noexcept
1448 return Shared {*this};
1452 using OptionWithUnsignedIntegerSelectorFieldClass =
1453 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstUnsignedIntegerRangeSet>;
1455 using ConstOptionWithUnsignedIntegerSelectorFieldClass =
1456 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstUnsignedIntegerRangeSet>;
1458 using OptionWithSignedIntegerSelectorFieldClass =
1459 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstSignedIntegerRangeSet>;
1461 using ConstOptionWithSignedIntegerSelectorFieldClass =
1462 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstSignedIntegerRangeSet>;
1464 namespace internal {
1466 template <typename LibObjT>
1467 struct CommonVariantFieldClassOptionSpec;
1469 // Functions specific to mutable variant field class options
1471 struct CommonVariantFieldClassOptionSpec<bt_field_class_variant_option> final
1473 static bt_field_class *fieldClass(bt_field_class_variant_option * const libObjPtr) noexcept
1475 return bt_field_class_variant_option_borrow_field_class(libObjPtr);
1479 // Functions specific to constant variant field class options
1481 struct CommonVariantFieldClassOptionSpec<const bt_field_class_variant_option> final
1483 static const bt_field_class *
1484 fieldClass(const bt_field_class_variant_option * const libObjPtr) noexcept
1486 return bt_field_class_variant_option_borrow_field_class_const(libObjPtr);
1490 } // namespace internal
1492 template <typename LibObjT>
1493 class CommonVariantFieldClassOption : public internal::BorrowedObj<LibObjT>
1496 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
1497 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
1500 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1503 explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1504 _ThisBorrowedObj {libObjPtr}
1508 template <typename OtherLibObjT>
1509 CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept :
1510 _ThisBorrowedObj {fc}
1514 template <typename OtherLibObjT>
1515 CommonVariantFieldClassOption<LibObjT>&
1516 operator=(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept
1518 _ThisBorrowedObj::operator=(fc);
1522 bpstd::string_view name() const noexcept
1524 return bt_field_class_variant_option_get_name(this->_libObjPtr());
1527 ConstFieldClass fieldClass() const noexcept
1529 return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
1530 const bt_field_class_variant_option>::fieldClass(this->_libObjPtr())};
1533 _FieldClass fieldClass() noexcept
1535 return _FieldClass {
1536 internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->_libObjPtr())};
1540 using VariantFieldClassOption = CommonVariantFieldClassOption<bt_field_class_variant_option>;
1542 using ConstVariantFieldClassOption =
1543 CommonVariantFieldClassOption<const bt_field_class_variant_option>;
1545 namespace internal {
1547 template <typename LibObjT>
1548 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
1550 // Functions specific to variant field class options with unsigned integer selector
1552 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1553 const bt_field_class_variant_with_selector_field_integer_unsigned_option>
1556 static const bt_integer_range_set_unsigned *
1557 ranges(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1558 * const libObjPtr) noexcept
1560 return bt_field_class_variant_with_selector_field_integer_unsigned_option_borrow_ranges_const(
1564 static const bt_field_class_variant_option *
1565 asBaseOption(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1566 * const libObjPtr) noexcept
1568 return bt_field_class_variant_with_selector_field_integer_unsigned_option_as_option_const(
1573 // Functions specific to variant field class options with signed integer selector
1575 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1576 const bt_field_class_variant_with_selector_field_integer_signed_option>
1579 static const bt_integer_range_set_signed *
1580 ranges(const bt_field_class_variant_with_selector_field_integer_signed_option
1581 * const libObjPtr) noexcept
1583 return bt_field_class_variant_with_selector_field_integer_signed_option_borrow_ranges_const(
1587 static const bt_field_class_variant_option *
1588 asBaseOption(const bt_field_class_variant_with_selector_field_integer_signed_option
1589 * const libObjPtr) noexcept
1591 return bt_field_class_variant_with_selector_field_integer_signed_option_as_option_const(
1596 } // namespace internal
1598 template <typename LibObjT>
1599 class ConstVariantWithIntegerSelectorFieldClassOption : public internal::BorrowedObj<LibObjT>
1602 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
1603 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
1604 using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
1607 using RangeSet = typename std::conditional<
1610 const bt_field_class_variant_with_selector_field_integer_unsigned_option>::value,
1611 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
1613 explicit ConstVariantWithIntegerSelectorFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1614 _ThisBorrowedObj {libObjPtr}
1618 template <typename OtherLibObjT>
1619 ConstVariantWithIntegerSelectorFieldClassOption(
1620 const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept :
1621 _ThisBorrowedObj {fc}
1625 template <typename OtherLibObjT>
1626 ConstVariantWithIntegerSelectorFieldClassOption<LibObjT>&
1627 operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept
1629 _ThisBorrowedObj::operator=(fc);
1633 ConstVariantFieldClassOption asBaseOption() const noexcept
1635 return ConstVariantFieldClassOption {_Spec::asBaseOption(this->_libObjPtr())};
1638 bpstd::string_view name() const noexcept
1640 return this->asBaseOption().name();
1643 ConstFieldClass fieldClass() const noexcept
1645 return this->asBaseOption().fieldClass();
1648 RangeSet ranges() const noexcept
1650 return RangeSet {_Spec::ranges(this->_libObjPtr())};
1654 using ConstVariantWithUnsignedIntegerSelectorFieldClassOption =
1655 ConstVariantWithIntegerSelectorFieldClassOption<
1656 const bt_field_class_variant_with_selector_field_integer_unsigned_option>;
1658 using ConstVariantWithSignedIntegerSelectorFieldClassOption =
1659 ConstVariantWithIntegerSelectorFieldClassOption<
1660 const bt_field_class_variant_with_selector_field_integer_signed_option>;
1662 namespace internal {
1664 template <typename LibObjT>
1665 struct CommonVariantFieldClassSpec;
1667 // Functions specific to mutable variant field classes
1669 struct CommonVariantFieldClassSpec<bt_field_class> final
1671 static bt_field_class_variant_option *optionByIndex(bt_field_class * const libObjPtr,
1672 const std::uint64_t index) noexcept
1674 return bt_field_class_variant_borrow_option_by_index(libObjPtr, index);
1677 static bt_field_class_variant_option *optionByName(bt_field_class * const libObjPtr,
1678 const char * const name) noexcept
1680 return bt_field_class_variant_borrow_option_by_name(libObjPtr, name);
1684 // Functions specific to constant variant field classes
1686 struct CommonVariantFieldClassSpec<const bt_field_class> final
1688 static const bt_field_class_variant_option *
1689 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1691 return bt_field_class_variant_borrow_option_by_index_const(libObjPtr, index);
1694 static const bt_field_class_variant_option *optionByName(const bt_field_class * const libObjPtr,
1695 const char * const name) noexcept
1697 return bt_field_class_variant_borrow_option_by_name_const(libObjPtr, name);
1701 } // namespace internal
1703 template <typename LibObjT>
1704 class CommonVariantFieldClass : public CommonFieldClass<LibObjT>
1707 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1710 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1711 using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
1714 using Shared = internal::SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
1717 typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
1718 VariantFieldClassOption>::type;
1720 explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
1721 _ThisCommonFieldClass {libObjPtr}
1723 BT_ASSERT_DBG(this->isVariant());
1726 template <typename OtherLibObjT>
1727 CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept :
1728 _ThisCommonFieldClass {fc}
1732 template <typename OtherLibObjT>
1733 _ThisCommonVariantFieldClass&
1734 operator=(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept
1736 _ThisCommonFieldClass::operator=(fc);
1740 std::uint64_t size() const noexcept
1742 return bt_field_class_variant_get_option_count(this->_libObjPtr());
1745 ConstVariantFieldClassOption operator[](const std::uint64_t index) const noexcept
1747 return ConstVariantFieldClassOption {
1748 internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
1749 this->_libObjPtr(), index)};
1752 Option operator[](const std::uint64_t index) noexcept
1754 return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
1755 this->_libObjPtr(), index)};
1758 nonstd::optional<ConstVariantFieldClassOption>
1759 operator[](const char * const name) const noexcept
1761 const auto libObjPtr =
1762 internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
1763 this->_libObjPtr(), name);
1766 return ConstVariantFieldClassOption {libObjPtr};
1769 return nonstd::nullopt;
1772 nonstd::optional<ConstVariantFieldClassOption>
1773 operator[](const std::string& name) const noexcept
1775 return (*this)[name.data()];
1778 nonstd::optional<Option> operator[](const char * const name) noexcept
1780 const auto libObjPtr =
1781 internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->_libObjPtr(), name);
1784 return Option {libObjPtr};
1787 return nonstd::nullopt;
1790 nonstd::optional<Option> operator[](const std::string& name) noexcept
1792 return (*this)[name.data()];
1795 Shared shared() const noexcept
1797 return Shared {*this};
1801 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
1802 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
1804 template <typename LibObjT>
1805 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
1808 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
1809 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1813 internal::SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
1815 explicit CommonVariantWithoutSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1816 _ThisCommonVariantFieldClass {libObjPtr}
1818 BT_ASSERT_DBG(this->isVariantWithoutSelector());
1821 template <typename OtherLibObjT>
1822 CommonVariantWithoutSelectorFieldClass(
1823 const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1824 _ThisCommonVariantFieldClass {fc}
1828 template <typename OtherLibObjT>
1829 CommonVariantWithoutSelectorFieldClass<LibObjT>&
1830 operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept
1832 _ThisCommonVariantFieldClass::operator=(fc);
1836 void appendOption(const char * const name, const FieldClass& fc)
1838 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1840 const auto status = bt_field_class_variant_without_selector_append_option(
1841 this->_libObjPtr(), name, fc._libObjPtr());
1844 BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
1845 throw LibMemoryError {};
1849 void appendOption(const std::string& name, const FieldClass& fc)
1851 this->appendOption(name.data(), fc);
1854 Shared shared() const noexcept
1856 return Shared {*this};
1860 using VariantWithoutSelectorFieldClass = CommonVariantWithoutSelectorFieldClass<bt_field_class>;
1861 using ConstVariantWithoutSelectorFieldClass =
1862 CommonVariantWithoutSelectorFieldClass<const bt_field_class>;
1864 namespace internal {
1866 template <typename OptionT>
1867 struct CommonVariantWithIntegerSelectorFieldClassSpec;
1869 // Functions specific to variant field classes with unsigned integer selector
1871 struct CommonVariantWithIntegerSelectorFieldClassSpec<
1872 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
1875 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
1876 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1878 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_index_const(
1882 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
1883 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1885 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_name_const(
1889 static bt_field_class_variant_with_selector_field_integer_append_option_status
1890 appendOption(bt_field_class * const libObjPtr, const char * const name,
1891 bt_field_class * const libOptFcPtr,
1892 const bt_integer_range_set_unsigned * const libRangesPtr)
1894 return bt_field_class_variant_with_selector_field_integer_unsigned_append_option(
1895 libObjPtr, name, libOptFcPtr, libRangesPtr);
1899 // Functions specific to variant field classes with signed integer selector
1901 struct CommonVariantWithIntegerSelectorFieldClassSpec<
1902 ConstVariantWithSignedIntegerSelectorFieldClassOption>
1905 static const bt_field_class_variant_with_selector_field_integer_signed_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_signed_borrow_option_by_index_const(
1912 static const bt_field_class_variant_with_selector_field_integer_signed_option *
1913 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1915 return bt_field_class_variant_with_selector_field_integer_signed_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_signed * const libRangesPtr)
1924 return bt_field_class_variant_with_selector_field_integer_signed_append_option(
1925 libObjPtr, name, libOptFcPtr, libRangesPtr);
1929 } // namespace internal
1931 template <typename LibObjT, typename OptionT>
1932 class CommonVariantWithIntegerSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
1935 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
1936 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1938 using _ThisCommonVariantWithIntegerSelectorFieldClass =
1939 CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
1941 using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
1945 internal::SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
1947 using Option = OptionT;
1949 explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1950 _ThisCommonVariantFieldClass {libObjPtr}
1952 BT_ASSERT_DBG(this->isVariant());
1955 template <typename OtherLibObjT>
1956 CommonVariantWithIntegerSelectorFieldClass(
1957 const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept :
1958 _ThisCommonVariantFieldClass {fc}
1962 template <typename OtherLibObjT>
1963 _ThisCommonVariantWithIntegerSelectorFieldClass&
1964 operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept
1966 _ThisCommonVariantFieldClass::operator=(fc);
1970 ConstFieldPath selectorFieldPath() const noexcept
1972 return ConstFieldPath {
1973 bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
1974 this->_libObjPtr())};
1977 Option operator[](const std::uint64_t index) const noexcept
1979 return Option {_Spec::optionByIndex(this->_libObjPtr(), index)};
1982 nonstd::optional<Option> operator[](const char * const name) const noexcept
1984 const auto libObjPtr = _Spec::optionByName(this->_libObjPtr(), name);
1987 return Option {libObjPtr};
1990 return nonstd::nullopt;
1993 nonstd::optional<Option> operator[](const std::string& name) const noexcept
1995 return (*this)[name.data()];
1998 void appendOption(const char * const name, const FieldClass& fc,
1999 const typename Option::RangeSet& ranges)
2001 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
2004 _Spec::appendOption(this->_libObjPtr(), name, fc._libObjPtr(), ranges._libObjPtr());
2007 BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2008 throw LibMemoryError {};
2012 void appendOption(const std::string& name, const FieldClass& fc)
2014 this->appendOption(name.data(), fc);
2017 Shared shared() const noexcept
2019 return Shared {*this};
2023 using VariantWithUnsignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2024 bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2026 using ConstVariantWithUnsignedIntegerSelectorFieldClass =
2027 CommonVariantWithIntegerSelectorFieldClass<
2028 const bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2030 using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2031 bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2033 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2034 const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2036 template <typename LibObjT>
2037 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
2039 BT_ASSERT_DBG(this->isBitArray());
2040 return CommonBitArrayFieldClass<LibObjT> {this->_libObjPtr()};
2043 template <typename LibObjT>
2044 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
2046 BT_ASSERT_DBG(this->isInteger());
2047 return CommonIntegerFieldClass<LibObjT> {this->_libObjPtr()};
2050 template <typename LibObjT>
2051 CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping>
2052 CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
2054 BT_ASSERT_DBG(this->isUnsignedEnumeration());
2055 return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
2056 this->_libObjPtr()};
2059 template <typename LibObjT>
2060 CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping>
2061 CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
2063 BT_ASSERT_DBG(this->isSignedEnumeration());
2064 return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
2065 this->_libObjPtr()};
2068 template <typename LibObjT>
2069 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
2071 BT_ASSERT_DBG(this->isStructure());
2072 return CommonStructureFieldClass<LibObjT> {this->_libObjPtr()};
2075 template <typename LibObjT>
2076 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
2078 BT_ASSERT_DBG(this->isArray());
2079 return CommonArrayFieldClass<LibObjT> {this->_libObjPtr()};
2082 template <typename LibObjT>
2083 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
2085 BT_ASSERT_DBG(this->isStaticArray());
2086 return CommonStaticArrayFieldClass<LibObjT> {this->_libObjPtr()};
2089 template <typename LibObjT>
2090 CommonDynamicArrayWithLengthFieldClass<LibObjT>
2091 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
2093 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
2094 return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->_libObjPtr()};
2097 template <typename LibObjT>
2098 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
2100 BT_ASSERT_DBG(this->isOption());
2101 return CommonOptionFieldClass<LibObjT> {this->_libObjPtr()};
2104 template <typename LibObjT>
2105 CommonOptionWithSelectorFieldClass<LibObjT>
2106 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
2108 BT_ASSERT_DBG(this->isOptionWithSelector());
2109 return CommonOptionWithSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2112 template <typename LibObjT>
2113 CommonOptionWithBoolSelectorFieldClass<LibObjT>
2114 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
2116 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
2117 return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2120 template <typename LibObjT>
2121 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
2122 CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
2124 BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
2125 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
2126 this->_libObjPtr()};
2129 template <typename LibObjT>
2130 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
2131 CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
2133 BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
2134 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
2135 this->_libObjPtr()};
2138 template <typename LibObjT>
2139 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
2141 BT_ASSERT_DBG(this->isVariant());
2142 return CommonVariantFieldClass<LibObjT> {this->_libObjPtr()};
2145 template <typename LibObjT>
2146 CommonVariantWithoutSelectorFieldClass<LibObjT>
2147 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
2149 BT_ASSERT_DBG(this->isVariantWithoutSelector());
2150 return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2153 template <typename LibObjT>
2154 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2155 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2156 CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
2158 BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
2159 return CommonVariantWithIntegerSelectorFieldClass<
2160 LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
2163 template <typename LibObjT>
2164 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2165 ConstVariantWithSignedIntegerSelectorFieldClassOption>
2166 CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
2168 BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
2169 return CommonVariantWithIntegerSelectorFieldClass<
2170 LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
2175 #endif // BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP