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/bt2c/c-string-view.hpp"
17 #include "cpp-common/bt2s/optional.hpp"
19 #include "borrowed-object-iterator.hpp"
20 #include "borrowed-object.hpp"
22 #include "field-path.hpp"
23 #include "integer-range-set.hpp"
24 #include "internal/utils.hpp"
25 #include "optional-borrowed-object.hpp"
26 #include "shared-object.hpp"
32 struct FieldClassRefFuncs final
34 static void get(const bt_field_class * const libObjPtr) noexcept
36 bt_field_class_get_ref(libObjPtr);
39 static void put(const bt_field_class * const libObjPtr) noexcept
41 bt_field_class_put_ref(libObjPtr);
45 template <typename LibObjT>
46 struct CommonFieldClassSpec;
48 /* Functions specific to mutable field classes */
50 struct CommonFieldClassSpec<bt_field_class> final
52 static bt_value *userAttributes(bt_field_class * const libObjPtr) noexcept
54 return bt_field_class_borrow_user_attributes(libObjPtr);
58 /* Functions specific to constant field classes */
60 struct CommonFieldClassSpec<const bt_field_class> final
62 static const bt_value *userAttributes(const bt_field_class * const libObjPtr) noexcept
64 return bt_field_class_borrow_user_attributes_const(libObjPtr);
68 } /* namespace internal */
70 template <typename ObjT, typename LibObjT>
71 using SharedFieldClass = SharedObject<ObjT, LibObjT, internal::FieldClassRefFuncs>;
73 template <typename LibObjT>
74 class CommonBitArrayFieldClass;
76 template <typename LibObjT>
77 class CommonIntegerFieldClass;
79 template <typename LibObjT>
80 class ConstEnumerationFieldClassMapping;
82 template <typename LibObjT>
83 class CommonBaseEnumerationFieldClass;
85 template <typename LibObjT, typename MappingT>
86 class CommonEnumerationFieldClass;
88 template <typename LibObjT>
89 class CommonStructureFieldClass;
91 template <typename LibObjT>
92 class CommonArrayFieldClass;
94 template <typename LibObjT>
95 class CommonStaticArrayFieldClass;
97 template <typename LibObjT>
98 class CommonDynamicArrayWithLengthFieldClass;
100 template <typename LibObjT>
101 class CommonOptionFieldClass;
103 template <typename LibObjT>
104 class CommonOptionWithSelectorFieldClass;
106 template <typename LibObjT>
107 class CommonOptionWithBoolSelectorFieldClass;
109 template <typename LibObjT>
110 class CommonVariantFieldClass;
112 template <typename LibObjT, typename RangeSetT>
113 class CommonOptionWithIntegerSelectorFieldClass;
115 template <typename LibObjT>
116 class CommonVariantWithoutSelectorFieldClass;
118 template <typename LibObjT>
119 class CommonVariantWithSelectorFieldClass;
121 template <typename LibObjT>
122 class ConstVariantWithIntegerSelectorFieldClassOption;
124 template <typename LibObjT, typename RangeSetT>
125 class CommonVariantWithIntegerSelectorFieldClass;
127 template <typename LibObjT>
128 class CommonEventClass;
130 template <typename LibObjT>
131 class CommonStreamClass;
133 template <typename LibObjT>
134 class CommonTraceClass;
136 enum class FieldClassType
138 BOOL = BT_FIELD_CLASS_TYPE_BOOL,
139 BIT_ARRAY = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
140 UNSIGNED_INTEGER = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER,
141 SIGNED_INTEGER = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER,
142 UNSIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
143 SIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
144 SINGLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL,
145 DOUBLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL,
146 STRING = BT_FIELD_CLASS_TYPE_STRING,
147 STRUCTURE = BT_FIELD_CLASS_TYPE_STRUCTURE,
148 STATIC_ARRAY = BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
149 DYNAMIC_ARRAY_WITHOUT_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD,
150 DYNAMIC_ARRAY_WITH_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD,
151 OPTION_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD,
152 OPTION_WITH_BOOL_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD,
153 OPTION_WITH_UNSIGNED_INTEGER_SELECTOR =
154 BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
155 OPTION_WITH_SIGNED_INTEGER_SELECTOR =
156 BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
157 VARIANT_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD,
158 VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR =
159 BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
160 VARIANT_WITH_SIGNED_INTEGER_SELECTOR =
161 BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
164 template <typename LibObjT>
165 class CommonFieldClass : public BorrowedObject<LibObjT>
168 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
171 using _ThisCommonFieldClass = CommonFieldClass<LibObjT>;
174 using typename BorrowedObject<LibObjT>::LibObjPtr;
175 using Shared = SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
176 using UserAttributes = internal::DepUserAttrs<LibObjT>;
178 explicit CommonFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
182 template <typename OtherLibObjT>
183 CommonFieldClass(const CommonFieldClass<OtherLibObjT> fc) noexcept : _ThisBorrowedObject {fc}
187 template <typename OtherLibObjT>
188 CommonFieldClass operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
190 _ThisBorrowedObject::operator=(fc);
194 CommonFieldClass<const bt_field_class> asConst() const noexcept
196 return CommonFieldClass<const bt_field_class> {*this};
199 FieldClassType type() const noexcept
201 return static_cast<FieldClassType>(bt_field_class_get_type(this->libObjPtr()));
204 bool isBool() const noexcept
206 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BOOL);
209 bool isBitArray() const noexcept
211 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BIT_ARRAY);
214 bool isInteger() const noexcept
216 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_INTEGER);
219 bool isUnsignedInteger() const noexcept
221 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
224 bool isSignedInteger() const noexcept
226 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
229 bool isEnumeration() const noexcept
231 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ENUMERATION);
234 bool isUnsignedEnumeration() const noexcept
236 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
239 bool isSignedEnumeration() const noexcept
241 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
244 bool isReal() const noexcept
246 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_REAL);
249 bool isSinglePrecisionReal() const noexcept
251 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL);
254 bool isDoublePrecisionReal() const noexcept
256 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL);
259 bool isString() const noexcept
261 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRING);
264 bool isStructure() const noexcept
266 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRUCTURE);
269 bool isArray() const noexcept
271 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ARRAY);
274 bool isStaticArray() const noexcept
276 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STATIC_ARRAY);
279 bool isDynamicArray() const noexcept
281 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY);
284 bool isDynamicArrayWithoutLength() const noexcept
286 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD);
289 bool isDynamicArrayWithLength() const noexcept
291 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
294 bool isOption() const noexcept
296 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION);
299 bool isOptionWithoutSelector() const noexcept
301 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD);
304 bool isOptionWithSelector() const noexcept
306 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD);
309 bool isOptionWithBoolSelector() const noexcept
311 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD);
314 bool isOptionWithIntegerSelector() const noexcept
316 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_INTEGER_SELECTOR_FIELD);
319 bool isOptionWithUnsignedIntegerSelector() const noexcept
321 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
324 bool isOptionWithSignedIntegerSelector() const noexcept
326 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
329 bool isVariant() const noexcept
331 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT);
334 bool isVariantWithoutSelector() const noexcept
336 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD);
339 bool isVariantWithSelector() const noexcept
341 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD);
344 bool isVariantWithIntegerSelector() const noexcept
346 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_INTEGER_SELECTOR_FIELD);
349 bool isVariantWithUnsignedIntegerSelector() const noexcept
351 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
354 bool isVariantWithSignedIntegerSelector() const noexcept
356 return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
359 template <typename FieldClassT>
360 FieldClassT as() const noexcept
362 return FieldClassT {this->libObjPtr()};
365 CommonBitArrayFieldClass<LibObjT> asBitArray() const noexcept;
366 CommonIntegerFieldClass<LibObjT> asInteger() const noexcept;
367 CommonBaseEnumerationFieldClass<LibObjT> asEnumeration() const noexcept;
368 CommonEnumerationFieldClass<LibObjT, ConstEnumerationFieldClassMapping<
369 const bt_field_class_enumeration_unsigned_mapping>>
370 asUnsignedEnumeration() const noexcept;
372 CommonEnumerationFieldClass<
373 LibObjT, ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>>
374 asSignedEnumeration() const noexcept;
376 CommonStructureFieldClass<LibObjT> asStructure() const noexcept;
377 CommonArrayFieldClass<LibObjT> asArray() const noexcept;
378 CommonStaticArrayFieldClass<LibObjT> asStaticArray() const noexcept;
379 CommonDynamicArrayWithLengthFieldClass<LibObjT> asDynamicArrayWithLength() const noexcept;
380 CommonOptionFieldClass<LibObjT> asOption() const noexcept;
381 CommonOptionWithSelectorFieldClass<LibObjT> asOptionWithSelector() const noexcept;
382 CommonOptionWithBoolSelectorFieldClass<LibObjT> asOptionWithBoolSelector() const noexcept;
384 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
385 asOptionWithUnsignedIntegerSelector() const noexcept;
387 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
388 asOptionWithSignedIntegerSelector() const noexcept;
390 CommonVariantFieldClass<LibObjT> asVariant() const noexcept;
391 CommonVariantWithoutSelectorFieldClass<LibObjT> asVariantWithoutSelector() const noexcept;
392 CommonVariantWithSelectorFieldClass<LibObjT> asVariantWithSelector() const noexcept;
394 CommonVariantWithIntegerSelectorFieldClass<
395 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
396 const bt_field_class_variant_with_selector_field_integer_unsigned_option>>
397 asVariantWithUnsignedIntegerSelector() const noexcept;
399 CommonVariantWithIntegerSelectorFieldClass<
400 LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
401 const bt_field_class_variant_with_selector_field_integer_signed_option>>
402 asVariantWithSignedIntegerSelector() const noexcept;
404 template <typename LibValT>
405 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
407 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstFieldClass`.");
409 bt_field_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
412 UserAttributes userAttributes() const noexcept
414 return UserAttributes {
415 internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
418 Shared shared() const noexcept
420 return Shared::createWithRef(*this);
424 bool _libTypeIs(const bt_field_class_type type) const noexcept
426 return bt_field_class_type_is(bt_field_class_get_type(this->libObjPtr()), type);
430 using FieldClass = CommonFieldClass<bt_field_class>;
431 using ConstFieldClass = CommonFieldClass<const bt_field_class>;
435 struct FieldClassTypeDescr
437 using Const = ConstFieldClass;
438 using NonConst = FieldClass;
442 struct TypeDescr<FieldClass> : public FieldClassTypeDescr
447 struct TypeDescr<ConstFieldClass> : public FieldClassTypeDescr
451 } /* namespace internal */
453 template <typename LibObjT>
454 class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
457 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
460 using typename CommonFieldClass<LibObjT>::LibObjPtr;
461 using Shared = SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
463 explicit CommonBitArrayFieldClass(const LibObjPtr libObjPtr) noexcept :
464 _ThisCommonFieldClass {libObjPtr}
466 BT_ASSERT_DBG(this->isBitArray());
469 template <typename OtherLibObjT>
470 CommonBitArrayFieldClass(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept :
471 _ThisCommonFieldClass {fc}
475 template <typename OtherLibObjT>
476 CommonBitArrayFieldClass<LibObjT>
477 operator=(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept
479 _ThisCommonFieldClass::operator=(fc);
483 CommonBitArrayFieldClass<const bt_field_class> asConst() const noexcept
485 return CommonBitArrayFieldClass<const bt_field_class> {*this};
488 std::uint64_t length() const noexcept
490 return bt_field_class_bit_array_get_length(this->libObjPtr());
493 Shared shared() const noexcept
495 return Shared::createWithRef(*this);
499 using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
500 using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
504 struct BitArrayFieldClassTypeDescr
506 using Const = ConstBitArrayFieldClass;
507 using NonConst = BitArrayFieldClass;
511 struct TypeDescr<BitArrayFieldClass> : public BitArrayFieldClassTypeDescr
516 struct TypeDescr<ConstBitArrayFieldClass> : public BitArrayFieldClassTypeDescr
520 } /* namespace internal */
522 enum class DisplayBase
524 BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
525 OCTAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL,
526 DECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL,
527 HEXADECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL,
530 template <typename LibObjT>
531 class CommonIntegerFieldClass : public CommonFieldClass<LibObjT>
534 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
537 using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass<LibObjT>;
540 using typename CommonFieldClass<LibObjT>::LibObjPtr;
541 using Shared = SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
543 explicit CommonIntegerFieldClass(const LibObjPtr libObjPtr) noexcept :
544 _ThisCommonFieldClass {libObjPtr}
546 BT_ASSERT_DBG(this->isInteger());
549 template <typename OtherLibObjT>
550 CommonIntegerFieldClass(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept :
551 _ThisCommonFieldClass {fc}
555 template <typename OtherLibObjT>
556 CommonIntegerFieldClass operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
558 _ThisCommonFieldClass::operator=(fc);
562 CommonIntegerFieldClass<const bt_field_class> asConst() const noexcept
564 return CommonIntegerFieldClass<const bt_field_class> {*this};
567 void fieldValueRange(const std::uint64_t n) const noexcept
569 static_assert(!std::is_const<LibObjT>::value,
570 "Not available with `bt2::ConstIntegerFieldClass`.");
572 bt_field_class_integer_set_field_value_range(this->libObjPtr(), n);
575 std::uint64_t fieldValueRange() const noexcept
577 return bt_field_class_integer_get_field_value_range(this->libObjPtr());
580 void preferredDisplayBase(const DisplayBase base) const noexcept
582 static_assert(!std::is_const<LibObjT>::value,
583 "Not available with `bt2::ConstIntegerFieldClass`.");
585 bt_field_class_integer_set_preferred_display_base(
586 this->libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
589 DisplayBase preferredDisplayBase() const noexcept
591 return static_cast<DisplayBase>(
592 bt_field_class_integer_get_preferred_display_base(this->libObjPtr()));
595 Shared shared() const noexcept
597 return Shared::createWithRef(*this);
601 using IntegerFieldClass = CommonIntegerFieldClass<bt_field_class>;
602 using ConstIntegerFieldClass = CommonIntegerFieldClass<const bt_field_class>;
606 struct IntegerFieldClassTypeDescr
608 using Const = ConstIntegerFieldClass;
609 using NonConst = IntegerFieldClass;
613 struct TypeDescr<IntegerFieldClass> : public IntegerFieldClassTypeDescr
618 struct TypeDescr<ConstIntegerFieldClass> : public IntegerFieldClassTypeDescr
622 template <typename LibObjT>
623 struct ConstEnumerationFieldClassMappingSpec;
625 /* Functions specific to unsigned enumeration field class mappings */
627 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_unsigned_mapping>
630 static const bt_integer_range_set_unsigned *
631 ranges(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
633 return bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(libObjPtr);
637 label(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
639 return bt_field_class_enumeration_mapping_get_label(
640 bt_field_class_enumeration_unsigned_mapping_as_mapping_const(libObjPtr));
644 /* Functions specific to signed enumeration field class mappings */
646 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_signed_mapping> final
648 static const bt_integer_range_set_signed *
649 ranges(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
651 return bt_field_class_enumeration_signed_mapping_borrow_ranges_const(libObjPtr);
655 label(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
657 return bt_field_class_enumeration_mapping_get_label(
658 bt_field_class_enumeration_signed_mapping_as_mapping_const(libObjPtr));
662 } /* namespace internal */
664 template <typename LibObjT>
665 class ConstEnumerationFieldClassMapping final : public BorrowedObject<LibObjT>
668 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
671 using typename BorrowedObject<LibObjT>::LibObjPtr;
673 using RangeSet = typename std::conditional<
674 std::is_same<LibObjT, const bt_field_class_enumeration_unsigned_mapping>::value,
675 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
677 explicit ConstEnumerationFieldClassMapping(const LibObjPtr libObjPtr) noexcept :
678 _ThisBorrowedObject {libObjPtr}
682 ConstEnumerationFieldClassMapping(const ConstEnumerationFieldClassMapping& mapping) noexcept :
683 _ThisBorrowedObject {mapping}
687 ConstEnumerationFieldClassMapping
688 operator=(const ConstEnumerationFieldClassMapping& mapping) noexcept
690 _ThisBorrowedObject::operator=(mapping);
694 RangeSet ranges() const noexcept
697 internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->libObjPtr())};
700 bt2c::CStringView label() const noexcept
702 return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->libObjPtr());
706 using ConstUnsignedEnumerationFieldClassMapping =
707 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_unsigned_mapping>;
709 using ConstSignedEnumerationFieldClassMapping =
710 ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>;
714 template <typename MappingT>
715 struct CommonEnumerationFieldClassSpec;
717 /* Functions specific to unsigned enumeration field classes */
719 struct CommonEnumerationFieldClassSpec<ConstUnsignedEnumerationFieldClassMapping> final
721 static const bt_field_class_enumeration_unsigned_mapping *
722 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
724 return bt_field_class_enumeration_unsigned_borrow_mapping_by_index_const(libObjPtr, index);
727 static const bt_field_class_enumeration_unsigned_mapping *
728 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
730 return bt_field_class_enumeration_unsigned_borrow_mapping_by_label_const(libObjPtr, label);
733 static bt_field_class_enumeration_add_mapping_status
734 addMapping(bt_field_class * const libObjPtr, const char * const label,
735 const bt_integer_range_set_unsigned * const libRanges) noexcept
737 return bt_field_class_enumeration_unsigned_add_mapping(libObjPtr, label, libRanges);
741 /* Functions specific to signed enumeration field classes */
743 struct CommonEnumerationFieldClassSpec<ConstSignedEnumerationFieldClassMapping> final
745 static const bt_field_class_enumeration_signed_mapping *
746 mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
748 return bt_field_class_enumeration_signed_borrow_mapping_by_index_const(libObjPtr, index);
751 static const bt_field_class_enumeration_signed_mapping *
752 mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
754 return bt_field_class_enumeration_signed_borrow_mapping_by_label_const(libObjPtr, label);
757 static bt_field_class_enumeration_add_mapping_status
758 addMapping(bt_field_class * const libObjPtr, const char * const label,
759 const bt_integer_range_set_signed * const libRanges) noexcept
761 return bt_field_class_enumeration_signed_add_mapping(libObjPtr, label, libRanges);
765 } /* namespace internal */
767 template <typename LibObjT>
768 class CommonBaseEnumerationFieldClass : public CommonIntegerFieldClass<LibObjT>
771 using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
774 using _ThisCommonBaseEnumerationFieldClass = CommonBaseEnumerationFieldClass<LibObjT>;
777 using typename CommonFieldClass<LibObjT>::LibObjPtr;
778 using Shared = SharedFieldClass<_ThisCommonBaseEnumerationFieldClass, LibObjT>;
780 explicit CommonBaseEnumerationFieldClass(const LibObjPtr libObjPtr) noexcept :
781 _ThisCommonIntegerFieldClass {libObjPtr}
783 BT_ASSERT_DBG(this->isEnumeration());
786 template <typename OtherLibObjT>
787 CommonBaseEnumerationFieldClass(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
789 _ThisCommonIntegerFieldClass {fc}
793 template <typename OtherLibObjT>
794 CommonBaseEnumerationFieldClass
795 operator=(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
797 _ThisCommonIntegerFieldClass::operator=(fc);
801 CommonBaseEnumerationFieldClass<const bt_field_class> asConst() const noexcept
803 return CommonBaseEnumerationFieldClass<const bt_field_class> {*this};
806 std::uint64_t length() const noexcept
808 return bt_field_class_enumeration_get_mapping_count(this->libObjPtr());
811 Shared shared() const noexcept
813 return Shared::createWithRef(*this);
817 template <typename LibObjT, typename MappingT>
818 class CommonEnumerationFieldClass final : public CommonBaseEnumerationFieldClass<LibObjT>
821 using typename CommonBaseEnumerationFieldClass<LibObjT>::_ThisCommonBaseEnumerationFieldClass;
824 using typename CommonFieldClass<LibObjT>::LibObjPtr;
825 using Shared = SharedFieldClass<CommonEnumerationFieldClass, LibObjT>;
826 using Iterator = BorrowedObjectIterator<CommonEnumerationFieldClass>;
827 using Mapping = MappingT;
829 explicit CommonEnumerationFieldClass(const LibObjPtr libObjPtr) noexcept :
830 _ThisCommonBaseEnumerationFieldClass {libObjPtr}
832 BT_ASSERT_DBG(this->isEnumeration());
835 template <typename OtherLibObjT>
836 CommonEnumerationFieldClass(
837 const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept :
838 CommonEnumerationFieldClass {fc}
842 template <typename OtherLibObjT>
843 CommonEnumerationFieldClass
844 operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept
846 CommonEnumerationFieldClass::operator=(fc);
850 Mapping operator[](const std::uint64_t index) const noexcept
852 return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
853 this->libObjPtr(), index)};
856 OptionalBorrowedObject<Mapping> operator[](const bt2c::CStringView label) const noexcept
858 return internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
859 this->libObjPtr(), label);
862 void addMapping(const bt2c::CStringView label, const typename Mapping::RangeSet ranges) const
864 const auto status = internal::CommonEnumerationFieldClassSpec<MappingT>::addMapping(
865 this->libObjPtr(), label, ranges.libObjPtr());
867 if (status == BT_FIELD_CLASS_ENUMERATION_ADD_MAPPING_STATUS_MEMORY_ERROR) {
868 throw MemoryError {};
872 Iterator begin() const noexcept
874 return Iterator {*this, 0};
877 Iterator end() const noexcept
879 return Iterator {*this, this->length()};
882 Shared shared() const noexcept
884 return Shared::createWithRef(*this);
888 using EnumerationFieldClass = CommonBaseEnumerationFieldClass<bt_field_class>;
889 using ConstEnumerationFieldClass = CommonBaseEnumerationFieldClass<const bt_field_class>;
891 using UnsignedEnumerationFieldClass =
892 CommonEnumerationFieldClass<bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
894 using ConstUnsignedEnumerationFieldClass =
895 CommonEnumerationFieldClass<const bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
897 using SignedEnumerationFieldClass =
898 CommonEnumerationFieldClass<bt_field_class, ConstSignedEnumerationFieldClassMapping>;
900 using ConstSignedEnumerationFieldClass =
901 CommonEnumerationFieldClass<const bt_field_class, ConstSignedEnumerationFieldClassMapping>;
905 struct UnsignedEnumerationFieldClassTypeDescr
907 using Const = ConstUnsignedEnumerationFieldClass;
908 using NonConst = UnsignedEnumerationFieldClass;
912 struct TypeDescr<UnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
917 struct TypeDescr<ConstUnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
921 struct SignedEnumerationFieldClassTypeDescr
923 using Const = ConstSignedEnumerationFieldClass;
924 using NonConst = SignedEnumerationFieldClass;
928 struct TypeDescr<SignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
933 struct TypeDescr<ConstSignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
937 template <typename LibObjT>
938 struct CommonStructureFieldClassMemberSpec;
940 /* Functions specific to mutable structure field class members */
942 struct CommonStructureFieldClassMemberSpec<bt_field_class_structure_member> final
944 static bt_field_class *fieldClass(bt_field_class_structure_member * const libObjPtr) noexcept
946 return bt_field_class_structure_member_borrow_field_class(libObjPtr);
949 static bt_value *userAttributes(bt_field_class_structure_member * const libObjPtr) noexcept
951 return bt_field_class_structure_member_borrow_user_attributes(libObjPtr);
955 /* Functions specific to constant structure field class members */
957 struct CommonStructureFieldClassMemberSpec<const bt_field_class_structure_member> final
959 static const bt_field_class *
960 fieldClass(const bt_field_class_structure_member * const libObjPtr) noexcept
962 return bt_field_class_structure_member_borrow_field_class_const(libObjPtr);
965 static const bt_value *
966 userAttributes(const bt_field_class_structure_member * const libObjPtr) noexcept
968 return bt_field_class_structure_member_borrow_user_attributes_const(libObjPtr);
972 } /* namespace internal */
974 template <typename LibObjT>
975 class CommonStructureFieldClassMember final : public BorrowedObject<LibObjT>
978 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
979 using _FieldClass = internal::DepFc<LibObjT>;
982 using typename BorrowedObject<LibObjT>::LibObjPtr;
983 using UserAttributes = internal::DepUserAttrs<LibObjT>;
985 explicit CommonStructureFieldClassMember(const LibObjPtr libObjPtr) noexcept :
986 _ThisBorrowedObject {libObjPtr}
990 template <typename OtherLibObjT>
991 CommonStructureFieldClassMember(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
993 _ThisBorrowedObject {fc}
997 template <typename OtherLibObjT>
998 CommonStructureFieldClassMember<LibObjT>
999 operator=(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
1001 _ThisBorrowedObject::operator=(fc);
1005 CommonStructureFieldClassMember<const bt_field_class_structure_member> asConst() const noexcept
1007 return CommonStructureFieldClassMember<const bt_field_class_structure_member> {*this};
1010 bt2c::CStringView name() const noexcept
1012 return bt_field_class_structure_member_get_name(this->libObjPtr());
1015 _FieldClass fieldClass() const noexcept
1017 return _FieldClass {
1018 internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->libObjPtr())};
1021 template <typename LibValT>
1022 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1024 static_assert(!std::is_const<LibObjT>::value,
1025 "Not available with `bt2::ConstStructureFieldClassMember`.");
1027 bt_field_class_structure_member_set_user_attributes(this->libObjPtr(),
1028 userAttrs.libObjPtr());
1031 UserAttributes userAttributes() const noexcept
1033 return UserAttributes {
1034 internal::CommonStructureFieldClassMemberSpec<LibObjT>::userAttributes(
1035 this->libObjPtr())};
1039 using StructureFieldClassMember = CommonStructureFieldClassMember<bt_field_class_structure_member>;
1041 using ConstStructureFieldClassMember =
1042 CommonStructureFieldClassMember<const bt_field_class_structure_member>;
1044 namespace internal {
1046 struct StructureFieldClassMemberTypeDescr
1048 using Const = ConstStructureFieldClassMember;
1049 using NonConst = StructureFieldClassMember;
1053 struct TypeDescr<StructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
1058 struct TypeDescr<ConstStructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
1062 template <typename LibObjT>
1063 struct CommonStructureFieldClassSpec;
1065 /* Functions specific to mutable structure field classes */
1067 struct CommonStructureFieldClassSpec<bt_field_class> final
1069 static bt_field_class_structure_member *memberByIndex(bt_field_class * const libObjPtr,
1070 const std::uint64_t index) noexcept
1072 return bt_field_class_structure_borrow_member_by_index(libObjPtr, index);
1075 static bt_field_class_structure_member *memberByName(bt_field_class * const libObjPtr,
1076 const char * const name) noexcept
1078 return bt_field_class_structure_borrow_member_by_name(libObjPtr, name);
1082 /* Functions specific to constant structure field classes */
1084 struct CommonStructureFieldClassSpec<const bt_field_class> final
1086 static const bt_field_class_structure_member *
1087 memberByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1089 return bt_field_class_structure_borrow_member_by_index_const(libObjPtr, index);
1092 static const bt_field_class_structure_member *
1093 memberByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1095 return bt_field_class_structure_borrow_member_by_name_const(libObjPtr, name);
1099 } /* namespace internal */
1101 template <typename LibObjT>
1102 class CommonStructureFieldClass final : public CommonFieldClass<LibObjT>
1105 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1108 using typename CommonFieldClass<LibObjT>::LibObjPtr;
1109 using Shared = SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
1110 using Iterator = BorrowedObjectIterator<CommonStructureFieldClass<LibObjT>>;
1113 internal::DepType<LibObjT, StructureFieldClassMember, ConstStructureFieldClassMember>;
1115 explicit CommonStructureFieldClass(const LibObjPtr libObjPtr) noexcept :
1116 _ThisCommonFieldClass {libObjPtr}
1118 BT_ASSERT_DBG(this->isStructure());
1121 template <typename OtherLibObjT>
1122 CommonStructureFieldClass(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept :
1123 _ThisCommonFieldClass {fc}
1127 template <typename OtherLibObjT>
1128 CommonStructureFieldClass operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
1130 _ThisCommonFieldClass::operator=(fc);
1134 CommonStructureFieldClass<const bt_field_class> asConst() const noexcept
1136 return CommonStructureFieldClass<const bt_field_class> {*this};
1139 void appendMember(const bt2c::CStringView name, const FieldClass fc) const
1141 static_assert(!std::is_const<LibObjT>::value,
1142 "Not available with `bt2::ConstStructureFieldClass`.");
1145 bt_field_class_structure_append_member(this->libObjPtr(), name, fc.libObjPtr());
1147 if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
1148 throw MemoryError {};
1152 std::uint64_t length() const noexcept
1154 return bt_field_class_structure_get_member_count(this->libObjPtr());
1157 Iterator begin() const noexcept
1159 return Iterator {*this, 0};
1162 Iterator end() const noexcept
1164 return Iterator {*this, this->length()};
1167 Member operator[](const std::uint64_t index) const noexcept
1169 return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
1170 this->libObjPtr(), index)};
1173 OptionalBorrowedObject<Member> operator[](const bt2c::CStringView name) const noexcept
1175 return internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(),
1179 Shared shared() const noexcept
1181 return Shared::createWithRef(*this);
1185 using StructureFieldClass = CommonStructureFieldClass<bt_field_class>;
1186 using ConstStructureFieldClass = CommonStructureFieldClass<const bt_field_class>;
1188 namespace internal {
1190 struct StructureFieldClassTypeDescr
1192 using Const = ConstStructureFieldClass;
1193 using NonConst = StructureFieldClass;
1197 struct TypeDescr<StructureFieldClass> : public StructureFieldClassTypeDescr
1202 struct TypeDescr<ConstStructureFieldClass> : public StructureFieldClassTypeDescr
1206 template <typename LibObjT>
1207 struct CommonArrayFieldClassSpec;
1209 /* Functions specific to mutable array field classes */
1211 struct CommonArrayFieldClassSpec<bt_field_class> final
1213 static bt_field_class *elementFieldClass(bt_field_class * const libObjPtr) noexcept
1215 return bt_field_class_array_borrow_element_field_class(libObjPtr);
1219 /* Functions specific to constant array field classes */
1221 struct CommonArrayFieldClassSpec<const bt_field_class> final
1223 static const bt_field_class *elementFieldClass(const bt_field_class * const libObjPtr) noexcept
1225 return bt_field_class_array_borrow_element_field_class_const(libObjPtr);
1229 } /* namespace internal */
1231 template <typename LibObjT>
1232 class CommonArrayFieldClass : public CommonFieldClass<LibObjT>
1235 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1236 using _FieldClass = internal::DepFc<LibObjT>;
1239 using _ThisCommonArrayFieldClass = CommonArrayFieldClass<LibObjT>;
1242 using typename CommonFieldClass<LibObjT>::LibObjPtr;
1243 using Shared = SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
1245 explicit CommonArrayFieldClass(const LibObjPtr libObjPtr) noexcept :
1246 _ThisCommonFieldClass {libObjPtr}
1248 BT_ASSERT_DBG(this->isArray());
1251 template <typename OtherLibObjT>
1252 CommonArrayFieldClass(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept :
1253 _ThisCommonFieldClass {fc}
1257 template <typename OtherLibObjT>
1258 CommonArrayFieldClass operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
1260 _ThisCommonFieldClass::operator=(fc);
1264 CommonArrayFieldClass<const bt_field_class> asConst() const noexcept
1266 return CommonArrayFieldClass<const bt_field_class> {*this};
1269 _FieldClass elementFieldClass() const noexcept
1271 return _FieldClass {
1272 internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->libObjPtr())};
1275 Shared shared() const noexcept
1277 return Shared::createWithRef(*this);
1281 using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
1282 using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
1284 namespace internal {
1286 struct ArrayFieldClassTypeDescr
1288 using Const = ConstArrayFieldClass;
1289 using NonConst = ArrayFieldClass;
1293 struct TypeDescr<ArrayFieldClass> : public ArrayFieldClassTypeDescr
1298 struct TypeDescr<ConstArrayFieldClass> : public ArrayFieldClassTypeDescr
1302 } /* namespace internal */
1304 template <typename LibObjT>
1305 class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
1308 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1311 using typename CommonFieldClass<LibObjT>::LibObjPtr;
1312 using Shared = SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
1314 explicit CommonStaticArrayFieldClass(const LibObjPtr libObjPtr) noexcept :
1315 _ThisCommonArrayFieldClass {libObjPtr}
1317 BT_ASSERT_DBG(this->isStaticArray());
1320 template <typename OtherLibObjT>
1321 CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept :
1322 _ThisCommonArrayFieldClass {fc}
1326 template <typename OtherLibObjT>
1327 CommonStaticArrayFieldClass
1328 operator=(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept
1330 _ThisCommonArrayFieldClass::operator=(fc);
1334 CommonStaticArrayFieldClass<const bt_field_class> asConst() const noexcept
1336 return CommonStaticArrayFieldClass<const bt_field_class> {*this};
1339 std::uint64_t length() const noexcept
1341 return bt_field_class_array_static_get_length(this->libObjPtr());
1344 Shared shared() const noexcept
1346 return Shared::createWithRef(*this);
1350 using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
1351 using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
1353 namespace internal {
1355 struct StaticArrayFieldClassTypeDescr
1357 using Const = ConstStaticArrayFieldClass;
1358 using NonConst = StaticArrayFieldClass;
1362 struct TypeDescr<StaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
1367 struct TypeDescr<ConstStaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
1371 } /* namespace internal */
1373 template <typename LibObjT>
1374 class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
1377 using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1380 using typename CommonFieldClass<LibObjT>::LibObjPtr;
1381 using Shared = SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
1383 explicit CommonDynamicArrayWithLengthFieldClass(const LibObjPtr libObjPtr) noexcept :
1384 _ThisCommonArrayFieldClass {libObjPtr}
1386 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
1389 template <typename OtherLibObjT>
1390 CommonDynamicArrayWithLengthFieldClass(
1391 const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept :
1392 _ThisCommonArrayFieldClass {fc}
1396 template <typename OtherLibObjT>
1397 CommonDynamicArrayWithLengthFieldClass
1398 operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept
1400 _ThisCommonArrayFieldClass::operator=(fc);
1404 CommonDynamicArrayWithLengthFieldClass<const bt_field_class> asConst() const noexcept
1406 return CommonDynamicArrayWithLengthFieldClass<const bt_field_class> {*this};
1409 ConstFieldPath lengthFieldPath() const noexcept
1411 return ConstFieldPath {
1412 bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
1413 this->libObjPtr())};
1416 Shared shared() const noexcept
1418 return Shared::createWithRef(*this);
1422 using DynamicArrayWithLengthFieldClass = CommonDynamicArrayWithLengthFieldClass<bt_field_class>;
1424 using ConstDynamicArrayWithLengthFieldClass =
1425 CommonDynamicArrayWithLengthFieldClass<const bt_field_class>;
1427 namespace internal {
1429 struct DynamicArrayWithLengthFieldClassTypeDescr
1431 using Const = ConstDynamicArrayWithLengthFieldClass;
1432 using NonConst = DynamicArrayWithLengthFieldClass;
1436 struct TypeDescr<DynamicArrayWithLengthFieldClass> :
1437 public DynamicArrayWithLengthFieldClassTypeDescr
1442 struct TypeDescr<ConstDynamicArrayWithLengthFieldClass> :
1443 public DynamicArrayWithLengthFieldClassTypeDescr
1447 template <typename LibObjT>
1448 struct CommonOptionFieldClassSpec;
1450 /* Functions specific to mutable option field classes */
1452 struct CommonOptionFieldClassSpec<bt_field_class> final
1454 static bt_field_class *fieldClass(bt_field_class * const libObjPtr) noexcept
1456 return bt_field_class_option_borrow_field_class(libObjPtr);
1460 /* Functions specific to constant option field classes */
1462 struct CommonOptionFieldClassSpec<const bt_field_class> final
1464 static const bt_field_class *fieldClass(const bt_field_class * const libObjPtr) noexcept
1466 return bt_field_class_option_borrow_field_class_const(libObjPtr);
1470 } /* namespace internal */
1472 template <typename LibObjT>
1473 class CommonOptionFieldClass : public CommonFieldClass<LibObjT>
1476 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1477 using _FieldClass = internal::DepFc<LibObjT>;
1480 using _ThisCommonOptionFieldClass = CommonOptionFieldClass<LibObjT>;
1483 using typename CommonFieldClass<LibObjT>::LibObjPtr;
1484 using Shared = SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
1486 explicit CommonOptionFieldClass(const LibObjPtr libObjPtr) noexcept :
1487 _ThisCommonFieldClass {libObjPtr}
1489 BT_ASSERT_DBG(this->isOption());
1492 template <typename OtherLibObjT>
1493 CommonOptionFieldClass(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept :
1494 _ThisCommonFieldClass {fc}
1498 template <typename OtherLibObjT>
1499 CommonOptionFieldClass operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
1501 _ThisCommonFieldClass::operator=(fc);
1505 CommonOptionFieldClass<const bt_field_class> asConst() const noexcept
1507 return CommonOptionFieldClass<const bt_field_class> {*this};
1510 _FieldClass fieldClass() const noexcept
1512 return _FieldClass {
1513 internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->libObjPtr())};
1516 Shared shared() const noexcept
1518 return Shared::createWithRef(*this);
1522 using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
1523 using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
1525 namespace internal {
1527 struct OptionFieldClassTypeDescr
1529 using Const = ConstOptionFieldClass;
1530 using NonConst = OptionFieldClass;
1534 struct TypeDescr<OptionFieldClass> : public OptionFieldClassTypeDescr
1539 struct TypeDescr<ConstOptionFieldClass> : public OptionFieldClassTypeDescr
1543 } /* namespace internal */
1545 template <typename LibObjT>
1546 class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
1549 using typename CommonOptionFieldClass<LibObjT>::_ThisCommonOptionFieldClass;
1552 using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<LibObjT>;
1555 using typename CommonFieldClass<LibObjT>::LibObjPtr;
1556 using Shared = SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
1558 explicit CommonOptionWithSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
1559 _ThisCommonOptionFieldClass {libObjPtr}
1561 BT_ASSERT_DBG(this->isOptionWithSelector());
1564 template <typename OtherLibObjT>
1565 CommonOptionWithSelectorFieldClass(
1566 const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept :
1567 _ThisCommonOptionFieldClass {fc}
1571 template <typename OtherLibObjT>
1572 CommonOptionWithSelectorFieldClass
1573 operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept
1575 _ThisCommonOptionFieldClass::operator=(fc);
1579 CommonOptionWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
1581 return CommonOptionWithSelectorFieldClass<const bt_field_class> {*this};
1584 ConstFieldPath selectorFieldPath() const noexcept
1586 return ConstFieldPath {
1587 bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
1588 this->libObjPtr())};
1591 Shared shared() const noexcept
1593 return Shared::createWithRef(*this);
1597 using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
1598 using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
1600 namespace internal {
1602 struct OptionWithSelectorFieldClassTypeDescr
1604 using Const = ConstOptionWithSelectorFieldClass;
1605 using NonConst = OptionWithSelectorFieldClass;
1609 struct TypeDescr<OptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
1614 struct TypeDescr<ConstOptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
1618 } /* namespace internal */
1620 template <typename LibObjT>
1621 class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1624 using typename CommonOptionWithSelectorFieldClass<
1625 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1628 using typename CommonFieldClass<LibObjT>::LibObjPtr;
1629 using Shared = SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
1631 explicit CommonOptionWithBoolSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
1632 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1634 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
1637 template <typename OtherLibObjT>
1638 CommonOptionWithBoolSelectorFieldClass(
1639 const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept :
1640 _ThisCommonOptionWithSelectorFieldClass {fc}
1644 template <typename OtherLibObjT>
1645 CommonOptionWithBoolSelectorFieldClass
1646 operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept
1648 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1652 CommonOptionWithBoolSelectorFieldClass<const bt_field_class> asConst() const noexcept
1654 return CommonOptionWithBoolSelectorFieldClass<const bt_field_class> {*this};
1657 bool selectorIsReversed() const noexcept
1659 return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
1663 Shared shared() const noexcept
1665 return Shared::createWithRef(*this);
1669 using OptionWithBoolSelectorFieldClass = CommonOptionWithBoolSelectorFieldClass<bt_field_class>;
1671 using ConstOptionWithBoolSelectorFieldClass =
1672 CommonOptionWithBoolSelectorFieldClass<const bt_field_class>;
1674 namespace internal {
1676 struct OptionWithBoolSelectorFieldClassTypeDescr
1678 using Const = ConstOptionWithBoolSelectorFieldClass;
1679 using NonConst = OptionWithBoolSelectorFieldClass;
1683 struct TypeDescr<OptionWithBoolSelectorFieldClass> :
1684 public OptionWithBoolSelectorFieldClassTypeDescr
1689 struct TypeDescr<ConstOptionWithBoolSelectorFieldClass> :
1690 public OptionWithBoolSelectorFieldClassTypeDescr
1694 template <typename RangeSetT>
1695 struct CommonOptionWithIntegerSelectorFieldClassSpec;
1697 /* Functions specific to option field classes with unsigned integer ranges */
1699 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstUnsignedIntegerRangeSet> final
1701 static const bt_integer_range_set_unsigned *
1702 ranges(const bt_field_class * const libObjPtr) noexcept
1704 return bt_field_class_option_with_selector_field_integer_unsigned_borrow_selector_ranges_const(
1709 /* Functions specific to option field classes with signed ranges */
1711 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstSignedIntegerRangeSet> final
1713 static const bt_integer_range_set_signed *
1714 ranges(const bt_field_class * const libObjPtr) noexcept
1716 return bt_field_class_option_with_selector_field_integer_signed_borrow_selector_ranges_const(
1721 } /* namespace internal */
1723 template <typename LibObjT, typename RangeSetT>
1724 class CommonOptionWithIntegerSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1727 using typename CommonOptionWithSelectorFieldClass<
1728 LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1731 using typename CommonFieldClass<LibObjT>::LibObjPtr;
1732 using Shared = SharedFieldClass<CommonOptionWithIntegerSelectorFieldClass, LibObjT>;
1733 using RangeSet = RangeSetT;
1735 explicit CommonOptionWithIntegerSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
1736 _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1738 BT_ASSERT_DBG(this->isOptionWithIntegerSelector());
1741 template <typename OtherLibObjT>
1742 CommonOptionWithIntegerSelectorFieldClass(
1743 const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept :
1744 _ThisCommonOptionWithSelectorFieldClass {fc}
1748 template <typename OtherLibObjT>
1749 CommonOptionWithIntegerSelectorFieldClass
1750 operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept
1752 _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
1756 RangeSet ranges() const noexcept
1758 return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
1759 this->libObjPtr())};
1762 Shared shared() const noexcept
1764 return Shared::createWithRef(*this);
1768 using OptionWithUnsignedIntegerSelectorFieldClass =
1769 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstUnsignedIntegerRangeSet>;
1771 using ConstOptionWithUnsignedIntegerSelectorFieldClass =
1772 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstUnsignedIntegerRangeSet>;
1774 using OptionWithSignedIntegerSelectorFieldClass =
1775 CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstSignedIntegerRangeSet>;
1777 using ConstOptionWithSignedIntegerSelectorFieldClass =
1778 CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstSignedIntegerRangeSet>;
1780 namespace internal {
1782 struct OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
1784 using Const = ConstOptionWithUnsignedIntegerSelectorFieldClass;
1785 using NonConst = OptionWithUnsignedIntegerSelectorFieldClass;
1789 struct TypeDescr<OptionWithUnsignedIntegerSelectorFieldClass> :
1790 public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
1795 struct TypeDescr<ConstOptionWithUnsignedIntegerSelectorFieldClass> :
1796 public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
1800 struct OptionWithSignedIntegerSelectorFieldClassTypeDescr
1802 using Const = ConstOptionWithSignedIntegerSelectorFieldClass;
1803 using NonConst = OptionWithSignedIntegerSelectorFieldClass;
1807 struct TypeDescr<OptionWithSignedIntegerSelectorFieldClass> :
1808 public OptionWithSignedIntegerSelectorFieldClassTypeDescr
1813 struct TypeDescr<ConstOptionWithSignedIntegerSelectorFieldClass> :
1814 public OptionWithSignedIntegerSelectorFieldClassTypeDescr
1818 template <typename LibObjT>
1819 struct CommonVariantFieldClassOptionSpec;
1821 /* Functions specific to mutable variant field class options */
1823 struct CommonVariantFieldClassOptionSpec<bt_field_class_variant_option> final
1825 static bt_field_class *fieldClass(bt_field_class_variant_option * const libObjPtr) noexcept
1827 return bt_field_class_variant_option_borrow_field_class(libObjPtr);
1830 static bt_value *userAttributes(bt_field_class_variant_option * const libObjPtr) noexcept
1832 return bt_field_class_variant_option_borrow_user_attributes(libObjPtr);
1836 /* Functions specific to constant variant field class options */
1838 struct CommonVariantFieldClassOptionSpec<const bt_field_class_variant_option> final
1840 static const bt_field_class *
1841 fieldClass(const bt_field_class_variant_option * const libObjPtr) noexcept
1843 return bt_field_class_variant_option_borrow_field_class_const(libObjPtr);
1846 static const bt_value *
1847 userAttributes(const bt_field_class_variant_option * const libObjPtr) noexcept
1849 return bt_field_class_variant_option_borrow_user_attributes_const(libObjPtr);
1853 } /* namespace internal */
1855 template <typename LibObjT>
1856 class CommonVariantFieldClassOption : public BorrowedObject<LibObjT>
1859 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1860 using _FieldClass = internal::DepFc<LibObjT>;
1863 using typename BorrowedObject<LibObjT>::LibObjPtr;
1864 using UserAttributes = internal::DepUserAttrs<LibObjT>;
1866 explicit CommonVariantFieldClassOption(const LibObjPtr libObjPtr) noexcept :
1867 _ThisBorrowedObject {libObjPtr}
1871 template <typename OtherLibObjT>
1872 CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept :
1873 _ThisBorrowedObject {fc}
1877 template <typename OtherLibObjT>
1878 CommonVariantFieldClassOption
1879 operator=(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept
1881 _ThisBorrowedObject::operator=(fc);
1885 CommonVariantFieldClassOption<const bt_field_class_variant_option> asConst() const noexcept
1887 return CommonVariantFieldClassOption<const bt_field_class_variant_option> {*this};
1890 bt2c::CStringView name() const noexcept
1892 return bt_field_class_variant_option_get_name(this->libObjPtr());
1895 _FieldClass fieldClass() const noexcept
1897 return _FieldClass {
1898 internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
1901 template <typename LibValT>
1902 void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1904 static_assert(!std::is_const<LibObjT>::value,
1905 "Not available with `bt2::ConstVariantFieldClassOption`.");
1907 bt_field_class_variant_option_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1910 UserAttributes userAttributes() const noexcept
1912 return UserAttributes {internal::CommonVariantFieldClassOptionSpec<LibObjT>::userAttributes(
1913 this->libObjPtr())};
1917 using VariantFieldClassOption = CommonVariantFieldClassOption<bt_field_class_variant_option>;
1919 using ConstVariantFieldClassOption =
1920 CommonVariantFieldClassOption<const bt_field_class_variant_option>;
1922 namespace internal {
1924 struct VariantFieldClassOptionTypeDescr
1926 using Const = ConstVariantFieldClassOption;
1927 using NonConst = VariantFieldClassOption;
1931 struct TypeDescr<VariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
1936 struct TypeDescr<ConstVariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
1940 template <typename LibObjT>
1941 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
1943 /* Functions specific to variant field class options with unsigned integer selector */
1945 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1946 const bt_field_class_variant_with_selector_field_integer_unsigned_option>
1949 static const bt_integer_range_set_unsigned *
1950 ranges(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1951 * const libObjPtr) noexcept
1953 return bt_field_class_variant_with_selector_field_integer_unsigned_option_borrow_ranges_const(
1957 static const bt_field_class_variant_option *
1958 asBaseOption(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1959 * const libObjPtr) noexcept
1961 return bt_field_class_variant_with_selector_field_integer_unsigned_option_as_option_const(
1966 /* Functions specific to variant field class options with signed integer selector */
1968 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1969 const bt_field_class_variant_with_selector_field_integer_signed_option>
1972 static const bt_integer_range_set_signed *
1973 ranges(const bt_field_class_variant_with_selector_field_integer_signed_option
1974 * const libObjPtr) noexcept
1976 return bt_field_class_variant_with_selector_field_integer_signed_option_borrow_ranges_const(
1980 static const bt_field_class_variant_option *
1981 asBaseOption(const bt_field_class_variant_with_selector_field_integer_signed_option
1982 * const libObjPtr) noexcept
1984 return bt_field_class_variant_with_selector_field_integer_signed_option_as_option_const(
1989 } /* namespace internal */
1991 template <typename LibObjT>
1992 class ConstVariantWithIntegerSelectorFieldClassOption : public BorrowedObject<LibObjT>
1995 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1996 using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
1999 using typename BorrowedObject<LibObjT>::LibObjPtr;
2001 using RangeSet = typename std::conditional<
2004 const bt_field_class_variant_with_selector_field_integer_unsigned_option>::value,
2005 ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
2007 explicit ConstVariantWithIntegerSelectorFieldClassOption(const LibObjPtr libObjPtr) noexcept :
2008 _ThisBorrowedObject {libObjPtr}
2012 template <typename OtherLibObjT>
2013 ConstVariantWithIntegerSelectorFieldClassOption(
2014 const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept :
2015 _ThisBorrowedObject {fc}
2019 template <typename OtherLibObjT>
2020 ConstVariantWithIntegerSelectorFieldClassOption
2021 operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept
2023 _ThisBorrowedObject::operator=(fc);
2027 ConstVariantFieldClassOption asBaseOption() const noexcept
2029 return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())};
2032 bt2c::CStringView name() const noexcept
2034 return this->asBaseOption().name();
2037 ConstFieldClass fieldClass() const noexcept
2039 return this->asBaseOption().fieldClass();
2042 RangeSet ranges() const noexcept
2044 return RangeSet {_Spec::ranges(this->libObjPtr())};
2048 using ConstVariantWithUnsignedIntegerSelectorFieldClassOption =
2049 ConstVariantWithIntegerSelectorFieldClassOption<
2050 const bt_field_class_variant_with_selector_field_integer_unsigned_option>;
2052 using ConstVariantWithSignedIntegerSelectorFieldClassOption =
2053 ConstVariantWithIntegerSelectorFieldClassOption<
2054 const bt_field_class_variant_with_selector_field_integer_signed_option>;
2056 namespace internal {
2058 template <typename LibObjT>
2059 struct CommonVariantFieldClassSpec;
2061 /* Functions specific to mutable variant field classes */
2063 struct CommonVariantFieldClassSpec<bt_field_class> final
2065 static bt_field_class_variant_option *optionByIndex(bt_field_class * const libObjPtr,
2066 const std::uint64_t index) noexcept
2068 return bt_field_class_variant_borrow_option_by_index(libObjPtr, index);
2071 static bt_field_class_variant_option *optionByName(bt_field_class * const libObjPtr,
2072 const char * const name) noexcept
2074 return bt_field_class_variant_borrow_option_by_name(libObjPtr, name);
2078 /* Functions specific to constant variant field classes */
2080 struct CommonVariantFieldClassSpec<const bt_field_class> final
2082 static const bt_field_class_variant_option *
2083 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2085 return bt_field_class_variant_borrow_option_by_index_const(libObjPtr, index);
2088 static const bt_field_class_variant_option *optionByName(const bt_field_class * const libObjPtr,
2089 const char * const name) noexcept
2091 return bt_field_class_variant_borrow_option_by_name_const(libObjPtr, name);
2095 } /* namespace internal */
2097 template <typename LibObjT>
2098 class CommonVariantFieldClass : public CommonFieldClass<LibObjT>
2101 using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
2104 using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
2107 using typename CommonFieldClass<LibObjT>::LibObjPtr;
2108 using Shared = SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
2109 using Iterator = BorrowedObjectIterator<CommonVariantFieldClass>;
2112 internal::DepType<LibObjT, VariantFieldClassOption, ConstVariantFieldClassOption>;
2114 explicit CommonVariantFieldClass(const LibObjPtr libObjPtr) noexcept :
2115 _ThisCommonFieldClass {libObjPtr}
2117 BT_ASSERT_DBG(this->isVariant());
2120 template <typename OtherLibObjT>
2121 CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept :
2122 _ThisCommonFieldClass {fc}
2126 template <typename OtherLibObjT>
2127 CommonVariantFieldClass operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
2129 _ThisCommonFieldClass::operator=(fc);
2133 CommonVariantFieldClass<const bt_field_class> asConst() const noexcept
2135 return CommonVariantFieldClass<const bt_field_class> {*this};
2138 std::uint64_t length() const noexcept
2140 return bt_field_class_variant_get_option_count(this->libObjPtr());
2143 Iterator begin() const noexcept
2145 return Iterator {*this, 0};
2148 Iterator end() const noexcept
2150 return Iterator {*this, this->length()};
2153 Option operator[](const std::uint64_t index) const noexcept
2155 return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
2156 this->libObjPtr(), index)};
2159 OptionalBorrowedObject<Option> operator[](const bt2c::CStringView name) const noexcept
2161 return internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(),
2165 Shared shared() const noexcept
2167 return Shared::createWithRef(*this);
2171 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
2172 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
2174 namespace internal {
2176 struct VariantFieldClassTypeDescr
2178 using Const = ConstVariantFieldClass;
2179 using NonConst = VariantFieldClass;
2183 struct TypeDescr<VariantFieldClass> : public VariantFieldClassTypeDescr
2188 struct TypeDescr<ConstVariantFieldClass> : public VariantFieldClassTypeDescr
2192 } /* namespace internal */
2194 template <typename LibObjT>
2195 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
2198 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
2201 using typename CommonFieldClass<LibObjT>::LibObjPtr;
2202 using Shared = SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
2204 explicit CommonVariantWithoutSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
2205 _ThisCommonVariantFieldClass {libObjPtr}
2207 BT_ASSERT_DBG(this->isVariantWithoutSelector());
2210 template <typename OtherLibObjT>
2211 CommonVariantWithoutSelectorFieldClass(
2212 const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept :
2213 _ThisCommonVariantFieldClass {fc}
2217 template <typename OtherLibObjT>
2218 CommonVariantWithoutSelectorFieldClass
2219 operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept
2221 _ThisCommonVariantFieldClass::operator=(fc);
2225 CommonVariantWithoutSelectorFieldClass<const bt_field_class> asConst() const noexcept
2227 return CommonVariantWithoutSelectorFieldClass<const bt_field_class> {*this};
2230 void appendOption(const char * const name, const FieldClass fc) const
2232 static_assert(!std::is_const<LibObjT>::value,
2233 "Not available with `bt2::ConstVariantWithoutSelectorFieldClass`.");
2235 const auto status = bt_field_class_variant_without_selector_append_option(
2236 this->libObjPtr(), name, fc.libObjPtr());
2239 BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2240 throw MemoryError {};
2244 void appendOption(const bt2c::CStringView name, const FieldClass fc) const
2246 return this->appendOption(name.data(), fc);
2249 void appendOption(const bt2s::optional<std::string>& name, const FieldClass fc) const
2251 this->appendOption(name ? name->data() : nullptr, fc);
2254 Shared shared() const noexcept
2256 return Shared::createWithRef(*this);
2260 using VariantWithoutSelectorFieldClass = CommonVariantWithoutSelectorFieldClass<bt_field_class>;
2261 using ConstVariantWithoutSelectorFieldClass =
2262 CommonVariantWithoutSelectorFieldClass<const bt_field_class>;
2264 namespace internal {
2266 struct VariantWithoutSelectorFieldClassTypeDescr
2268 using Const = ConstVariantWithoutSelectorFieldClass;
2269 using NonConst = VariantWithoutSelectorFieldClass;
2273 struct TypeDescr<VariantWithoutSelectorFieldClass> :
2274 public VariantWithoutSelectorFieldClassTypeDescr
2279 struct TypeDescr<ConstVariantWithoutSelectorFieldClass> :
2280 public VariantWithoutSelectorFieldClassTypeDescr
2284 template <typename OptionT>
2285 struct CommonVariantWithIntegerSelectorFieldClassSpec;
2287 /* Functions specific to variant field classes with unsigned integer selector */
2289 struct CommonVariantWithIntegerSelectorFieldClassSpec<
2290 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2293 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
2294 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2296 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_index_const(
2300 static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
2301 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
2303 return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_name_const(
2307 static bt_field_class_variant_with_selector_field_integer_append_option_status
2308 appendOption(bt_field_class * const libObjPtr, const char * const name,
2309 bt_field_class * const libOptFcPtr,
2310 const bt_integer_range_set_unsigned * const libRangesPtr)
2312 return bt_field_class_variant_with_selector_field_integer_unsigned_append_option(
2313 libObjPtr, name, libOptFcPtr, libRangesPtr);
2317 /* Functions specific to variant field classes with signed integer selector */
2319 struct CommonVariantWithIntegerSelectorFieldClassSpec<
2320 ConstVariantWithSignedIntegerSelectorFieldClassOption>
2323 static const bt_field_class_variant_with_selector_field_integer_signed_option *
2324 optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2326 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_index_const(
2330 static const bt_field_class_variant_with_selector_field_integer_signed_option *
2331 optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
2333 return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_name_const(
2337 static bt_field_class_variant_with_selector_field_integer_append_option_status
2338 appendOption(bt_field_class * const libObjPtr, const char * const name,
2339 bt_field_class * const libOptFcPtr,
2340 const bt_integer_range_set_signed * const libRangesPtr)
2342 return bt_field_class_variant_with_selector_field_integer_signed_append_option(
2343 libObjPtr, name, libOptFcPtr, libRangesPtr);
2347 } /* namespace internal */
2349 template <typename LibObjT>
2350 class CommonVariantWithSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
2353 using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
2356 using _ThisCommonVariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<LibObjT>;
2359 using typename CommonFieldClass<LibObjT>::LibObjPtr;
2360 using Shared = SharedFieldClass<_ThisCommonVariantWithSelectorFieldClass, LibObjT>;
2362 explicit CommonVariantWithSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
2363 _ThisCommonVariantFieldClass {libObjPtr}
2365 BT_ASSERT_DBG(this->isVariantWithSelector());
2368 template <typename OtherLibObjT>
2369 CommonVariantWithSelectorFieldClass(
2370 const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept :
2371 _ThisCommonVariantFieldClass {fc}
2375 template <typename OtherLibObjT>
2376 CommonVariantWithSelectorFieldClass
2377 operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept
2379 _ThisCommonVariantFieldClass::operator=(fc);
2383 CommonVariantWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
2385 return CommonVariantWithSelectorFieldClass<const bt_field_class> {*this};
2388 ConstFieldPath selectorFieldPath() const noexcept
2390 return ConstFieldPath {
2391 bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
2392 this->libObjPtr())};
2395 Shared shared() const noexcept
2397 return Shared::createWithRef(*this);
2401 using VariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<bt_field_class>;
2402 using ConstVariantWithSelectorFieldClass =
2403 CommonVariantWithSelectorFieldClass<const bt_field_class>;
2405 template <typename LibObjT, typename OptionT>
2406 class CommonVariantWithIntegerSelectorFieldClass :
2407 public CommonVariantWithSelectorFieldClass<LibObjT>
2410 using typename CommonVariantWithSelectorFieldClass<
2411 LibObjT>::_ThisCommonVariantWithSelectorFieldClass;
2413 using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
2416 using typename CommonFieldClass<LibObjT>::LibObjPtr;
2417 using Shared = SharedFieldClass<CommonVariantWithIntegerSelectorFieldClass, LibObjT>;
2418 using Option = OptionT;
2421 BorrowedObjectIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>>;
2423 explicit CommonVariantWithIntegerSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
2424 _ThisCommonVariantWithSelectorFieldClass {libObjPtr}
2426 BT_ASSERT_DBG(this->isVariant());
2429 template <typename OtherLibObjT>
2430 CommonVariantWithIntegerSelectorFieldClass(
2431 const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept :
2432 _ThisCommonVariantWithSelectorFieldClass {fc}
2436 template <typename OtherLibObjT>
2437 CommonVariantWithIntegerSelectorFieldClass
2438 operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept
2440 _ThisCommonVariantWithSelectorFieldClass::operator=(fc);
2444 Option operator[](const std::uint64_t index) const noexcept
2446 return Option {_Spec::optionByIndex(this->libObjPtr(), index)};
2449 OptionalBorrowedObject<Option> operator[](const bt2c::CStringView name) const noexcept
2451 return _Spec::optionByName(this->libObjPtr(), name);
2454 void appendOption(const char * const name, const FieldClass fc,
2455 const typename Option::RangeSet ranges) const
2458 !std::is_const<LibObjT>::value,
2459 "Not available with `bt2::ConstVariantWithUnsignedIntegerSelectorFieldClass`.");
2462 _Spec::appendOption(this->libObjPtr(), name, fc.libObjPtr(), ranges.libObjPtr());
2465 BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2466 throw MemoryError {};
2470 void appendOption(const bt2c::CStringView name, const FieldClass fc,
2471 const typename Option::RangeSet ranges) const
2473 return this->appendOption(name.data(), fc, ranges);
2476 void appendOption(const bt2s::optional<std::string>& name, const FieldClass fc,
2477 const typename Option::RangeSet ranges) const
2479 this->appendOption(name ? name->data() : nullptr, fc, ranges);
2482 Iterator begin() const noexcept
2484 return Iterator {*this, 0};
2487 Iterator end() const noexcept
2489 return Iterator {*this, this->length()};
2492 Shared shared() const noexcept
2494 return Shared::createWithRef(*this);
2498 using VariantWithUnsignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2499 bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2501 using ConstVariantWithUnsignedIntegerSelectorFieldClass =
2502 CommonVariantWithIntegerSelectorFieldClass<
2503 const bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2505 using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2506 bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2508 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2509 const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2511 namespace internal {
2513 struct VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2515 using Const = ConstVariantWithUnsignedIntegerSelectorFieldClass;
2516 using NonConst = VariantWithUnsignedIntegerSelectorFieldClass;
2520 struct TypeDescr<VariantWithUnsignedIntegerSelectorFieldClass> :
2521 public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2526 struct TypeDescr<ConstVariantWithUnsignedIntegerSelectorFieldClass> :
2527 public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2531 struct VariantWithSignedIntegerSelectorFieldClassTypeDescr
2533 using Const = ConstVariantWithSignedIntegerSelectorFieldClass;
2534 using NonConst = VariantWithSignedIntegerSelectorFieldClass;
2538 struct TypeDescr<VariantWithSignedIntegerSelectorFieldClass> :
2539 public VariantWithSignedIntegerSelectorFieldClassTypeDescr
2544 struct TypeDescr<ConstVariantWithSignedIntegerSelectorFieldClass> :
2545 public VariantWithSignedIntegerSelectorFieldClassTypeDescr
2549 } /* namespace internal */
2551 template <typename LibObjT>
2552 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
2554 BT_ASSERT_DBG(this->isBitArray());
2555 return CommonBitArrayFieldClass<LibObjT> {this->libObjPtr()};
2558 template <typename LibObjT>
2559 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
2561 BT_ASSERT_DBG(this->isInteger());
2562 return CommonIntegerFieldClass<LibObjT> {this->libObjPtr()};
2565 template <typename LibObjT>
2566 CommonBaseEnumerationFieldClass<LibObjT> CommonFieldClass<LibObjT>::asEnumeration() const noexcept
2568 BT_ASSERT_DBG(this->isEnumeration());
2569 return CommonBaseEnumerationFieldClass<LibObjT> {this->libObjPtr()};
2572 template <typename LibObjT>
2573 CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping>
2574 CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
2576 BT_ASSERT_DBG(this->isUnsignedEnumeration());
2577 return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
2581 template <typename LibObjT>
2582 CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping>
2583 CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
2585 BT_ASSERT_DBG(this->isSignedEnumeration());
2586 return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
2590 template <typename LibObjT>
2591 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
2593 BT_ASSERT_DBG(this->isStructure());
2594 return CommonStructureFieldClass<LibObjT> {this->libObjPtr()};
2597 template <typename LibObjT>
2598 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
2600 BT_ASSERT_DBG(this->isArray());
2601 return CommonArrayFieldClass<LibObjT> {this->libObjPtr()};
2604 template <typename LibObjT>
2605 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
2607 BT_ASSERT_DBG(this->isStaticArray());
2608 return CommonStaticArrayFieldClass<LibObjT> {this->libObjPtr()};
2611 template <typename LibObjT>
2612 CommonDynamicArrayWithLengthFieldClass<LibObjT>
2613 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
2615 BT_ASSERT_DBG(this->isDynamicArrayWithLength());
2616 return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->libObjPtr()};
2619 template <typename LibObjT>
2620 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
2622 BT_ASSERT_DBG(this->isOption());
2623 return CommonOptionFieldClass<LibObjT> {this->libObjPtr()};
2626 template <typename LibObjT>
2627 CommonOptionWithSelectorFieldClass<LibObjT>
2628 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
2630 BT_ASSERT_DBG(this->isOptionWithSelector());
2631 return CommonOptionWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
2634 template <typename LibObjT>
2635 CommonOptionWithBoolSelectorFieldClass<LibObjT>
2636 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
2638 BT_ASSERT_DBG(this->isOptionWithBoolSelector());
2639 return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->libObjPtr()};
2642 template <typename LibObjT>
2643 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
2644 CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
2646 BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
2647 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
2651 template <typename LibObjT>
2652 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
2653 CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
2655 BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
2656 return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
2660 template <typename LibObjT>
2661 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
2663 BT_ASSERT_DBG(this->isVariant());
2664 return CommonVariantFieldClass<LibObjT> {this->libObjPtr()};
2667 template <typename LibObjT>
2668 CommonVariantWithoutSelectorFieldClass<LibObjT>
2669 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
2671 BT_ASSERT_DBG(this->isVariantWithoutSelector());
2672 return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->libObjPtr()};
2675 template <typename LibObjT>
2676 CommonVariantWithSelectorFieldClass<LibObjT>
2677 CommonFieldClass<LibObjT>::asVariantWithSelector() const noexcept
2679 BT_ASSERT_DBG(this->isVariantWithSelector());
2680 return CommonVariantWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
2683 template <typename LibObjT>
2684 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2685 ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2686 CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
2688 BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
2689 return CommonVariantWithIntegerSelectorFieldClass<
2690 LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
2693 template <typename LibObjT>
2694 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2695 ConstVariantWithSignedIntegerSelectorFieldClassOption>
2696 CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
2698 BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
2699 return CommonVariantWithIntegerSelectorFieldClass<
2700 LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
2703 } /* namespace bt2 */
2705 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP */