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
11 #include <type_traits>
13 #include <babeltrace2/babeltrace.h>
15 #include "common/assert.h"
16 #include "cpp-common/optional.hpp"
17 #include "cpp-common/string_view.hpp"
19 #include "borrowed-object.hpp"
20 #include "common-iterator.hpp"
22 #include "field-path.hpp"
23 #include "integer-range-set.hpp"
24 #include "internal/utils.hpp"
25 #include "shared-object.hpp"
31 struct FieldClassRefFuncs final
33 static void get(const bt_field_class * const libObjPtr) noexcept
35 bt_field_class_get_ref(libObjPtr);
38 static void put(const bt_field_class * const libObjPtr) noexcept
40 bt_field_class_put_ref(libObjPtr);
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 ObjT, typename LibObjT>
70 using SharedFieldClass = SharedObject<ObjT, LibObjT, internal::FieldClassRefFuncs>;
72 template <typename LibObjT>
73 class CommonBitArrayFieldClass;
75 template <typename LibObjT>
76 class CommonIntegerFieldClass;
78 template <typename LibObjT>
79 class ConstEnumerationFieldClassMapping;
81 template <typename LibObjT>
82 class CommonBaseEnumerationFieldClass;
84 template <typename LibObjT, typename MappingT>
85 class CommonEnumerationFieldClass;
87 template <typename LibObjT>
88 class CommonStructureFieldClass;
90 template <typename LibObjT>
91 class CommonArrayFieldClass;
93 template <typename LibObjT>
94 class CommonStaticArrayFieldClass;
96 template <typename LibObjT>
97 class CommonDynamicArrayWithLengthFieldClass;
99 template <typename LibObjT>
100 class CommonOptionFieldClass;
102 template <typename LibObjT>
103 class CommonOptionWithSelectorFieldClass;
105 template <typename LibObjT>
106 class CommonOptionWithBoolSelectorFieldClass;
108 template <typename LibObjT>
109 class CommonVariantFieldClass;
111 template <typename LibObjT, typename RangeSetT>
112 class CommonOptionWithIntegerSelectorFieldClass;
114 template <typename LibObjT>
115 class CommonVariantWithoutSelectorFieldClass;
117 template <typename LibObjT>
118 class CommonVariantWithSelectorFieldClass;
120 template <typename LibObjT>
121 class ConstVariantWithIntegerSelectorFieldClassOption;
123 template <typename LibObjT, typename RangeSetT>
124 class CommonVariantWithIntegerSelectorFieldClass;
126 template <typename LibObjT>
127 class CommonEventClass;
129 template <typename LibObjT>
130 class CommonStreamClass;
132 template <typename LibObjT>
133 class CommonTraceClass;
135 enum class FieldClassType
137 BOOL = BT_FIELD_CLASS_TYPE_BOOL,
138 BIT_ARRAY = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
139 UNSIGNED_INTEGER = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER,
140 SIGNED_INTEGER = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER,
141 UNSIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
142 SIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
143 SINGLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL,
144 DOUBLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL,
145 STRING = BT_FIELD_CLASS_TYPE_STRING,
146 STRUCTURE = BT_FIELD_CLASS_TYPE_STRUCTURE,
147 STATIC_ARRAY = BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
148 DYNAMIC_ARRAY_WITHOUT_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD,
149 DYNAMIC_ARRAY_WITH_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD,
150 OPTION_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD,
151 OPTION_WITH_BOOL_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD,
152 OPTION_WITH_UNSIGNED_INTEGER_SELECTOR =
153 BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
154 OPTION_WITH_SIGNED_INTEGER_SELECTOR =
155 BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
156 VARIANT_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD,
157 VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR =
158 BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
159 VARIANT_WITH_SIGNED_INTEGER_SELECTOR =
160 BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
163 template <typename LibObjT>
164 class CommonFieldClass : public BorrowedObject<LibObjT>
167 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
170 using typename BorrowedObject<LibObjT>::_LibObjPtr;
171 using _ThisCommonFieldClass = CommonFieldClass<LibObjT>;
174 using Shared = SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
176 using UserAttributes =
177 typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
179 explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
183 template <typename OtherLibObjT>
184 CommonFieldClass(const CommonFieldClass<OtherLibObjT> fc) noexcept : _ThisBorrowedObject {fc}
188 template <typename OtherLibObjT>
189 CommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
191 _ThisBorrowedObject::operator=(fc);
195 FieldClassType type() const noexcept
197 return static_cast<FieldClassType>(bt_field_class_get_type(this->libObjPtr()));
200 bool isBool() const noexcept
202 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BOOL);
205 bool isBitArray() const noexcept
207 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BIT_ARRAY);
210 bool isInteger() const noexcept
212 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_INTEGER);
215 bool isUnsignedInteger() const noexcept
217 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
220 bool isSignedInteger() const noexcept
222 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
225 bool isEnumeration() const noexcept
227 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ENUMERATION);
230 bool isUnsignedEnumeration() const noexcept
232 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
235 bool isSignedEnumeration() const noexcept
237 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
240 bool isReal() const noexcept
242 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_REAL);
245 bool isSinglePrecisionReal() const noexcept
247 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL);
250 bool isDoublePrecisionReal() const noexcept
252 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL);
255 bool isString() const noexcept
257 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRING);
260 bool isStructure() const noexcept
262 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRUCTURE);
265 bool isArray() const noexcept
267 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ARRAY);
270 bool isStaticArray() const noexcept
272 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STATIC_ARRAY);
275 bool isDynamicArray() const noexcept
277 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY);
280 bool isDynamicArrayWithoutLength() const noexcept
282 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD);
285 bool isDynamicArrayWithLength() const noexcept
287 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
290 bool isOption() const noexcept
292 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION);
295 bool isOptionWithoutSelector() const noexcept
297 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD);
300 bool isOptionWithSelector() const noexcept
302 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD);
305 bool isOptionWithBoolSelector() const noexcept
307 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD);
310 bool isOptionWithIntegerSelector() const noexcept
312 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_INTEGER_SELECTOR_FIELD);
315 bool isOptionWithUnsignedIntegerSelector() const noexcept
317 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
320 bool isOptionWithSignedIntegerSelector() const noexcept
322 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
325 bool isVariant() const noexcept
327 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT);
330 bool isVariantWithoutSelector() const noexcept
332 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD);
335 bool isVariantWithSelector() const noexcept
337 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD);
340 bool isVariantWithIntegerSelector() const noexcept
342 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_INTEGER_SELECTOR_FIELD);
345 bool isVariantWithUnsignedIntegerSelector() const noexcept
347 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
350 bool isVariantWithSignedIntegerSelector() const noexcept
352 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
355 template <typename FieldClassT>
356 FieldClassT as() const noexcept
358 return FieldClassT {this->libObjPtr()};
361 CommonBitArrayFieldClass<LibObjT> asBitArray() const noexcept;
362 CommonIntegerFieldClass<LibObjT> asInteger() const noexcept;
363 CommonBaseEnumerationFieldClass<LibObjT> asEnumeration() const noexcept;
364 CommonEnumerationFieldClass<LibObjT, ConstEnumerationFieldClassMapping<
365 const bt_field_class_enumeration_unsigned_mapping>>
366 asUnsignedEnumeration() const noexcept;
368 CommonEnumerationFieldClass<
369 LibObjT, ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>>
370 asSignedEnumeration() const noexcept;
372 CommonStructureFieldClass<LibObjT> asStructure() const noexcept;
373 CommonArrayFieldClass<LibObjT> asArray() const noexcept;
374 CommonStaticArrayFieldClass<LibObjT> asStaticArray() const noexcept;
375 CommonDynamicArrayWithLengthFieldClass<LibObjT> asDynamicArrayWithLength() const noexcept;
376 CommonOptionFieldClass<LibObjT> asOption() const noexcept;
377 CommonOptionWithSelectorFieldClass<LibObjT> asOptionWithSelector() const noexcept;
378 CommonOptionWithBoolSelectorFieldClass<LibObjT> asOptionWithBoolSelector() const noexcept;
380 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
381 asOptionWithUnsignedIntegerSelector() const noexcept;
383 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
384 asOptionWithSignedIntegerSelector() const noexcept;
386 CommonVariantFieldClass<LibObjT> asVariant() const noexcept;
387 CommonVariantWithoutSelectorFieldClass<LibObjT> asVariantWithoutSelector() const noexcept;
388 CommonVariantWithSelectorFieldClass<LibObjT> asVariantWithSelector() const noexcept;
390 CommonVariantWithIntegerSelectorFieldClass<
391 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
392 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>
393 asVariantWithUnsignedIntegerSelector() const noexcept;
395 CommonVariantWithIntegerSelectorFieldClass<
396 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
397 const bt_field_class_variant_with_selector_field_integer_signed_option>>
398 asVariantWithSignedIntegerSelector() const noexcept;
400 template <typename LibValT>
401 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
403 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
405 bt_field_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
408 UserAttributes userAttributes() const noexcept
410 return UserAttributes {
411 internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
414 Shared shared() const noexcept
416 return Shared::createWithRef(*this);
420 bool _libTypeIs(const bt_field_class_type type) const noexcept
422 return bt_field_class_type_is(bt_field_class_get_type(this->libObjPtr()), type);
426 using FieldClass = CommonFieldClass<bt_field_class>;
427 using ConstFieldClass = CommonFieldClass<const bt_field_class>;
431 struct FieldClassTypeDescr
433 using Const = ConstFieldClass;
434 using NonConst = FieldClass;
438 struct TypeDescr<FieldClass> : public FieldClassTypeDescr
443 struct TypeDescr<ConstFieldClass> : public FieldClassTypeDescr
447 } /* namespace internal */
449 template <typename LibObjT>
450 class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
453 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
454 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
457 using Shared = SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
459 explicit CommonBitArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
460 _ThisCommonFieldClass {libObjPtr}
462 BT_ASSERT_DBG(this->isBitArray());
465 template <typename OtherLibObjT>
466 CommonBitArrayFieldClass(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept :
467 _ThisCommonFieldClass {fc}
471 template <typename OtherLibObjT>
472 CommonBitArrayFieldClass<LibObjT>&
473 operator=(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept
475 _ThisCommonFieldClass::operator=(fc);
479 std::uint64_t length() const noexcept
481 return bt_field_class_bit_array_get_length(this->libObjPtr());
484 Shared shared() const noexcept
486 return Shared::createWithRef(*this);
490 using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
491 using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
495 struct BitArrayFieldClassTypeDescr
497 using Const = ConstBitArrayFieldClass;
498 using NonConst = BitArrayFieldClass;
502 struct TypeDescr<BitArrayFieldClass> : public BitArrayFieldClassTypeDescr
507 struct TypeDescr<ConstBitArrayFieldClass> : public BitArrayFieldClassTypeDescr
511 } /* namespace internal */
513 enum class DisplayBase
515 BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
516 OCTAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL,
517 DECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL,
518 HEXADECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL,
521 template <typename LibObjT>
522 class CommonIntegerFieldClass : public CommonFieldClass<LibObjT>
525 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
528 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
529 using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass<LibObjT>;
532 using Shared = SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
534 explicit CommonIntegerFieldClass(const _LibObjPtr libObjPtr) noexcept :
535 _ThisCommonFieldClass {libObjPtr}
537 BT_ASSERT_DBG(this->isInteger());
540 template <typename OtherLibObjT>
541 CommonIntegerFieldClass(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept :
542 _ThisCommonFieldClass {fc}
546 template <typename OtherLibObjT>
547 CommonIntegerFieldClass& operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
549 _ThisCommonFieldClass::operator=(fc);
553 void fieldValueRange(const std::uint64_t n) const noexcept
555 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
557 bt_field_class_integer_set_field_value_range(this->libObjPtr(), n);
560 std::uint64_t fieldValueRange() const noexcept
562 return bt_field_class_integer_get_field_value_range(this->libObjPtr());
565 void preferredDisplayBase(const DisplayBase base) const noexcept
567 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
569 bt_field_class_integer_set_preferred_display_base(
570 this->libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
573 DisplayBase preferredDisplayBase() const noexcept
575 return static_cast<DisplayBase>(
576 bt_field_class_integer_get_preferred_display_base(this->libObjPtr()));
579 Shared shared() const noexcept
581 return Shared::createWithRef(*this);
585 using IntegerFieldClass = CommonIntegerFieldClass<bt_field_class>;
586 using ConstIntegerFieldClass = CommonIntegerFieldClass<const bt_field_class>;
590 struct IntegerFieldClassTypeDescr
592 using Const = ConstIntegerFieldClass;
593 using NonConst = IntegerFieldClass;
597 struct TypeDescr<IntegerFieldClass> : public IntegerFieldClassTypeDescr
602 struct TypeDescr<ConstIntegerFieldClass> : public IntegerFieldClassTypeDescr
606 } /* namespace internal */
610 template <typename LibObjT>
611 struct ConstEnumerationFieldClassMappingSpec;
613 /* Functions specific to unsigned enumeration field class mappings */
615 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_unsigned_mapping>
618 static const bt_integer_range_set_unsigned *
619 ranges(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
621 return bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(libObjPtr);
625 label(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
627 return bt_field_class_enumeration_mapping_get_label(
628 bt_field_class_enumeration_unsigned_mapping_as_mapping_const(libObjPtr));
632 /* Functions specific to signed enumeration field class mappings */
634 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_signed_mapping> final
636 static const bt_integer_range_set_signed *
637 ranges(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
639 return bt_field_class_enumeration_signed_mapping_borrow_ranges_const(libObjPtr);
643 label(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
645 return bt_field_class_enumeration_mapping_get_label(
646 bt_field_class_enumeration_signed_mapping_as_mapping_const(libObjPtr));
650 } /* namespace internal */
652 template <typename LibObjT>
653 class ConstEnumerationFieldClassMapping final : public BorrowedObject<LibObjT>
656 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
657 using typename BorrowedObject<LibObjT>::_LibObjPtr;
660 using RangeSet = typename std::conditional<
661 std::is_same<LibObjT, const bt_field_class_enumeration_unsigned_mapping>::value,
662 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
664 explicit ConstEnumerationFieldClassMapping(const _LibObjPtr libObjPtr) noexcept :
665 _ThisBorrowedObject {libObjPtr}
669 ConstEnumerationFieldClassMapping(const ConstEnumerationFieldClassMapping& mapping) noexcept :
670 _ThisBorrowedObject {mapping}
674 ConstEnumerationFieldClassMapping&
675 operator=(const ConstEnumerationFieldClassMapping& mapping) noexcept
677 _ThisBorrowedObject::operator=(mapping);
681 RangeSet ranges() const noexcept
684 internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->libObjPtr())};
687 bpstd::string_view label() const noexcept
689 return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->libObjPtr());
693 using ConstUnsignedEnumerationFieldClassMapping =
694 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_unsigned_mapping>;
696 using ConstSignedEnumerationFieldClassMapping =
697 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>;
701 template <typename MappingT>
702 struct CommonEnumerationFieldClassSpec;
704 /* Functions specific to unsigned enumeration field classes */
706 struct CommonEnumerationFieldClassSpec<ConstUnsignedEnumerationFieldClassMapping> final
708 static const bt_field_class_enumeration_unsigned_mapping *
709 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
711 return bt_field_class_enumeration_unsigned_borrow_mapping_by_index_const(libObjPtr, index);
714 static const bt_field_class_enumeration_unsigned_mapping *
715 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
717 return bt_field_class_enumeration_unsigned_borrow_mapping_by_label_const(libObjPtr, label);
720 static bt_field_class_enumeration_add_mapping_status
721 addMapping(bt_field_class * const libObjPtr, const char * const label,
722 const bt_integer_range_set_unsigned * const libRanges) noexcept
724 return bt_field_class_enumeration_unsigned_add_mapping(libObjPtr, label, libRanges);
728 /* Functions specific to signed enumeration field classes */
730 struct CommonEnumerationFieldClassSpec<ConstSignedEnumerationFieldClassMapping> final
732 static const bt_field_class_enumeration_signed_mapping *
733 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
735 return bt_field_class_enumeration_signed_borrow_mapping_by_index_const(libObjPtr, index);
738 static const bt_field_class_enumeration_signed_mapping *
739 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
741 return bt_field_class_enumeration_signed_borrow_mapping_by_label_const(libObjPtr, label);
744 static bt_field_class_enumeration_add_mapping_status
745 addMapping(bt_field_class * const libObjPtr, const char * const label,
746 const bt_integer_range_set_signed * const libRanges) noexcept
748 return bt_field_class_enumeration_signed_add_mapping(libObjPtr, label, libRanges);
752 } /* namespace internal */
754 template <typename LibObjT>
755 class CommonBaseEnumerationFieldClass : public CommonIntegerFieldClass<LibObjT>
758 using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
761 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
762 using _ThisCommonBaseEnumerationFieldClass = CommonBaseEnumerationFieldClass<LibObjT>;
765 using Shared = SharedFieldClass<_ThisCommonBaseEnumerationFieldClass, LibObjT>;
767 explicit CommonBaseEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
768 _ThisCommonIntegerFieldClass {libObjPtr}
770 BT_ASSERT_DBG(this->isEnumeration());
773 template <typename OtherLibObjT>
774 CommonBaseEnumerationFieldClass(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
776 _ThisCommonIntegerFieldClass {fc}
780 template <typename OtherLibObjT>
781 CommonBaseEnumerationFieldClass&
782 operator=(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
784 _ThisCommonIntegerFieldClass::operator=(fc);
788 std::uint64_t length() const noexcept
790 return bt_field_class_enumeration_get_mapping_count(this->libObjPtr());
793 Shared shared() const noexcept
795 return Shared::createWithRef(*this);
799 template <typename LibObjT, typename MappingT>
800 class CommonEnumerationFieldClass final : public CommonBaseEnumerationFieldClass<LibObjT>
803 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
804 using typename CommonBaseEnumerationFieldClass<LibObjT>::_ThisCommonBaseEnumerationFieldClass;
805 using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
808 using Shared = SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
809 using Iterator = CommonIterator<CommonEnumerationFieldClass, MappingT>;
810 using Mapping = MappingT;
812 explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
813 _ThisCommonBaseEnumerationFieldClass {libObjPtr}
815 BT_ASSERT_DBG(this->isEnumeration());
818 template <typename OtherLibObjT>
819 CommonEnumerationFieldClass(
820 const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept :
821 _ThisCommonEnumerationFieldClass {fc}
825 template <typename OtherLibObjT>
826 CommonEnumerationFieldClass&
827 operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept
829 _ThisCommonEnumerationFieldClass::operator=(fc);
833 Mapping operator[](const std::uint64_t index) const noexcept
835 return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
836 this->libObjPtr(), index)};
839 nonstd::optional<Mapping> operator[](const char * const label) const noexcept
841 const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
842 this->libObjPtr(), label);
845 return Mapping {libObjPtr};
848 return nonstd::nullopt;
851 nonstd::optional<Mapping> operator[](const std::string& label) const noexcept
853 return (*this)[label.data()];
856 void addMapping(const char * const label, const typename Mapping::RangeSet ranges) const
858 const auto status = internal::CommonEnumerationFieldClassSpec<MappingT>::addMapping(
859 this->libObjPtr(), label, ranges.libObjPtr());
861 if (status == BT_FIELD_CLASS_ENUMERATION_ADD_MAPPING_STATUS_MEMORY_ERROR) {
862 throw MemoryError {};
866 void addMapping(const std::string& label, const typename Mapping::RangeSet ranges) const
868 this->addMapping(label.data(), ranges);
871 Iterator begin() const noexcept
873 return Iterator {*this, 0};
876 Iterator end() const noexcept
878 return Iterator {*this, this->length()};
881 Shared shared() const noexcept
883 return Shared::createWithRef(*this);
887 using EnumerationFieldClass = CommonBaseEnumerationFieldClass<bt_field_class>;
888 using ConstEnumerationFieldClass = CommonBaseEnumerationFieldClass<const bt_field_class>;
890 using UnsignedEnumerationFieldClass =
891 CommonEnumerationFieldClass<bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
893 using ConstUnsignedEnumerationFieldClass =
894 CommonEnumerationFieldClass<const bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
896 using SignedEnumerationFieldClass =
897 CommonEnumerationFieldClass<bt_field_class, ConstSignedEnumerationFieldClassMapping>;
899 using ConstSignedEnumerationFieldClass =
900 CommonEnumerationFieldClass<const bt_field_class, ConstSignedEnumerationFieldClassMapping>;
904 struct UnsignedEnumerationFieldClassTypeDescr
906 using Const = ConstUnsignedEnumerationFieldClass;
907 using NonConst = UnsignedEnumerationFieldClass;
911 struct TypeDescr<UnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
916 struct TypeDescr<ConstUnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
920 struct SignedEnumerationFieldClassTypeDescr
922 using Const = ConstSignedEnumerationFieldClass;
923 using NonConst = SignedEnumerationFieldClass;
927 struct TypeDescr<SignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
932 struct TypeDescr<ConstSignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
936 template <typename LibObjT>
937 struct CommonStructureFieldClassMemberSpec;
939 /* Functions specific to mutable structure field class members */
941 struct CommonStructureFieldClassMemberSpec<bt_field_class_structure_member> final
943 static bt_field_class *fieldClass(bt_field_class_structure_member * const libObjPtr) noexcept
945 return bt_field_class_structure_member_borrow_field_class(libObjPtr);
948 static bt_value *userAttributes(bt_field_class_structure_member * const libObjPtr) noexcept
950 return bt_field_class_structure_member_borrow_user_attributes(libObjPtr);
954 /* Functions specific to constant structure field class members */
956 struct CommonStructureFieldClassMemberSpec<const bt_field_class_structure_member> final
958 static const bt_field_class *
959 fieldClass(const bt_field_class_structure_member * const libObjPtr) noexcept
961 return bt_field_class_structure_member_borrow_field_class_const(libObjPtr);
964 static const bt_value *
965 userAttributes(const bt_field_class_structure_member * const libObjPtr) noexcept
967 return bt_field_class_structure_member_borrow_user_attributes_const(libObjPtr);
971 } /* namespace internal */
973 template <typename LibObjT>
974 class CommonStructureFieldClassMember final : public BorrowedObject<LibObjT>
977 using typename BorrowedObject<LibObjT>::_LibObjPtr;
978 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
981 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
984 using UserAttributes =
985 typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
987 explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept :
988 _ThisBorrowedObject {libObjPtr}
992 template <typename OtherLibObjT>
993 CommonStructureFieldClassMember(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
995 _ThisBorrowedObject {fc}
999 template <typename OtherLibObjT>
1000 CommonStructureFieldClassMember<LibObjT>&
1001 operator=(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
1003 _ThisBorrowedObject::operator=(fc);
1007 bpstd::string_view name() const noexcept
1009 return bt_field_class_structure_member_get_name(this->libObjPtr());
1012 _FieldClass fieldClass() const noexcept
1014 return _FieldClass {
1015 internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->libObjPtr())};
1018 template <typename LibValT>
1019 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1021 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1023 bt_field_class_structure_member_set_user_attributes(this->libObjPtr(),
1024 userAttrs.libObjPtr());
1027 UserAttributes userAttributes() const noexcept
1029 return UserAttributes {
1030 internal::CommonStructureFieldClassMemberSpec<LibObjT>::userAttributes(
1031 this->libObjPtr())};
1035 using StructureFieldClassMember = CommonStructureFieldClassMember<bt_field_class_structure_member>;
1037 using ConstStructureFieldClassMember =
1038 CommonStructureFieldClassMember<const bt_field_class_structure_member>;
1040 namespace internal {
1042 struct StructureFieldClassMemberTypeDescr
1044 using Const = ConstStructureFieldClassMember;
1045 using NonConst = StructureFieldClassMember;
1049 struct TypeDescr<StructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
1054 struct TypeDescr<ConstStructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
1058 template <typename LibObjT>
1059 struct CommonStructureFieldClassSpec;
1061 /* Functions specific to mutable structure field classes */
1063 struct CommonStructureFieldClassSpec<bt_field_class> final
1065 static bt_field_class_structure_member *memberByIndex(bt_field_class * const libObjPtr,
1066 const std::uint64_t index) noexcept
1068 return bt_field_class_structure_borrow_member_by_index(libObjPtr, index);
1071 static bt_field_class_structure_member *memberByName(bt_field_class * const libObjPtr,
1072 const char * const name) noexcept
1074 return bt_field_class_structure_borrow_member_by_name(libObjPtr, name);
1078 /* Functions specific to constant structure field classes */
1080 struct CommonStructureFieldClassSpec<const bt_field_class> final
1082 static const bt_field_class_structure_member *
1083 memberByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1085 return bt_field_class_structure_borrow_member_by_index_const(libObjPtr, index);
1088 static const bt_field_class_structure_member *
1089 memberByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1091 return bt_field_class_structure_borrow_member_by_name_const(libObjPtr, name);
1095 } /* namespace internal */
1097 template <typename LibObjT>
1098 class CommonStructureFieldClass final : public CommonFieldClass<LibObjT>
1101 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1102 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1105 using Shared = SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
1107 typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClassMember,
1108 StructureFieldClassMember>::type;
1110 using Iterator = CommonIterator<CommonStructureFieldClass<LibObjT>, Member>;
1112 explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
1113 _ThisCommonFieldClass {libObjPtr}
1115 BT_ASSERT_DBG(this->isStructure());
1118 template <typename OtherLibObjT>
1119 CommonStructureFieldClass(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept :
1120 _ThisCommonFieldClass {fc}
1124 template <typename OtherLibObjT>
1125 CommonStructureFieldClass& operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
1127 _ThisCommonFieldClass::operator=(fc);
1131 void appendMember(const char * const name, const FieldClass fc) const
1133 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1136 bt_field_class_structure_append_member(this->libObjPtr(), name, fc.libObjPtr());
1138 if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
1139 throw MemoryError {};
1143 void appendMember(const std::string& name, const FieldClass fc) const
1145 this->appendMember(name.data(), fc);
1148 std::uint64_t length() const noexcept
1150 return bt_field_class_structure_get_member_count(this->libObjPtr());
1153 Iterator begin() const noexcept
1155 return Iterator {*this, 0};
1158 Iterator end() const noexcept
1160 return Iterator {*this, this->length()};
1163 Member operator[](const std::uint64_t index) const noexcept
1165 return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
1166 this->libObjPtr(), index)};
1169 nonstd::optional<Member> operator[](const char * const name) const noexcept
1171 const auto libObjPtr =
1172 internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(), name);
1175 return Member {libObjPtr};
1178 return nonstd::nullopt;
1181 nonstd::optional<Member> operator[](const std::string& name) const noexcept
1183 return (*this)[name.data()];
1186 Shared shared() const noexcept
1188 return Shared::createWithRef(*this);
1192 using StructureFieldClass = CommonStructureFieldClass<bt_field_class>;
1193 using ConstStructureFieldClass = CommonStructureFieldClass<const bt_field_class>;
1195 namespace internal {
1197 struct StructureFieldClassTypeDescr
1199 using Const = ConstStructureFieldClass;
1200 using NonConst = StructureFieldClass;
1204 struct TypeDescr<StructureFieldClass> : public StructureFieldClassTypeDescr
1209 struct TypeDescr<ConstStructureFieldClass> : public StructureFieldClassTypeDescr
1213 template <typename LibObjT>
1214 struct CommonArrayFieldClassSpec;
1216 /* Functions specific to mutable array field classes */
1218 struct CommonArrayFieldClassSpec<bt_field_class> final
1220 static bt_field_class *elementFieldClass(bt_field_class * const libObjPtr) noexcept
1222 return bt_field_class_array_borrow_element_field_class(libObjPtr);
1226 /* Functions specific to constant array field classes */
1228 struct CommonArrayFieldClassSpec<const bt_field_class> final
1230 static const bt_field_class *elementFieldClass(const bt_field_class * const libObjPtr) noexcept
1232 return bt_field_class_array_borrow_element_field_class_const(libObjPtr);
1236 } /* namespace internal */
1238 template <typename LibObjT>
1239 class CommonArrayFieldClass : public CommonFieldClass<LibObjT>
1242 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1245 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1248 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1249 using _ThisCommonArrayFieldClass = CommonArrayFieldClass<LibObjT>;
1252 using Shared = SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
1254 explicit CommonArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1255 _ThisCommonFieldClass {libObjPtr}
1257 BT_ASSERT_DBG(this->isArray());
1260 template <typename OtherLibObjT>
1261 CommonArrayFieldClass(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept :
1262 _ThisCommonFieldClass {fc}
1266 template <typename OtherLibObjT>
1267 CommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
1269 _ThisCommonFieldClass::operator=(fc);
1273 _FieldClass elementFieldClass() const noexcept
1275 return _FieldClass {
1276 internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->libObjPtr())};
1279 Shared shared() const noexcept
1281 return Shared::createWithRef(*this);
1285 using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
1286 using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
1288 namespace internal {
1290 struct ArrayFieldClassTypeDescr
1292 using Const = ConstArrayFieldClass;
1293 using NonConst = ArrayFieldClass;
1297 struct TypeDescr<ArrayFieldClass> : public ArrayFieldClassTypeDescr
1302 struct TypeDescr<ConstArrayFieldClass> : public ArrayFieldClassTypeDescr
1306 } /* namespace internal */
1308 template <typename LibObjT>
1309 class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
1312 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1313 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1316 using Shared = SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
1318 explicit CommonStaticArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
1319 _ThisCommonArrayFieldClass {libObjPtr}
1321 BT_ASSERT_DBG(this->isStaticArray());
1324 template <typename OtherLibObjT>
1325 CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept :
1326 _ThisCommonArrayFieldClass {fc}
1330 template <typename OtherLibObjT>
1331 CommonStaticArrayFieldClass&
1332 operator=(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept
1334 _ThisCommonArrayFieldClass::operator=(fc);
1338 std::uint64_t length() const noexcept
1340 return bt_field_class_array_static_get_length(this->libObjPtr());
1343 Shared shared() const noexcept
1345 return Shared::createWithRef(*this);
1349 using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
1350 using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
1352 namespace internal {
1354 struct StaticArrayFieldClassTypeDescr
1356 using Const = ConstStaticArrayFieldClass;
1357 using NonConst = StaticArrayFieldClass;
1361 struct TypeDescr<StaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
1366 struct TypeDescr<ConstStaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
1370 } /* namespace internal */
1372 template <typename LibObjT>
1373 class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
1376 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1377 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1380 using Shared = SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
1382 explicit CommonDynamicArrayWithLengthFieldClass(const _LibObjPtr libObjPtr) noexcept :
1383 _ThisCommonArrayFieldClass {libObjPtr}
1385 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
1388 template <typename OtherLibObjT>
1389 CommonDynamicArrayWithLengthFieldClass(
1390 const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept :
1391 _ThisCommonArrayFieldClass {fc}
1395 template <typename OtherLibObjT>
1396 CommonDynamicArrayWithLengthFieldClass&
1397 operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept
1399 _ThisCommonArrayFieldClass::operator=(fc);
1403 ConstFieldPath lengthFieldPath() const noexcept
1405 return ConstFieldPath {
1406 bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
1407 this->libObjPtr())};
1410 Shared shared() const noexcept
1412 return Shared::createWithRef(*this);
1416 using DynamicArrayWithLengthFieldClass = CommonDynamicArrayWithLengthFieldClass<bt_field_class>;
1418 using ConstDynamicArrayWithLengthFieldClass =
1419 CommonDynamicArrayWithLengthFieldClass<const bt_field_class>;
1421 namespace internal {
1423 struct DynamicArrayWithLengthFieldClassTypeDescr
1425 using Const = ConstDynamicArrayWithLengthFieldClass;
1426 using NonConst = DynamicArrayWithLengthFieldClass;
1430 struct TypeDescr<DynamicArrayWithLengthFieldClass> :
1431 public DynamicArrayWithLengthFieldClassTypeDescr
1436 struct TypeDescr<ConstDynamicArrayWithLengthFieldClass> :
1437 public DynamicArrayWithLengthFieldClassTypeDescr
1441 template <typename LibObjT>
1442 struct CommonOptionFieldClassSpec;
1444 /* Functions specific to mutable option field classes */
1446 struct CommonOptionFieldClassSpec<bt_field_class> final
1448 static bt_field_class *fieldClass(bt_field_class * const libObjPtr) noexcept
1450 return bt_field_class_option_borrow_field_class(libObjPtr);
1454 /* Functions specific to constant option field classes */
1456 struct CommonOptionFieldClassSpec<const bt_field_class> final
1458 static const bt_field_class *fieldClass(const bt_field_class * const libObjPtr) noexcept
1460 return bt_field_class_option_borrow_field_class_const(libObjPtr);
1464 } /* namespace internal */
1466 template <typename LibObjT>
1467 class CommonOptionFieldClass : public CommonFieldClass<LibObjT>
1470 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1473 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1476 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1477 using _ThisCommonOptionFieldClass = CommonOptionFieldClass<LibObjT>;
1480 using Shared = SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
1482 explicit CommonOptionFieldClass(const _LibObjPtr libObjPtr) noexcept :
1483 _ThisCommonFieldClass {libObjPtr}
1485 BT_ASSERT_DBG(this->isOption());
1488 template <typename OtherLibObjT>
1489 CommonOptionFieldClass(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept :
1490 _ThisCommonFieldClass {fc}
1494 template <typename OtherLibObjT>
1495 CommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
1497 _ThisCommonFieldClass::operator=(fc);
1501 _FieldClass fieldClass() const noexcept
1503 return _FieldClass {
1504 internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->libObjPtr())};
1507 Shared shared() const noexcept
1509 return Shared::createWithRef(*this);
1513 using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
1514 using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
1516 namespace internal {
1518 struct OptionFieldClassTypeDescr
1520 using Const = ConstOptionFieldClass;
1521 using NonConst = OptionFieldClass;
1525 struct TypeDescr<OptionFieldClass> : public OptionFieldClassTypeDescr
1530 struct TypeDescr<ConstOptionFieldClass> : public OptionFieldClassTypeDescr
1534 } /* namespace internal */
1536 template <typename LibObjT>
1537 class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
1540 using typename CommonOptionFieldClass<LibObjT>::_ThisCommonOptionFieldClass;
1543 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1544 using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<LibObjT>;
1547 using Shared = SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
1549 explicit CommonOptionWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1550 _ThisCommonOptionFieldClass {libObjPtr}
1552 BT_ASSERT_DBG(this->isOptionWithSelector());
1555 template <typename OtherLibObjT>
1556 CommonOptionWithSelectorFieldClass(
1557 const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept :
1558 _ThisCommonOptionFieldClass {fc}
1562 template <typename OtherLibObjT>
1563 CommonOptionWithSelectorFieldClass&
1564 operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept
1566 _ThisCommonOptionFieldClass::operator=(fc);
1570 ConstFieldPath selectorFieldPath() const noexcept
1572 return ConstFieldPath {
1573 bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
1574 this->libObjPtr())};
1577 Shared shared() const noexcept
1579 return Shared::createWithRef(*this);
1583 using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
1584 using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
1586 namespace internal {
1588 struct OptionWithSelectorFieldClassTypeDescr
1590 using Const = ConstOptionWithSelectorFieldClass;
1591 using NonConst = OptionWithSelectorFieldClass;
1595 struct TypeDescr<OptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
1600 struct TypeDescr<ConstOptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
1604 } /* namespace internal */
1606 template <typename LibObjT>
1607 class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1610 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1612 using typename CommonOptionWithSelectorFieldClass<
1613 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1616 using Shared = SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
1618 explicit CommonOptionWithBoolSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1619 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1621 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
1624 template <typename OtherLibObjT>
1625 CommonOptionWithBoolSelectorFieldClass(
1626 const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept :
1627 _ThisCommonOptionWithSelectorFieldClass {fc}
1631 template <typename OtherLibObjT>
1632 CommonOptionWithBoolSelectorFieldClass&
1633 operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept
1635 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1639 bool selectorIsReversed() const noexcept
1641 return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
1645 Shared shared() const noexcept
1647 return Shared::createWithRef(*this);
1651 using OptionWithBoolSelectorFieldClass = CommonOptionWithBoolSelectorFieldClass<bt_field_class>;
1653 using ConstOptionWithBoolSelectorFieldClass =
1654 CommonOptionWithBoolSelectorFieldClass<const bt_field_class>;
1656 namespace internal {
1658 struct OptionWithBoolSelectorFieldClassTypeDescr
1660 using Const = ConstOptionWithBoolSelectorFieldClass;
1661 using NonConst = OptionWithBoolSelectorFieldClass;
1665 struct TypeDescr<OptionWithBoolSelectorFieldClass> :
1666 public OptionWithBoolSelectorFieldClassTypeDescr
1671 struct TypeDescr<ConstOptionWithBoolSelectorFieldClass> :
1672 public OptionWithBoolSelectorFieldClassTypeDescr
1676 template <typename RangeSetT>
1677 struct CommonOptionWithIntegerSelectorFieldClassSpec;
1679 /* Functions specific to option field classes with unsigned integer ranges */
1681 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstUnsignedIntegerRangeSet> final
1683 static const bt_integer_range_set_unsigned *
1684 ranges(const bt_field_class * const libObjPtr) noexcept
1686 return bt_field_class_option_with_selector_field_integer_unsigned_borrow_selector_ranges_const(
1691 /* Functions specific to option field classes with signed ranges */
1693 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstSignedIntegerRangeSet> final
1695 static const bt_integer_range_set_signed *
1696 ranges(const bt_field_class * const libObjPtr) noexcept
1698 return bt_field_class_option_with_selector_field_integer_signed_borrow_selector_ranges_const(
1703 } /* namespace internal */
1705 template <typename LibObjT, typename RangeSetT>
1706 class CommonOptionWithIntegerSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1709 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
1711 using typename CommonOptionWithSelectorFieldClass<
1712 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1714 using _ThisCommonOptionWithIntegerSelectorFieldClass =
1715 CommonOptionWithIntegerSelectorFieldClass<LibObjT, RangeSetT>;
1718 using Shared = SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
1720 using RangeSet = RangeSetT;
1722 explicit CommonOptionWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
1723 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1725 BT_ASSERT_DBG(this->isOptionWithIntegerSelector());
1728 template <typename OtherLibObjT>
1729 CommonOptionWithIntegerSelectorFieldClass(
1730 const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept :
1731 _ThisCommonOptionWithSelectorFieldClass {fc}
1735 template <typename OtherLibObjT>
1736 CommonOptionWithIntegerSelectorFieldClass&
1737 operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept
1739 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1743 RangeSet ranges() const noexcept
1745 return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
1746 this->libObjPtr())};
1749 Shared shared() const noexcept
1751 return Shared::createWithRef(*this);
1755 using OptionWithUnsignedIntegerSelectorFieldClass =
1756 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstUnsignedIntegerRangeSet>;
1758 using ConstOptionWithUnsignedIntegerSelectorFieldClass =
1759 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstUnsignedIntegerRangeSet>;
1761 using OptionWithSignedIntegerSelectorFieldClass =
1762 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstSignedIntegerRangeSet>;
1764 using ConstOptionWithSignedIntegerSelectorFieldClass =
1765 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstSignedIntegerRangeSet>;
1767 namespace internal {
1769 struct OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
1771 using Const = ConstOptionWithUnsignedIntegerSelectorFieldClass;
1772 using NonConst = OptionWithUnsignedIntegerSelectorFieldClass;
1776 struct TypeDescr<OptionWithUnsignedIntegerSelectorFieldClass> :
1777 public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
1782 struct TypeDescr<ConstOptionWithUnsignedIntegerSelectorFieldClass> :
1783 public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
1787 struct OptionWithSignedIntegerSelectorFieldClassTypeDescr
1789 using Const = ConstOptionWithSignedIntegerSelectorFieldClass;
1790 using NonConst = OptionWithSignedIntegerSelectorFieldClass;
1794 struct TypeDescr<OptionWithSignedIntegerSelectorFieldClass> :
1795 public OptionWithSignedIntegerSelectorFieldClassTypeDescr
1800 struct TypeDescr<ConstOptionWithSignedIntegerSelectorFieldClass> :
1801 public OptionWithSignedIntegerSelectorFieldClassTypeDescr
1805 template <typename LibObjT>
1806 struct CommonVariantFieldClassOptionSpec;
1808 /* Functions specific to mutable variant field class options */
1810 struct CommonVariantFieldClassOptionSpec<bt_field_class_variant_option> final
1812 static bt_field_class *fieldClass(bt_field_class_variant_option * const libObjPtr) noexcept
1814 return bt_field_class_variant_option_borrow_field_class(libObjPtr);
1817 static bt_value *userAttributes(bt_field_class_variant_option * const libObjPtr) noexcept
1819 return bt_field_class_variant_option_borrow_user_attributes(libObjPtr);
1823 /* Functions specific to constant variant field class options */
1825 struct CommonVariantFieldClassOptionSpec<const bt_field_class_variant_option> final
1827 static const bt_field_class *
1828 fieldClass(const bt_field_class_variant_option * const libObjPtr) noexcept
1830 return bt_field_class_variant_option_borrow_field_class_const(libObjPtr);
1833 static const bt_value *
1834 userAttributes(const bt_field_class_variant_option * const libObjPtr) noexcept
1836 return bt_field_class_variant_option_borrow_user_attributes_const(libObjPtr);
1840 } /* namespace internal */
1842 template <typename LibObjT>
1843 class CommonVariantFieldClassOption : public BorrowedObject<LibObjT>
1846 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1847 using typename BorrowedObject<LibObjT>::_LibObjPtr;
1850 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
1853 using UserAttributes =
1854 typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
1856 explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1857 _ThisBorrowedObject {libObjPtr}
1861 template <typename OtherLibObjT>
1862 CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept :
1863 _ThisBorrowedObject {fc}
1867 template <typename OtherLibObjT>
1868 CommonVariantFieldClassOption&
1869 operator=(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept
1871 _ThisBorrowedObject::operator=(fc);
1875 nonstd::optional<bpstd::string_view> name() const noexcept
1877 const auto name = bt_field_class_variant_option_get_name(this->libObjPtr());
1883 return nonstd::nullopt;
1886 _FieldClass fieldClass() const noexcept
1888 return _FieldClass {
1889 internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
1892 template <typename LibValT>
1893 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1895 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1897 bt_field_class_variant_option_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1900 UserAttributes userAttributes() const noexcept
1902 return UserAttributes {internal::CommonVariantFieldClassOptionSpec<LibObjT>::userAttributes(
1903 this->libObjPtr())};
1907 using VariantFieldClassOption = CommonVariantFieldClassOption<bt_field_class_variant_option>;
1909 using ConstVariantFieldClassOption =
1910 CommonVariantFieldClassOption<const bt_field_class_variant_option>;
1912 namespace internal {
1914 struct VariantFieldClassOptionTypeDescr
1916 using Const = ConstVariantFieldClassOption;
1917 using NonConst = VariantFieldClassOption;
1921 struct TypeDescr<VariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
1926 struct TypeDescr<ConstVariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
1930 template <typename LibObjT>
1931 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
1933 /* Functions specific to variant field class options with unsigned integer selector */
1935 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1936 const bt_field_class_variant_with_selector_field_integer_unsigned_option>
1939 static const bt_integer_range_set_unsigned *
1940 ranges(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1941 * const libObjPtr) noexcept
1943 return bt_field_class_variant_with_selector_field_integer_unsigned_option_borrow_ranges_const(
1947 static const bt_field_class_variant_option *
1948 asBaseOption(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1949 * const libObjPtr) noexcept
1951 return bt_field_class_variant_with_selector_field_integer_unsigned_option_as_option_const(
1956 /* Functions specific to variant field class options with signed integer selector */
1958 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1959 const bt_field_class_variant_with_selector_field_integer_signed_option>
1962 static const bt_integer_range_set_signed *
1963 ranges(const bt_field_class_variant_with_selector_field_integer_signed_option
1964 * const libObjPtr) noexcept
1966 return bt_field_class_variant_with_selector_field_integer_signed_option_borrow_ranges_const(
1970 static const bt_field_class_variant_option *
1971 asBaseOption(const bt_field_class_variant_with_selector_field_integer_signed_option
1972 * const libObjPtr) noexcept
1974 return bt_field_class_variant_with_selector_field_integer_signed_option_as_option_const(
1979 } /* namespace internal */
1981 template <typename LibObjT>
1982 class ConstVariantWithIntegerSelectorFieldClassOption : public BorrowedObject<LibObjT>
1985 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1986 using typename BorrowedObject<LibObjT>::_LibObjPtr;
1987 using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
1990 using RangeSet = typename std::conditional<
1993 const bt_field_class_variant_with_selector_field_integer_unsigned_option>::value,
1994 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
1996 explicit ConstVariantWithIntegerSelectorFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
1997 _ThisBorrowedObject {libObjPtr}
2001 template <typename OtherLibObjT>
2002 ConstVariantWithIntegerSelectorFieldClassOption(
2003 const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept :
2004 _ThisBorrowedObject {fc}
2008 template <typename OtherLibObjT>
2009 ConstVariantWithIntegerSelectorFieldClassOption&
2010 operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept
2012 _ThisBorrowedObject::operator=(fc);
2016 ConstVariantFieldClassOption asBaseOption() const noexcept
2018 return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())};
2021 nonstd::optional<bpstd::string_view> name() const noexcept
2023 return this->asBaseOption().name();
2026 ConstFieldClass fieldClass() const noexcept
2028 return this->asBaseOption().fieldClass();
2031 RangeSet ranges() const noexcept
2033 return RangeSet {_Spec::ranges(this->libObjPtr())};
2037 using ConstVariantWithUnsignedIntegerSelectorFieldClassOption =
2038 ConstVariantWithIntegerSelectorFieldClassOption<
2039 const bt_field_class_variant_with_selector_field_integer_unsigned_option>;
2041 using ConstVariantWithSignedIntegerSelectorFieldClassOption =
2042 ConstVariantWithIntegerSelectorFieldClassOption<
2043 const bt_field_class_variant_with_selector_field_integer_signed_option>;
2045 namespace internal {
2047 template <typename LibObjT>
2048 struct CommonVariantFieldClassSpec;
2050 /* Functions specific to mutable variant field classes */
2052 struct CommonVariantFieldClassSpec<bt_field_class> final
2054 static bt_field_class_variant_option *optionByIndex(bt_field_class * const libObjPtr,
2055 const std::uint64_t index) noexcept
2057 return bt_field_class_variant_borrow_option_by_index(libObjPtr, index);
2060 static bt_field_class_variant_option *optionByName(bt_field_class * const libObjPtr,
2061 const char * const name) noexcept
2063 return bt_field_class_variant_borrow_option_by_name(libObjPtr, name);
2067 /* Functions specific to constant variant field classes */
2069 struct CommonVariantFieldClassSpec<const bt_field_class> final
2071 static const bt_field_class_variant_option *
2072 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2074 return bt_field_class_variant_borrow_option_by_index_const(libObjPtr, index);
2077 static const bt_field_class_variant_option *optionByName(const bt_field_class * const libObjPtr,
2078 const char * const name) noexcept
2080 return bt_field_class_variant_borrow_option_by_name_const(libObjPtr, name);
2084 } /* namespace internal */
2086 template <typename LibObjT>
2087 class CommonVariantFieldClass : public CommonFieldClass<LibObjT>
2090 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
2093 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
2094 using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
2097 using Shared = SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
2100 typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
2101 VariantFieldClassOption>::type;
2103 using Iterator = CommonIterator<CommonVariantFieldClass, Option>;
2105 explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
2106 _ThisCommonFieldClass {libObjPtr}
2108 BT_ASSERT_DBG(this->isVariant());
2111 template <typename OtherLibObjT>
2112 CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept :
2113 _ThisCommonFieldClass {fc}
2117 template <typename OtherLibObjT>
2118 CommonVariantFieldClass& operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
2120 _ThisCommonFieldClass::operator=(fc);
2124 std::uint64_t length() const noexcept
2126 return bt_field_class_variant_get_option_count(this->libObjPtr());
2129 Iterator begin() const noexcept
2131 return Iterator {*this, 0};
2134 Iterator end() const noexcept
2136 return Iterator {*this, this->length()};
2139 Option operator[](const std::uint64_t index) const noexcept
2141 return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
2142 this->libObjPtr(), index)};
2145 nonstd::optional<Option> operator[](const char * const name) const noexcept
2147 const auto libObjPtr =
2148 internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(), name);
2151 return Option {libObjPtr};
2154 return nonstd::nullopt;
2157 nonstd::optional<Option> operator[](const std::string& name) const noexcept
2159 return (*this)[name.data()];
2162 Shared shared() const noexcept
2164 return Shared::createWithRef(*this);
2168 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
2169 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
2171 namespace internal {
2173 struct VariantFieldClassTypeDescr
2175 using Const = ConstVariantFieldClass;
2176 using NonConst = VariantFieldClass;
2180 struct TypeDescr<VariantFieldClass> : public VariantFieldClassTypeDescr
2185 struct TypeDescr<ConstVariantFieldClass> : public VariantFieldClassTypeDescr
2189 } /* namespace internal */
2191 template <typename LibObjT>
2192 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
2195 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
2196 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
2199 using Shared = SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
2201 explicit CommonVariantWithoutSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
2202 _ThisCommonVariantFieldClass {libObjPtr}
2204 BT_ASSERT_DBG(this->isVariantWithoutSelector());
2207 template <typename OtherLibObjT>
2208 CommonVariantWithoutSelectorFieldClass(
2209 const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept :
2210 _ThisCommonVariantFieldClass {fc}
2214 template <typename OtherLibObjT>
2215 CommonVariantWithoutSelectorFieldClass&
2216 operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept
2218 _ThisCommonVariantFieldClass::operator=(fc);
2222 void appendOption(const char * const name, const FieldClass fc) const
2224 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
2226 const auto status = bt_field_class_variant_without_selector_append_option(
2227 this->libObjPtr(), name, fc.libObjPtr());
2230 BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2231 throw MemoryError {};
2235 void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc) const
2237 this->appendOption(name ? name->data() : nullptr, fc);
2240 Shared shared() const noexcept
2242 return Shared::createWithRef(*this);
2246 using VariantWithoutSelectorFieldClass = CommonVariantWithoutSelectorFieldClass<bt_field_class>;
2247 using ConstVariantWithoutSelectorFieldClass =
2248 CommonVariantWithoutSelectorFieldClass<const bt_field_class>;
2250 namespace internal {
2252 struct VariantWithoutSelectorFieldClassTypeDescr
2254 using Const = ConstVariantWithoutSelectorFieldClass;
2255 using NonConst = VariantWithoutSelectorFieldClass;
2259 struct TypeDescr<VariantWithoutSelectorFieldClass> :
2260 public VariantWithoutSelectorFieldClassTypeDescr
2265 struct TypeDescr<ConstVariantWithoutSelectorFieldClass> :
2266 public VariantWithoutSelectorFieldClassTypeDescr
2270 template <typename OptionT>
2271 struct CommonVariantWithIntegerSelectorFieldClassSpec;
2273 /* Functions specific to variant field classes with unsigned integer selector */
2275 struct CommonVariantWithIntegerSelectorFieldClassSpec<
2276 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2279 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
2280 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2282 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_index_const(
2286 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
2287 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
2289 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_name_const(
2293 static bt_field_class_variant_with_selector_field_integer_append_option_status
2294 appendOption(bt_field_class * const libObjPtr, const char * const name,
2295 bt_field_class * const libOptFcPtr,
2296 const bt_integer_range_set_unsigned * const libRangesPtr)
2298 return bt_field_class_variant_with_selector_field_integer_unsigned_append_option(
2299 libObjPtr, name, libOptFcPtr, libRangesPtr);
2303 /* Functions specific to variant field classes with signed integer selector */
2305 struct CommonVariantWithIntegerSelectorFieldClassSpec<
2306 ConstVariantWithSignedIntegerSelectorFieldClassOption>
2309 static const bt_field_class_variant_with_selector_field_integer_signed_option *
2310 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2312 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_index_const(
2316 static const bt_field_class_variant_with_selector_field_integer_signed_option *
2317 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
2319 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_name_const(
2323 static bt_field_class_variant_with_selector_field_integer_append_option_status
2324 appendOption(bt_field_class * const libObjPtr, const char * const name,
2325 bt_field_class * const libOptFcPtr,
2326 const bt_integer_range_set_signed * const libRangesPtr)
2328 return bt_field_class_variant_with_selector_field_integer_signed_append_option(
2329 libObjPtr, name, libOptFcPtr, libRangesPtr);
2333 } /* namespace internal */
2335 template <typename LibObjT>
2336 class CommonVariantWithSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
2339 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
2342 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
2343 using _ThisCommonVariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<LibObjT>;
2346 using Shared = SharedFieldClass<_ThisCommonVariantWithSelectorFieldClass, LibObjT>;
2348 explicit CommonVariantWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
2349 _ThisCommonVariantFieldClass {libObjPtr}
2351 BT_ASSERT_DBG(this->isVariantWithSelector());
2354 template <typename OtherLibObjT>
2355 CommonVariantWithSelectorFieldClass(
2356 const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept :
2357 _ThisCommonVariantFieldClass {fc}
2361 template <typename OtherLibObjT>
2362 CommonVariantWithSelectorFieldClass&
2363 operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept
2365 _ThisCommonVariantFieldClass::operator=(fc);
2369 ConstFieldPath selectorFieldPath() const noexcept
2371 return ConstFieldPath {
2372 bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
2373 this->libObjPtr())};
2376 Shared shared() const noexcept
2378 return Shared::createWithRef(*this);
2382 using VariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<bt_field_class>;
2383 using ConstVariantWithSelectorFieldClass =
2384 CommonVariantWithSelectorFieldClass<const bt_field_class>;
2386 template <typename LibObjT, typename OptionT>
2387 class CommonVariantWithIntegerSelectorFieldClass :
2388 public CommonVariantWithSelectorFieldClass<LibObjT>
2391 using typename CommonVariantWithSelectorFieldClass<
2392 LibObjT>::_ThisCommonVariantWithSelectorFieldClass;
2393 using typename CommonFieldClass<LibObjT>::_LibObjPtr;
2394 using _ThisCommonVariantWithIntegerSelectorFieldClass =
2395 CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
2397 using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
2400 using Shared = SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
2402 using Option = OptionT;
2404 CommonIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>, Option>;
2406 explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
2407 _ThisCommonVariantWithSelectorFieldClass {libObjPtr}
2409 BT_ASSERT_DBG(this->isVariant());
2412 template <typename OtherLibObjT>
2413 CommonVariantWithIntegerSelectorFieldClass(
2414 const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept :
2415 _ThisCommonVariantWithSelectorFieldClass {fc}
2419 template <typename OtherLibObjT>
2420 CommonVariantWithIntegerSelectorFieldClass&
2421 operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept
2423 _ThisCommonVariantWithSelectorFieldClass::operator=(fc);
2427 Option operator[](const std::uint64_t index) const noexcept
2429 return Option {_Spec::optionByIndex(this->libObjPtr(), index)};
2432 nonstd::optional<Option> operator[](const char * const name) const noexcept
2434 const auto libObjPtr = _Spec::optionByName(this->libObjPtr(), name);
2437 return Option {libObjPtr};
2440 return nonstd::nullopt;
2443 nonstd::optional<Option> operator[](const std::string& name) const noexcept
2445 return (*this)[name.data()];
2448 void appendOption(const char * const name, const FieldClass fc,
2449 const typename Option::RangeSet ranges) const
2451 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
2454 _Spec::appendOption(this->libObjPtr(), name, fc.libObjPtr(), ranges.libObjPtr());
2457 BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2458 throw MemoryError {};
2462 void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc,
2463 const typename Option::RangeSet ranges) const
2465 this->appendOption(name ? name->data() : nullptr, fc, ranges);
2468 Iterator begin() const noexcept
2470 return Iterator {*this, 0};
2473 Iterator end() const noexcept
2475 return Iterator {*this, this->length()};
2478 Shared shared() const noexcept
2480 return Shared::createWithRef(*this);
2484 using VariantWithUnsignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2485 bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2487 using ConstVariantWithUnsignedIntegerSelectorFieldClass =
2488 CommonVariantWithIntegerSelectorFieldClass<
2489 const bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2491 using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2492 bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2494 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2495 const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2497 namespace internal {
2499 struct VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2501 using Const = ConstVariantWithUnsignedIntegerSelectorFieldClass;
2502 using NonConst = VariantWithUnsignedIntegerSelectorFieldClass;
2506 struct TypeDescr<VariantWithUnsignedIntegerSelectorFieldClass> :
2507 public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2512 struct TypeDescr<ConstVariantWithUnsignedIntegerSelectorFieldClass> :
2513 public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2517 struct VariantWithSignedIntegerSelectorFieldClassTypeDescr
2519 using Const = ConstVariantWithSignedIntegerSelectorFieldClass;
2520 using NonConst = VariantWithSignedIntegerSelectorFieldClass;
2524 struct TypeDescr<VariantWithSignedIntegerSelectorFieldClass> :
2525 public VariantWithSignedIntegerSelectorFieldClassTypeDescr
2530 struct TypeDescr<ConstVariantWithSignedIntegerSelectorFieldClass> :
2531 public VariantWithSignedIntegerSelectorFieldClassTypeDescr
2535 } /* namespace internal */
2537 template <typename LibObjT>
2538 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
2540 BT_ASSERT_DBG(this->isBitArray());
2541 return CommonBitArrayFieldClass<LibObjT> {this->libObjPtr()};
2544 template <typename LibObjT>
2545 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
2547 BT_ASSERT_DBG(this->isInteger());
2548 return CommonIntegerFieldClass<LibObjT> {this->libObjPtr()};
2551 template <typename LibObjT>
2552 CommonBaseEnumerationFieldClass<LibObjT> CommonFieldClass<LibObjT>::asEnumeration() const noexcept
2554 BT_ASSERT_DBG(this->isEnumeration());
2555 return CommonBaseEnumerationFieldClass<LibObjT> {this->libObjPtr()};
2558 template <typename LibObjT>
2559 CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping>
2560 CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
2562 BT_ASSERT_DBG(this->isUnsignedEnumeration());
2563 return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
2567 template <typename LibObjT>
2568 CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping>
2569 CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
2571 BT_ASSERT_DBG(this->isSignedEnumeration());
2572 return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
2576 template <typename LibObjT>
2577 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
2579 BT_ASSERT_DBG(this->isStructure());
2580 return CommonStructureFieldClass<LibObjT> {this->libObjPtr()};
2583 template <typename LibObjT>
2584 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
2586 BT_ASSERT_DBG(this->isArray());
2587 return CommonArrayFieldClass<LibObjT> {this->libObjPtr()};
2590 template <typename LibObjT>
2591 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
2593 BT_ASSERT_DBG(this->isStaticArray());
2594 return CommonStaticArrayFieldClass<LibObjT> {this->libObjPtr()};
2597 template <typename LibObjT>
2598 CommonDynamicArrayWithLengthFieldClass<LibObjT>
2599 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
2601 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
2602 return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->libObjPtr()};
2605 template <typename LibObjT>
2606 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
2608 BT_ASSERT_DBG(this->isOption());
2609 return CommonOptionFieldClass<LibObjT> {this->libObjPtr()};
2612 template <typename LibObjT>
2613 CommonOptionWithSelectorFieldClass<LibObjT>
2614 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
2616 BT_ASSERT_DBG(this->isOptionWithSelector());
2617 return CommonOptionWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
2620 template <typename LibObjT>
2621 CommonOptionWithBoolSelectorFieldClass<LibObjT>
2622 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
2624 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
2625 return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->libObjPtr()};
2628 template <typename LibObjT>
2629 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
2630 CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
2632 BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
2633 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
2637 template <typename LibObjT>
2638 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
2639 CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
2641 BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
2642 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
2646 template <typename LibObjT>
2647 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
2649 BT_ASSERT_DBG(this->isVariant());
2650 return CommonVariantFieldClass<LibObjT> {this->libObjPtr()};
2653 template <typename LibObjT>
2654 CommonVariantWithoutSelectorFieldClass<LibObjT>
2655 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
2657 BT_ASSERT_DBG(this->isVariantWithoutSelector());
2658 return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->libObjPtr()};
2661 template <typename LibObjT>
2662 CommonVariantWithSelectorFieldClass<LibObjT>
2663 CommonFieldClass<LibObjT>::asVariantWithSelector() const noexcept
2665 BT_ASSERT_DBG(this->isVariantWithSelector());
2666 return CommonVariantWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
2669 template <typename LibObjT>
2670 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2671 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2672 CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
2674 BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
2675 return CommonVariantWithIntegerSelectorFieldClass<
2676 LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
2679 template <typename LibObjT>
2680 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2681 ConstVariantWithSignedIntegerSelectorFieldClassOption>
2682 CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
2684 BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
2685 return CommonVariantWithIntegerSelectorFieldClass<
2686 LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
2689 } /* namespace bt2 */
2691 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP */