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"
28 struct FieldClassRefFuncs final
30 static void get(const bt_field_class * const libObjPtr)
32 bt_field_class_get_ref(libObjPtr);
35 static void put(const bt_field_class * const libObjPtr)
37 bt_field_class_put_ref(libObjPtr);
41 template <typename ObjT, typename LibObjT>
42 using SharedFieldClass = internal::SharedObj<ObjT, LibObjT, internal::FieldClassRefFuncs>;
44 template <typename LibObjT>
45 struct CommonFieldClassSpec;
47 /* Functions specific to mutable field classes */
49 struct CommonFieldClassSpec<bt_field_class> final
51 static bt_value *userAttributes(bt_field_class * const libObjPtr) noexcept
53 return bt_field_class_borrow_user_attributes(libObjPtr);
57 /* Functions specific to constant field classes */
59 struct CommonFieldClassSpec<const bt_field_class> final
61 static const bt_value *userAttributes(const bt_field_class * const libObjPtr) noexcept
63 return bt_field_class_borrow_user_attributes_const(libObjPtr);
67 } /* namespace internal */
69 template <typename LibObjT>
70 class CommonBitArrayFieldClass;
72 template <typename LibObjT>
73 class CommonIntegerFieldClass;
75 template <typename LibObjT>
76 class ConstEnumerationFieldClassMapping;
78 template <typename LibObjT, typename MappingT>
79 class CommonEnumerationFieldClass;
81 template <typename LibObjT>
82 class CommonStructureFieldClass;
84 template <typename LibObjT>
85 class CommonArrayFieldClass;
87 template <typename LibObjT>
88 class CommonStaticArrayFieldClass;
90 template <typename LibObjT>
91 class CommonDynamicArrayWithLengthFieldClass;
93 template <typename LibObjT>
94 class CommonOptionFieldClass;
96 template <typename LibObjT>
97 class CommonOptionWithSelectorFieldClass;
99 template <typename LibObjT>
100 class CommonOptionWithBoolSelectorFieldClass;
102 template <typename LibObjT>
103 class CommonVariantFieldClass;
105 template <typename LibObjT, typename RangeSetT>
106 class CommonOptionWithIntegerSelectorFieldClass;
108 template <typename LibObjT>
109 class CommonVariantWithoutSelectorFieldClass;
111 template <typename LibObjT>
112 class ConstVariantWithIntegerSelectorFieldClassOption;
114 template <typename LibObjT, typename RangeSetT>
115 class CommonVariantWithIntegerSelectorFieldClass;
117 template <typename LibObjT>
118 class CommonEventClass;
120 template <typename LibObjT>
121 class CommonStreamClass;
123 template <typename LibObjT>
124 class CommonTraceClass;
126 enum class FieldClassType
128 BOOL = BT_FIELD_CLASS_TYPE_BOOL,
129 BIT_ARRAY = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
130 UNSIGNED_INTEGER = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER,
131 SIGNED_INTEGER = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER,
132 UNSIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
133 SIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
134 SINGLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL,
135 DOUBLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL,
136 STRING = BT_FIELD_CLASS_TYPE_STRING,
137 STRUCTURE = BT_FIELD_CLASS_TYPE_STRUCTURE,
138 STATIC_ARRAY = BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
139 DYNAMIC_ARRAY_WITHOUT_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD,
140 DYNAMIC_ARRAY_WITH_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD,
141 OPTION_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD,
142 OPTION_WITH_BOOL_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD,
143 OPTION_WITH_UNSIGNED_INTEGER_SELECTOR =
144 BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
145 OPTION_WITH_SIGNED_INTEGER_SELECTOR =
146 BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
147 VARIANT_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD,
148 VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR =
149 BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
150 VARIANT_WITH_SIGNED_INTEGER_SELECTOR =
151 BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
154 template <typename LibObjT>
155 class CommonFieldClass : public internal::BorrowedObj<LibObjT>
157 /* Allow appendMember() to call `fc._libObjPtr()` */
158 friend class CommonStructureFieldClass<bt_field_class>;
160 /* Allow appendOption() to call `fc._libObjPtr()` */
161 friend class CommonVariantWithoutSelectorFieldClass<bt_field_class>;
163 friend class CommonVariantWithIntegerSelectorFieldClass<
165 ConstVariantWithIntegerSelectorFieldClassOption<
166 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>;
168 friend class CommonVariantWithIntegerSelectorFieldClass<
170 ConstVariantWithIntegerSelectorFieldClassOption<
171 const bt_field_class_variant_with_selector_field_integer_signed_option>>;
173 /* Allow *FieldClass() to call `fc._libObjPtr()` */
174 friend class CommonEventClass<bt_event_class>;
175 friend class CommonStreamClass<bt_stream_class>;
177 /* Allow create*FieldClass() to call `fc._libObjPtr()` */
178 friend class CommonTraceClass<bt_trace_class>;
181 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
184 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
185 using _ThisCommonFieldClass = CommonFieldClass<LibObjT>;
188 using Shared = internal::SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
190 using UserAttributes =
191 typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
193 explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
197 template <typename OtherLibObjT>
198 CommonFieldClass(const CommonFieldClass<OtherLibObjT>& fc) noexcept : _ThisBorrowedObj {fc}
202 template <typename OtherLibObjT>
203 _ThisCommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT>& fc) noexcept
205 _ThisBorrowedObj::operator=(fc);
209 FieldClassType type() const noexcept
211 return static_cast<FieldClassType>(bt_field_class_get_type(this->_libObjPtr()));
214 bool isBool() const noexcept
216 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BOOL);
219 bool isBitArray() const noexcept
221 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BIT_ARRAY);
224 bool isInteger() const noexcept
226 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_INTEGER);
229 bool isUnsignedInteger() const noexcept
231 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
234 bool isSignedInteger() const noexcept
236 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
239 bool isEnumeration() const noexcept
241 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ENUMERATION);
244 bool isUnsignedEnumeration() const noexcept
246 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
249 bool isSignedEnumeration() const noexcept
251 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
254 bool isReal() const noexcept
256 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_REAL);
259 bool isSinglePrecisionReal() const noexcept
261 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL);
264 bool isDoublePrecisionReal() const noexcept
266 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL);
269 bool isString() const noexcept
271 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRING);
274 bool isStructure() const noexcept
276 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRUCTURE);
279 bool isArray() const noexcept
281 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ARRAY);
284 bool isStaticArray() const noexcept
286 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STATIC_ARRAY);
289 bool isDynamicArray() const noexcept
291 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY);
294 bool isDynamicArrayWithoutLength() const noexcept
296 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD);
299 bool isDynamicArrayWithLength() const noexcept
301 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
304 bool isOption() const noexcept
306 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION);
309 bool isOptionWithoutSelector() const noexcept
311 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD);
314 bool isOptionWithSelector() const noexcept
316 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD);
319 bool isOptionWithBoolSelector() const noexcept
321 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD);
324 bool isOptionWithIntegerSelector() const noexcept
326 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_INTEGER_SELECTOR_FIELD);
329 bool isOptionWithUnsignedIntegerSelector() const noexcept
331 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
334 bool isOptionWithSignedIntegerSelector() const noexcept
336 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
339 bool isVariant() const noexcept
341 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT);
344 bool isVariantWithoutSelector() const noexcept
346 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD);
349 bool isVariantWithSelector() const noexcept
351 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD);
354 bool isVariantWithIntegerSelector() const noexcept
356 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_INTEGER_SELECTOR_FIELD);
359 bool isVariantWithUnsignedIntegerSelector() const noexcept
361 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
364 bool isVariantWithSignedIntegerSelector() const noexcept
366 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
369 CommonBitArrayFieldClass<LibObjT> asBitArray() const noexcept;
370 CommonIntegerFieldClass<LibObjT> asInteger() const noexcept;
372 CommonEnumerationFieldClass<LibObjT, ConstEnumerationFieldClassMapping<
373 const bt_field_class_enumeration_unsigned_mapping>>
374 asUnsignedEnumeration() const noexcept;
376 CommonEnumerationFieldClass<
377 LibObjT, ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>>
378 asSignedEnumeration() const noexcept;
380 CommonStructureFieldClass<LibObjT> asStructure() const noexcept;
381 CommonArrayFieldClass<LibObjT> asArray() const noexcept;
382 CommonStaticArrayFieldClass<LibObjT> asStaticArray() const noexcept;
383 CommonDynamicArrayWithLengthFieldClass<LibObjT> asDynamicArrayWithLength() const noexcept;
384 CommonOptionFieldClass<LibObjT> asOption() const noexcept;
385 CommonOptionWithSelectorFieldClass<LibObjT> asOptionWithSelector() const noexcept;
386 CommonOptionWithBoolSelectorFieldClass<LibObjT> asOptionWithBoolSelector() const noexcept;
388 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
389 asOptionWithUnsignedIntegerSelector() const noexcept;
391 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
392 asOptionWithSignedIntegerSelector() const noexcept;
394 CommonVariantFieldClass<LibObjT> asVariant() const noexcept;
395 CommonVariantWithoutSelectorFieldClass<LibObjT> asVariantWithoutSelector() const noexcept;
397 CommonVariantWithIntegerSelectorFieldClass<
398 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
399 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>
400 asVariantWithUnsignedIntegerSelector() const noexcept;
402 CommonVariantWithIntegerSelectorFieldClass<
403 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
404 const bt_field_class_variant_with_selector_field_integer_signed_option>>
405 asVariantWithSignedIntegerSelector() const noexcept;
407 template <typename LibValT>
408 void userAttributes(const CommonMapValue<LibValT>& userAttrs)
410 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
412 bt_field_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
415 ConstMapValue userAttributes() const noexcept
417 return ConstMapValue {internal::CommonFieldClassSpec<const bt_field_class>::userAttributes(
418 this->_libObjPtr())};
421 UserAttributes userAttributes() noexcept
423 return UserAttributes {
424 internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->_libObjPtr())};
427 Shared shared() const noexcept
429 return Shared {*this};
433 bool _libTypeIs(const bt_field_class_type type) const noexcept
435 return bt_field_class_type_is(bt_field_class_get_type(this->_libObjPtr()), type);
439 using FieldClass = CommonFieldClass<bt_field_class>;
440 using ConstFieldClass = CommonFieldClass<const bt_field_class>;
442 template <typename LibObjT>
443 class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
446 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
447 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
450 using Shared = internal::SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
452 explicit CommonBitArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
453 _ThisCommonFieldClass {libObjPtr}
455 BT_ASSERT_DBG(this->isBitArray());
458 template <typename OtherLibObjT>
459 CommonBitArrayFieldClass(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept :
460 _ThisCommonFieldClass {fc}
464 template <typename OtherLibObjT>
465 CommonBitArrayFieldClass<LibObjT>&
466 operator=(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept
468 _ThisCommonFieldClass::operator=(fc);
472 std::uint64_t length() const noexcept
474 return bt_field_class_bit_array_get_length(this->_libObjPtr());
477 Shared shared() const noexcept
479 return Shared {*this};
483 using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
484 using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
486 enum class DisplayBase
488 BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
489 OCTAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL,
490 DECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL,
491 HEXADECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL,
494 template <typename LibObjT>
495 class CommonIntegerFieldClass : public CommonFieldClass<LibObjT>
498 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
501 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
502 using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass<LibObjT>;
505 using Shared = internal::SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
507 explicit CommonIntegerFieldClass(const _LibObjPtr libObjPtr) noexcept :
508 _ThisCommonFieldClass {libObjPtr}
510 BT_ASSERT_DBG(this->isInteger());
513 template <typename OtherLibObjT>
514 CommonIntegerFieldClass(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept :
515 _ThisCommonFieldClass {fc}
519 template <typename OtherLibObjT>
520 _ThisCommonIntegerFieldClass&
521 operator=(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept
523 _ThisCommonFieldClass::operator=(fc);
527 void fieldValueRange(const std::uint64_t n) noexcept
529 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
531 bt_field_class_integer_get_field_value_range(this->_libObjPtr(), n);
534 std::uint64_t fieldValueRange() const noexcept
536 return bt_field_class_integer_get_field_value_range(this->_libObjPtr());
539 void preferredDisplayBase(const DisplayBase base) noexcept
541 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
543 bt_field_class_integer_set_preferred_display_base(
544 this->_libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
547 DisplayBase preferredDisplayBase() const noexcept
549 return static_cast<DisplayBase>(
550 bt_field_class_integer_get_preferred_display_base(this->_libObjPtr()));
553 Shared shared() const noexcept
555 return Shared {*this};
559 using IntegerFieldClass = CommonIntegerFieldClass<bt_field_class>;
560 using ConstIntegerFieldClass = CommonIntegerFieldClass<const bt_field_class>;
564 template <typename LibObjT>
565 struct ConstEnumerationFieldClassMappingSpec;
567 /* Functions specific to unsigned enumeration field class mappings */
569 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_unsigned_mapping>
572 static const bt_integer_range_set_unsigned *
573 ranges(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
575 return bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(libObjPtr);
579 label(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
581 return bt_field_class_enumeration_mapping_get_label(
582 bt_field_class_enumeration_unsigned_mapping_as_mapping_const(libObjPtr));
586 /* Functions specific to signed enumeration field class mappings */
588 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_signed_mapping> final
590 static const bt_integer_range_set_signed *
591 ranges(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
593 return bt_field_class_enumeration_signed_mapping_borrow_ranges_const(libObjPtr);
597 label(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
599 return bt_field_class_enumeration_mapping_get_label(
600 bt_field_class_enumeration_signed_mapping_as_mapping_const(libObjPtr));
604 } /* namespace internal */
606 template <typename LibObjT>
607 class ConstEnumerationFieldClassMapping final : public internal::BorrowedObj<LibObjT>
610 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
611 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
612 using _ThisConstEnumerationFieldClassMapping = ConstEnumerationFieldClassMapping<LibObjT>;
615 using RangeSet = typename std::conditional<
616 std::is_same<LibObjT, const bt_field_class_enumeration_unsigned_mapping>::value,
617 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
619 explicit ConstEnumerationFieldClassMapping(const _LibObjPtr libObjPtr) noexcept :
620 _ThisBorrowedObj {libObjPtr}
624 ConstEnumerationFieldClassMapping(
625 const _ThisConstEnumerationFieldClassMapping& mapping) noexcept :
626 _ThisBorrowedObj {mapping}
630 _ThisConstEnumerationFieldClassMapping&
631 operator=(const _ThisConstEnumerationFieldClassMapping& mapping) noexcept
633 _ThisBorrowedObj::operator=(mapping);
637 RangeSet ranges() const noexcept
640 internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->_libObjPtr())};
643 bpstd::string_view label() const noexcept
645 return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->_libObjPtr());
649 using ConstUnsignedEnumerationFieldClassMapping =
650 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_unsigned_mapping>;
652 using ConstSignedEnumerationFieldClassMapping =
653 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>;
657 template <typename MappingT>
658 struct CommonEnumerationFieldClassSpec;
660 /* Functions specific to unsigned enumeration field classes */
662 struct CommonEnumerationFieldClassSpec<ConstUnsignedEnumerationFieldClassMapping> final
664 static const bt_field_class_enumeration_unsigned_mapping *
665 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
667 return bt_field_class_enumeration_unsigned_borrow_mapping_by_index_const(libObjPtr, index);
670 static const bt_field_class_enumeration_unsigned_mapping *
671 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
673 return bt_field_class_enumeration_unsigned_borrow_mapping_by_label_const(libObjPtr, label);
677 /* Functions specific to signed enumeration field classes */
679 struct CommonEnumerationFieldClassSpec<ConstSignedEnumerationFieldClassMapping> final
681 static const bt_field_class_enumeration_signed_mapping *
682 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
684 return bt_field_class_enumeration_signed_borrow_mapping_by_index_const(libObjPtr, index);
687 static const bt_field_class_enumeration_signed_mapping *
688 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
690 return bt_field_class_enumeration_signed_borrow_mapping_by_label_const(libObjPtr, label);
694 } /* namespace internal */
696 template <typename LibObjT, typename MappingT>
697 class CommonEnumerationFieldClass final : public CommonIntegerFieldClass<LibObjT>
700 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
701 using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
702 using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
705 using Shared = internal::SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
706 using Mapping = MappingT;
708 explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
709 _ThisCommonIntegerFieldClass {libObjPtr}
711 BT_ASSERT_DBG(this->isEnumeration());
714 template <typename OtherLibObjT>
715 CommonEnumerationFieldClass(
716 const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept :
717 _ThisCommonIntegerFieldClass {fc}
721 template <typename OtherLibObjT>
722 _ThisCommonEnumerationFieldClass&
723 operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept
725 _ThisCommonIntegerFieldClass::operator=(fc);
729 std::uint64_t size() const noexcept
731 return bt_field_class_enumeration_get_mapping_count(this->_libObjPtr());
734 Mapping operator[](const std::uint64_t index) const noexcept
736 return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
737 this->_libObjPtr(), index)};
740 nonstd::optional<Mapping> operator[](const char * const label) const noexcept
742 const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
743 this->_libObjPtr(), label);
746 return Mapping {libObjPtr};
749 return nonstd::nullopt;
752 nonstd::optional<Mapping> operator[](const std::string& label) const noexcept
754 return (*this)[label.data()];
757 Shared shared() const noexcept
759 return Shared {*this};
763 using UnsignedEnumerationFieldClass =
764 CommonEnumerationFieldClass<bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
766 using ConstUnsignedEnumerationFieldClass =
767 CommonEnumerationFieldClass<const bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
769 using SignedEnumerationFieldClass =
770 CommonEnumerationFieldClass<bt_field_class, ConstSignedEnumerationFieldClassMapping>;
772 using ConstSignedEnumerationFieldClass =
773 CommonEnumerationFieldClass<const bt_field_class, ConstSignedEnumerationFieldClassMapping>;
777 template <typename LibObjT>
778 struct CommonStructureFieldClassMemberSpec;
780 /* Functions specific to mutable structure field class members */
782 struct CommonStructureFieldClassMemberSpec<bt_field_class_structure_member> final
784 static bt_field_class *fieldClass(bt_field_class_structure_member * const libObjPtr) noexcept
786 return bt_field_class_structure_member_borrow_field_class(libObjPtr);
790 /* Functions specific to constant structure field class members */
792 struct CommonStructureFieldClassMemberSpec<const bt_field_class_structure_member> final
794 static const bt_field_class *
795 fieldClass(const bt_field_class_structure_member * const libObjPtr) noexcept
797 return bt_field_class_structure_member_borrow_field_class_const(libObjPtr);
801 } /* namespace internal */
803 template <typename LibObjT>
804 class CommonStructureFieldClassMember final : public internal::BorrowedObj<LibObjT>
807 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
808 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
811 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
814 explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept :
815 _ThisBorrowedObj {libObjPtr}
819 template <typename OtherLibObjT>
820 CommonStructureFieldClassMember(
821 const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept :
822 _ThisBorrowedObj {fc}
826 template <typename OtherLibObjT>
827 CommonStructureFieldClassMember<LibObjT>&
828 operator=(const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept
830 _ThisBorrowedObj::operator=(fc);
834 bpstd::string_view name() const noexcept
836 return bt_field_class_structure_member_get_name(this->_libObjPtr());
839 ConstFieldClass fieldClass() const noexcept
841 return ConstFieldClass {internal::CommonStructureFieldClassMemberSpec<
842 const bt_field_class_structure_member>::fieldClass(this->_libObjPtr())};
845 _FieldClass fieldClass() noexcept
848 internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->_libObjPtr())};
852 using StructureFieldClassMember = CommonStructureFieldClassMember<bt_field_class_structure_member>;
854 using ConstStructureFieldClassMember =
855 CommonStructureFieldClassMember<const bt_field_class_structure_member>;
859 template <typename LibObjT>
860 struct CommonStructureFieldClassSpec;
862 /* Functions specific to mutable structure field classes */
864 struct CommonStructureFieldClassSpec<bt_field_class> final
866 static bt_field_class_structure_member *memberByIndex(bt_field_class * const libObjPtr,
867 const std::uint64_t index) noexcept
869 return bt_field_class_structure_borrow_member_by_index(libObjPtr, index);
872 static bt_field_class_structure_member *memberByName(bt_field_class * const libObjPtr,
873 const char * const name) noexcept
875 return bt_field_class_structure_borrow_member_by_name(libObjPtr, name);
879 /* Functions specific to constant structure field classes */
881 struct CommonStructureFieldClassSpec<const bt_field_class> final
883 static const bt_field_class_structure_member *
884 memberByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
886 return bt_field_class_structure_borrow_member_by_index_const(libObjPtr, index);
889 static const bt_field_class_structure_member *
890 memberByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
892 return bt_field_class_structure_borrow_member_by_name_const(libObjPtr, name);
896 } /* namespace internal */
898 template <typename LibObjT>
899 class CommonStructureFieldClass final : public CommonFieldClass<LibObjT>
902 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
903 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
906 using Shared = internal::SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
909 typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClassMember,
910 StructureFieldClassMember>::type;
912 explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
913 _ThisCommonFieldClass {libObjPtr}
915 BT_ASSERT_DBG(this->isStructure());
918 template <typename OtherLibObjT>
919 CommonStructureFieldClass(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept :
920 _ThisCommonFieldClass {fc}
924 template <typename OtherLibObjT>
925 CommonStructureFieldClass<LibObjT>&
926 operator=(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept
928 _ThisCommonFieldClass::operator=(fc);
932 void appendMember(const char * const name, const FieldClass& fc)
934 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
937 bt_field_class_structure_append_member(this->_libObjPtr(), name, fc._libObjPtr());
939 if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
940 throw LibMemoryError {};
944 void appendMember(const std::string& name, const FieldClass& fc)
946 this->appendMember(name.data(), fc);
949 std::uint64_t size() const noexcept
951 return bt_field_class_structure_get_member_count(this->_libObjPtr());
954 ConstStructureFieldClassMember operator[](const std::uint64_t index) const noexcept
956 return ConstStructureFieldClassMember {
957 internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByIndex(
958 this->_libObjPtr(), index)};
961 Member operator[](const std::uint64_t index) noexcept
963 return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
964 this->_libObjPtr(), index)};
967 nonstd::optional<ConstStructureFieldClassMember>
968 operator[](const char * const name) const noexcept
970 const auto libObjPtr =
971 internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
972 this->_libObjPtr(), name);
975 return ConstStructureFieldClassMember {libObjPtr};
978 return nonstd::nullopt;
981 nonstd::optional<ConstStructureFieldClassMember>
982 operator[](const std::string& name) const noexcept
984 return (*this)[name.data()];
987 nonstd::optional<Member> operator[](const char * const name) noexcept
989 const auto libObjPtr = internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(
990 this->_libObjPtr(), name);
993 return Member {libObjPtr};
996 return nonstd::nullopt;
999 nonstd::optional<Member> operator[](const std::string& name) noexcept
1001 return (*this)[name.data()];
1004 Shared shared() const noexcept
1006 return Shared {*this};
1010 using StructureFieldClass = CommonStructureFieldClass<bt_field_class>;
1011 using ConstStructureFieldClass = CommonStructureFieldClass<const bt_field_class>;
1013 namespace internal {
1015 template <typename LibObjT>
1016 struct CommonArrayFieldClassSpec;
1018 /* Functions specific to mutable array field classes */
1020 struct CommonArrayFieldClassSpec<bt_field_class> final
1022 static bt_field_class *elementFieldClass(bt_field_class * const libObjPtr) noexcept
1024 return bt_field_class_array_borrow_element_field_class(libObjPtr);
1028 /* Functions specific to constant array field classes */
1030 struct CommonArrayFieldClassSpec<const bt_field_class> final
1032 static const bt_field_class *elementFieldClass(const bt_field_class * const libObjPtr) noexcept
1034 return bt_field_class_array_borrow_element_field_class_const(libObjPtr);
1038 } /* namespace internal */
1040 template <typename LibObjT>
1041 class CommonArrayFieldClass : public CommonFieldClass<LibObjT>
1044 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1047 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1050 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1051 using _ThisCommonArrayFieldClass = CommonArrayFieldClass<LibObjT>;
1054 using Shared = internal::SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
1056 explicit CommonArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1057 _ThisCommonFieldClass {libObjPtr}
1059 BT_ASSERT_DBG(this->isArray());
1062 template <typename OtherLibObjT>
1063 CommonArrayFieldClass(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept :
1064 _ThisCommonFieldClass {fc}
1068 template <typename OtherLibObjT>
1069 _ThisCommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept
1071 _ThisCommonFieldClass::operator=(fc);
1075 ConstFieldClass elementFieldClass() const noexcept
1077 return ConstFieldClass {
1078 internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
1079 this->_libObjPtr())};
1082 _FieldClass elementFieldClass() noexcept
1084 return _FieldClass {
1085 internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->_libObjPtr())};
1088 Shared shared() const noexcept
1090 return Shared {*this};
1094 using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
1095 using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
1097 template <typename LibObjT>
1098 class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
1101 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1102 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1105 using Shared = internal::SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
1107 explicit CommonStaticArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1108 _ThisCommonArrayFieldClass {libObjPtr}
1110 BT_ASSERT_DBG(this->isStaticArray());
1113 template <typename OtherLibObjT>
1114 CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept :
1115 _ThisCommonArrayFieldClass {fc}
1119 template <typename OtherLibObjT>
1120 CommonStaticArrayFieldClass<LibObjT>&
1121 operator=(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept
1123 _ThisCommonArrayFieldClass::operator=(fc);
1127 std::uint64_t length() const noexcept
1129 return bt_field_class_array_static_get_length(this->_libObjPtr());
1132 Shared shared() const noexcept
1134 return Shared {*this};
1138 using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
1139 using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
1141 template <typename LibObjT>
1142 class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
1145 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1146 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1150 internal::SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
1152 explicit CommonDynamicArrayWithLengthFieldClass(const _LibObjPtr libObjPtr) noexcept :
1153 _ThisCommonArrayFieldClass {libObjPtr}
1155 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
1158 template <typename OtherLibObjT>
1159 CommonDynamicArrayWithLengthFieldClass(
1160 const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept :
1161 _ThisCommonArrayFieldClass {fc}
1165 template <typename OtherLibObjT>
1166 CommonDynamicArrayWithLengthFieldClass<LibObjT>&
1167 operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept
1169 _ThisCommonArrayFieldClass::operator=(fc);
1173 ConstFieldPath lengthFieldPath() const noexcept
1175 return ConstFieldPath {
1176 bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
1177 this->_libObjPtr())};
1180 Shared shared() const noexcept
1182 return Shared {*this};
1186 using DynamicArrayWithLengthFieldClass = CommonDynamicArrayWithLengthFieldClass<bt_field_class>;
1188 using ConstDynamicArrayWithLengthFieldClass =
1189 CommonDynamicArrayWithLengthFieldClass<const bt_field_class>;
1191 namespace internal {
1193 template <typename LibObjT>
1194 struct CommonOptionFieldClassSpec;
1196 /* Functions specific to mutable option field classes */
1198 struct CommonOptionFieldClassSpec<bt_field_class> final
1200 static bt_field_class *fieldClass(bt_field_class * const libObjPtr) noexcept
1202 return bt_field_class_option_borrow_field_class(libObjPtr);
1206 /* Functions specific to constant option field classes */
1208 struct CommonOptionFieldClassSpec<const bt_field_class> final
1210 static const bt_field_class *fieldClass(const bt_field_class * const libObjPtr) noexcept
1212 return bt_field_class_option_borrow_field_class_const(libObjPtr);
1216 } /* namespace internal */
1218 template <typename LibObjT>
1219 class CommonOptionFieldClass : public CommonFieldClass<LibObjT>
1222 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1225 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1228 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1229 using _ThisCommonOptionFieldClass = CommonOptionFieldClass<LibObjT>;
1232 using Shared = internal::SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
1234 explicit CommonOptionFieldClass(const _LibObjPtr libObjPtr) noexcept :
1235 _ThisCommonFieldClass {libObjPtr}
1237 BT_ASSERT_DBG(this->isOption());
1240 template <typename OtherLibObjT>
1241 CommonOptionFieldClass(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept :
1242 _ThisCommonFieldClass {fc}
1246 template <typename OtherLibObjT>
1247 _ThisCommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept
1249 _ThisCommonFieldClass::operator=(fc);
1253 ConstFieldClass fieldClass() const noexcept
1255 return ConstFieldClass {
1256 internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
1257 this->_libObjPtr())};
1260 _FieldClass fieldClass() noexcept
1262 return _FieldClass {
1263 internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->_libObjPtr())};
1266 Shared shared() const noexcept
1268 return Shared {*this};
1272 using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
1273 using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
1275 template <typename LibObjT>
1276 class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
1279 using typename CommonOptionFieldClass<LibObjT>::_ThisCommonOptionFieldClass;
1282 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1283 using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<LibObjT>;
1286 using Shared = internal::SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
1288 explicit CommonOptionWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1289 _ThisCommonOptionFieldClass {libObjPtr}
1291 BT_ASSERT_DBG(this->isOptionWithSelector());
1294 template <typename OtherLibObjT>
1295 CommonOptionWithSelectorFieldClass(
1296 const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1297 _ThisCommonOptionFieldClass {fc}
1301 template <typename OtherLibObjT>
1302 _ThisCommonOptionWithSelectorFieldClass&
1303 operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept
1305 _ThisCommonOptionFieldClass::operator=(fc);
1309 ConstFieldPath selectorFieldPath() const noexcept
1311 return ConstFieldPath {
1312 bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
1313 this->_libObjPtr())};
1316 Shared shared() const noexcept
1318 return Shared {*this};
1322 using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
1323 using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
1325 template <typename LibObjT>
1326 class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1329 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1331 using typename CommonOptionWithSelectorFieldClass<
1332 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1336 internal::SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
1338 explicit CommonOptionWithBoolSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1339 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1341 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
1344 template <typename OtherLibObjT>
1345 CommonOptionWithBoolSelectorFieldClass(
1346 const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1347 _ThisCommonOptionWithSelectorFieldClass {fc}
1351 template <typename OtherLibObjT>
1352 CommonOptionWithBoolSelectorFieldClass<LibObjT>&
1353 operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept
1355 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1359 bool selectorIsReversed() const noexcept
1361 return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
1362 this->_libObjPtr());
1365 Shared shared() const noexcept
1367 return Shared {*this};
1371 using OptionWithBoolSelectorFieldClass = CommonOptionWithBoolSelectorFieldClass<bt_field_class>;
1373 using ConstOptionWithBoolSelectorFieldClass =
1374 CommonOptionWithBoolSelectorFieldClass<const bt_field_class>;
1376 namespace internal {
1378 template <typename RangeSetT>
1379 struct CommonOptionWithIntegerSelectorFieldClassSpec;
1381 /* Functions specific to option field classes with unsigned integer ranges */
1383 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstUnsignedIntegerRangeSet> final
1385 static const bt_integer_range_set_unsigned *
1386 ranges(const bt_field_class * const libObjPtr) noexcept
1388 return bt_field_class_option_with_selector_field_integer_unsigned_borrow_selector_ranges_const(
1393 /* Functions specific to option field classes with signed ranges */
1395 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstSignedIntegerRangeSet> final
1397 static const bt_integer_range_set_signed *
1398 ranges(const bt_field_class * const libObjPtr) noexcept
1400 return bt_field_class_option_with_selector_field_integer_signed_borrow_selector_ranges_const(
1405 } /* namespace internal */
1407 template <typename LibObjT, typename RangeSetT>
1408 class CommonOptionWithIntegerSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1411 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1413 using typename CommonOptionWithSelectorFieldClass<
1414 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1416 using _ThisCommonOptionWithIntegerSelectorFieldClass =
1417 CommonOptionWithIntegerSelectorFieldClass<LibObjT, RangeSetT>;
1421 internal::SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
1423 using RangeSet = RangeSetT;
1425 explicit CommonOptionWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1426 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1428 BT_ASSERT_DBG(this->isOptionWithIntegerSelector());
1431 template <typename OtherLibObjT>
1432 CommonOptionWithIntegerSelectorFieldClass(
1433 const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept :
1434 _ThisCommonOptionWithSelectorFieldClass {fc}
1438 template <typename OtherLibObjT>
1439 _ThisCommonOptionWithIntegerSelectorFieldClass&
1440 operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept
1442 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1446 RangeSet ranges() const noexcept
1448 return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
1449 this->_libObjPtr())};
1452 Shared shared() const noexcept
1454 return Shared {*this};
1458 using OptionWithUnsignedIntegerSelectorFieldClass =
1459 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstUnsignedIntegerRangeSet>;
1461 using ConstOptionWithUnsignedIntegerSelectorFieldClass =
1462 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstUnsignedIntegerRangeSet>;
1464 using OptionWithSignedIntegerSelectorFieldClass =
1465 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstSignedIntegerRangeSet>;
1467 using ConstOptionWithSignedIntegerSelectorFieldClass =
1468 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstSignedIntegerRangeSet>;
1470 namespace internal {
1472 template <typename LibObjT>
1473 struct CommonVariantFieldClassOptionSpec;
1475 /* Functions specific to mutable variant field class options */
1477 struct CommonVariantFieldClassOptionSpec<bt_field_class_variant_option> final
1479 static bt_field_class *fieldClass(bt_field_class_variant_option * const libObjPtr) noexcept
1481 return bt_field_class_variant_option_borrow_field_class(libObjPtr);
1485 /* Functions specific to constant variant field class options */
1487 struct CommonVariantFieldClassOptionSpec<const bt_field_class_variant_option> final
1489 static const bt_field_class *
1490 fieldClass(const bt_field_class_variant_option * const libObjPtr) noexcept
1492 return bt_field_class_variant_option_borrow_field_class_const(libObjPtr);
1496 } /* namespace internal */
1498 template <typename LibObjT>
1499 class CommonVariantFieldClassOption : public internal::BorrowedObj<LibObjT>
1502 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
1503 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
1506 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1509 explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1510 _ThisBorrowedObj {libObjPtr}
1514 template <typename OtherLibObjT>
1515 CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept :
1516 _ThisBorrowedObj {fc}
1520 template <typename OtherLibObjT>
1521 CommonVariantFieldClassOption<LibObjT>&
1522 operator=(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept
1524 _ThisBorrowedObj::operator=(fc);
1528 bpstd::string_view name() const noexcept
1530 return bt_field_class_variant_option_get_name(this->_libObjPtr());
1533 ConstFieldClass fieldClass() const noexcept
1535 return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
1536 const bt_field_class_variant_option>::fieldClass(this->_libObjPtr())};
1539 _FieldClass fieldClass() noexcept
1541 return _FieldClass {
1542 internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->_libObjPtr())};
1546 using VariantFieldClassOption = CommonVariantFieldClassOption<bt_field_class_variant_option>;
1548 using ConstVariantFieldClassOption =
1549 CommonVariantFieldClassOption<const bt_field_class_variant_option>;
1551 namespace internal {
1553 template <typename LibObjT>
1554 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
1556 /* Functions specific to variant field class options with unsigned integer selector */
1558 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1559 const bt_field_class_variant_with_selector_field_integer_unsigned_option>
1562 static const bt_integer_range_set_unsigned *
1563 ranges(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1564 * const libObjPtr) noexcept
1566 return bt_field_class_variant_with_selector_field_integer_unsigned_option_borrow_ranges_const(
1570 static const bt_field_class_variant_option *
1571 asBaseOption(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1572 * const libObjPtr) noexcept
1574 return bt_field_class_variant_with_selector_field_integer_unsigned_option_as_option_const(
1579 /* Functions specific to variant field class options with signed integer selector */
1581 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1582 const bt_field_class_variant_with_selector_field_integer_signed_option>
1585 static const bt_integer_range_set_signed *
1586 ranges(const bt_field_class_variant_with_selector_field_integer_signed_option
1587 * const libObjPtr) noexcept
1589 return bt_field_class_variant_with_selector_field_integer_signed_option_borrow_ranges_const(
1593 static const bt_field_class_variant_option *
1594 asBaseOption(const bt_field_class_variant_with_selector_field_integer_signed_option
1595 * const libObjPtr) noexcept
1597 return bt_field_class_variant_with_selector_field_integer_signed_option_as_option_const(
1602 } /* namespace internal */
1604 template <typename LibObjT>
1605 class ConstVariantWithIntegerSelectorFieldClassOption : public internal::BorrowedObj<LibObjT>
1608 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
1609 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
1610 using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
1613 using RangeSet = typename std::conditional<
1616 const bt_field_class_variant_with_selector_field_integer_unsigned_option>::value,
1617 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
1619 explicit ConstVariantWithIntegerSelectorFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1620 _ThisBorrowedObj {libObjPtr}
1624 template <typename OtherLibObjT>
1625 ConstVariantWithIntegerSelectorFieldClassOption(
1626 const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept :
1627 _ThisBorrowedObj {fc}
1631 template <typename OtherLibObjT>
1632 ConstVariantWithIntegerSelectorFieldClassOption<LibObjT>&
1633 operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept
1635 _ThisBorrowedObj::operator=(fc);
1639 ConstVariantFieldClassOption asBaseOption() const noexcept
1641 return ConstVariantFieldClassOption {_Spec::asBaseOption(this->_libObjPtr())};
1644 bpstd::string_view name() const noexcept
1646 return this->asBaseOption().name();
1649 ConstFieldClass fieldClass() const noexcept
1651 return this->asBaseOption().fieldClass();
1654 RangeSet ranges() const noexcept
1656 return RangeSet {_Spec::ranges(this->_libObjPtr())};
1660 using ConstVariantWithUnsignedIntegerSelectorFieldClassOption =
1661 ConstVariantWithIntegerSelectorFieldClassOption<
1662 const bt_field_class_variant_with_selector_field_integer_unsigned_option>;
1664 using ConstVariantWithSignedIntegerSelectorFieldClassOption =
1665 ConstVariantWithIntegerSelectorFieldClassOption<
1666 const bt_field_class_variant_with_selector_field_integer_signed_option>;
1668 namespace internal {
1670 template <typename LibObjT>
1671 struct CommonVariantFieldClassSpec;
1673 /* Functions specific to mutable variant field classes */
1675 struct CommonVariantFieldClassSpec<bt_field_class> final
1677 static bt_field_class_variant_option *optionByIndex(bt_field_class * const libObjPtr,
1678 const std::uint64_t index) noexcept
1680 return bt_field_class_variant_borrow_option_by_index(libObjPtr, index);
1683 static bt_field_class_variant_option *optionByName(bt_field_class * const libObjPtr,
1684 const char * const name) noexcept
1686 return bt_field_class_variant_borrow_option_by_name(libObjPtr, name);
1690 /* Functions specific to constant variant field classes */
1692 struct CommonVariantFieldClassSpec<const bt_field_class> final
1694 static const bt_field_class_variant_option *
1695 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1697 return bt_field_class_variant_borrow_option_by_index_const(libObjPtr, index);
1700 static const bt_field_class_variant_option *optionByName(const bt_field_class * const libObjPtr,
1701 const char * const name) noexcept
1703 return bt_field_class_variant_borrow_option_by_name_const(libObjPtr, name);
1707 } /* namespace internal */
1709 template <typename LibObjT>
1710 class CommonVariantFieldClass : public CommonFieldClass<LibObjT>
1713 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1716 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1717 using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
1720 using Shared = internal::SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
1723 typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
1724 VariantFieldClassOption>::type;
1726 explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
1727 _ThisCommonFieldClass {libObjPtr}
1729 BT_ASSERT_DBG(this->isVariant());
1732 template <typename OtherLibObjT>
1733 CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept :
1734 _ThisCommonFieldClass {fc}
1738 template <typename OtherLibObjT>
1739 _ThisCommonVariantFieldClass&
1740 operator=(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept
1742 _ThisCommonFieldClass::operator=(fc);
1746 std::uint64_t size() const noexcept
1748 return bt_field_class_variant_get_option_count(this->_libObjPtr());
1751 ConstVariantFieldClassOption operator[](const std::uint64_t index) const noexcept
1753 return ConstVariantFieldClassOption {
1754 internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
1755 this->_libObjPtr(), index)};
1758 Option operator[](const std::uint64_t index) noexcept
1760 return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
1761 this->_libObjPtr(), index)};
1764 nonstd::optional<ConstVariantFieldClassOption>
1765 operator[](const char * const name) const noexcept
1767 const auto libObjPtr =
1768 internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
1769 this->_libObjPtr(), name);
1772 return ConstVariantFieldClassOption {libObjPtr};
1775 return nonstd::nullopt;
1778 nonstd::optional<ConstVariantFieldClassOption>
1779 operator[](const std::string& name) const noexcept
1781 return (*this)[name.data()];
1784 nonstd::optional<Option> operator[](const char * const name) noexcept
1786 const auto libObjPtr =
1787 internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->_libObjPtr(), name);
1790 return Option {libObjPtr};
1793 return nonstd::nullopt;
1796 nonstd::optional<Option> operator[](const std::string& name) noexcept
1798 return (*this)[name.data()];
1801 Shared shared() const noexcept
1803 return Shared {*this};
1807 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
1808 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
1810 template <typename LibObjT>
1811 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
1814 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
1815 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1819 internal::SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
1821 explicit CommonVariantWithoutSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1822 _ThisCommonVariantFieldClass {libObjPtr}
1824 BT_ASSERT_DBG(this->isVariantWithoutSelector());
1827 template <typename OtherLibObjT>
1828 CommonVariantWithoutSelectorFieldClass(
1829 const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept :
1830 _ThisCommonVariantFieldClass {fc}
1834 template <typename OtherLibObjT>
1835 CommonVariantWithoutSelectorFieldClass<LibObjT>&
1836 operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept
1838 _ThisCommonVariantFieldClass::operator=(fc);
1842 void appendOption(const char * const name, const FieldClass& fc)
1844 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1846 const auto status = bt_field_class_variant_without_selector_append_option(
1847 this->_libObjPtr(), name, fc._libObjPtr());
1850 BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
1851 throw LibMemoryError {};
1855 void appendOption(const std::string& name, const FieldClass& fc)
1857 this->appendOption(name.data(), fc);
1860 Shared shared() const noexcept
1862 return Shared {*this};
1866 using VariantWithoutSelectorFieldClass = CommonVariantWithoutSelectorFieldClass<bt_field_class>;
1867 using ConstVariantWithoutSelectorFieldClass =
1868 CommonVariantWithoutSelectorFieldClass<const bt_field_class>;
1870 namespace internal {
1872 template <typename OptionT>
1873 struct CommonVariantWithIntegerSelectorFieldClassSpec;
1875 /* Functions specific to variant field classes with unsigned integer selector */
1877 struct CommonVariantWithIntegerSelectorFieldClassSpec<
1878 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
1881 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
1882 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1884 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_index_const(
1888 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
1889 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1891 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_name_const(
1895 static bt_field_class_variant_with_selector_field_integer_append_option_status
1896 appendOption(bt_field_class * const libObjPtr, const char * const name,
1897 bt_field_class * const libOptFcPtr,
1898 const bt_integer_range_set_unsigned * const libRangesPtr)
1900 return bt_field_class_variant_with_selector_field_integer_unsigned_append_option(
1901 libObjPtr, name, libOptFcPtr, libRangesPtr);
1905 /* Functions specific to variant field classes with signed integer selector */
1907 struct CommonVariantWithIntegerSelectorFieldClassSpec<
1908 ConstVariantWithSignedIntegerSelectorFieldClassOption>
1911 static const bt_field_class_variant_with_selector_field_integer_signed_option *
1912 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1914 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_index_const(
1918 static const bt_field_class_variant_with_selector_field_integer_signed_option *
1919 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1921 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_name_const(
1925 static bt_field_class_variant_with_selector_field_integer_append_option_status
1926 appendOption(bt_field_class * const libObjPtr, const char * const name,
1927 bt_field_class * const libOptFcPtr,
1928 const bt_integer_range_set_signed * const libRangesPtr)
1930 return bt_field_class_variant_with_selector_field_integer_signed_append_option(
1931 libObjPtr, name, libOptFcPtr, libRangesPtr);
1935 } /* namespace internal */
1937 template <typename LibObjT, typename OptionT>
1938 class CommonVariantWithIntegerSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
1941 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
1942 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1944 using _ThisCommonVariantWithIntegerSelectorFieldClass =
1945 CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
1947 using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
1951 internal::SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
1953 using Option = OptionT;
1955 explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1956 _ThisCommonVariantFieldClass {libObjPtr}
1958 BT_ASSERT_DBG(this->isVariant());
1961 template <typename OtherLibObjT>
1962 CommonVariantWithIntegerSelectorFieldClass(
1963 const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept :
1964 _ThisCommonVariantFieldClass {fc}
1968 template <typename OtherLibObjT>
1969 _ThisCommonVariantWithIntegerSelectorFieldClass&
1970 operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept
1972 _ThisCommonVariantFieldClass::operator=(fc);
1976 ConstFieldPath selectorFieldPath() const noexcept
1978 return ConstFieldPath {
1979 bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
1980 this->_libObjPtr())};
1983 Option operator[](const std::uint64_t index) const noexcept
1985 return Option {_Spec::optionByIndex(this->_libObjPtr(), index)};
1988 nonstd::optional<Option> operator[](const char * const name) const noexcept
1990 const auto libObjPtr = _Spec::optionByName(this->_libObjPtr(), name);
1993 return Option {libObjPtr};
1996 return nonstd::nullopt;
1999 nonstd::optional<Option> operator[](const std::string& name) const noexcept
2001 return (*this)[name.data()];
2004 void appendOption(const char * const name, const FieldClass& fc,
2005 const typename Option::RangeSet& ranges)
2007 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
2010 _Spec::appendOption(this->_libObjPtr(), name, fc._libObjPtr(), ranges._libObjPtr());
2013 BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2014 throw LibMemoryError {};
2018 void appendOption(const std::string& name, const FieldClass& fc)
2020 this->appendOption(name.data(), fc);
2023 Shared shared() const noexcept
2025 return Shared {*this};
2029 using VariantWithUnsignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2030 bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2032 using ConstVariantWithUnsignedIntegerSelectorFieldClass =
2033 CommonVariantWithIntegerSelectorFieldClass<
2034 const bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2036 using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2037 bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2039 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2040 const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2042 template <typename LibObjT>
2043 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
2045 BT_ASSERT_DBG(this->isBitArray());
2046 return CommonBitArrayFieldClass<LibObjT> {this->_libObjPtr()};
2049 template <typename LibObjT>
2050 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
2052 BT_ASSERT_DBG(this->isInteger());
2053 return CommonIntegerFieldClass<LibObjT> {this->_libObjPtr()};
2056 template <typename LibObjT>
2057 CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping>
2058 CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
2060 BT_ASSERT_DBG(this->isUnsignedEnumeration());
2061 return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
2062 this->_libObjPtr()};
2065 template <typename LibObjT>
2066 CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping>
2067 CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
2069 BT_ASSERT_DBG(this->isSignedEnumeration());
2070 return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
2071 this->_libObjPtr()};
2074 template <typename LibObjT>
2075 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
2077 BT_ASSERT_DBG(this->isStructure());
2078 return CommonStructureFieldClass<LibObjT> {this->_libObjPtr()};
2081 template <typename LibObjT>
2082 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
2084 BT_ASSERT_DBG(this->isArray());
2085 return CommonArrayFieldClass<LibObjT> {this->_libObjPtr()};
2088 template <typename LibObjT>
2089 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
2091 BT_ASSERT_DBG(this->isStaticArray());
2092 return CommonStaticArrayFieldClass<LibObjT> {this->_libObjPtr()};
2095 template <typename LibObjT>
2096 CommonDynamicArrayWithLengthFieldClass<LibObjT>
2097 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
2099 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
2100 return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->_libObjPtr()};
2103 template <typename LibObjT>
2104 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
2106 BT_ASSERT_DBG(this->isOption());
2107 return CommonOptionFieldClass<LibObjT> {this->_libObjPtr()};
2110 template <typename LibObjT>
2111 CommonOptionWithSelectorFieldClass<LibObjT>
2112 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
2114 BT_ASSERT_DBG(this->isOptionWithSelector());
2115 return CommonOptionWithSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2118 template <typename LibObjT>
2119 CommonOptionWithBoolSelectorFieldClass<LibObjT>
2120 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
2122 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
2123 return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2126 template <typename LibObjT>
2127 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
2128 CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
2130 BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
2131 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
2132 this->_libObjPtr()};
2135 template <typename LibObjT>
2136 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
2137 CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
2139 BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
2140 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
2141 this->_libObjPtr()};
2144 template <typename LibObjT>
2145 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
2147 BT_ASSERT_DBG(this->isVariant());
2148 return CommonVariantFieldClass<LibObjT> {this->_libObjPtr()};
2151 template <typename LibObjT>
2152 CommonVariantWithoutSelectorFieldClass<LibObjT>
2153 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
2155 BT_ASSERT_DBG(this->isVariantWithoutSelector());
2156 return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->_libObjPtr()};
2159 template <typename LibObjT>
2160 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2161 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2162 CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
2164 BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
2165 return CommonVariantWithIntegerSelectorFieldClass<
2166 LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
2169 template <typename LibObjT>
2170 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2171 ConstVariantWithSignedIntegerSelectorFieldClassOption>
2172 CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
2174 BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
2175 return CommonVariantWithIntegerSelectorFieldClass<
2176 LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
2179 } /* namespace bt2 */
2181 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP */