src/cpp-common/bt2/field-class.hpp

   1 /*
   2  * Copyright (c) 2020 Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * SPDX-License-Identifier: MIT
   5  */
   6
   7 #ifndef BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP
   9
  10 #include <cstdint>
  11 #include <type_traits>
  12
  13 #include <babeltrace2/babeltrace.h>
  14
  15 #include "common/assert.h"
  16 #include "cpp-common/bt2c/c-string-view.hpp"
  17 #include "cpp-common/bt2s/optional.hpp"
  18
  19 #include "borrowed-object-iterator.hpp"
  20 #include "borrowed-object.hpp"
  21 #include "exc.hpp"
  22 #include "field-location.hpp"
  23 #include "field-path.hpp"
  24 #include "integer-range-set.hpp"
  25 #include "internal/utils.hpp"
  26 #include "optional-borrowed-object.hpp"
  27 #include "shared-object.hpp"
  28 #include "value.hpp"
  29
  30 namespace bt2 {
  31 namespace internal {
  32
  33 struct FieldClassRefFuncs final
  34 {
  35     static void get(const bt_field_class * const libObjPtr) noexcept
  36     {
  37         bt_field_class_get_ref(libObjPtr);
  38     }
  39
  40     static void put(const bt_field_class * const libObjPtr) noexcept
  41     {
  42         bt_field_class_put_ref(libObjPtr);
  43     }
  44 };
  45
  46 template <typename LibObjT>
  47 struct CommonFieldClassSpec;
  48
  49 /* Functions specific to mutable field classes */
  50 template <>
  51 struct CommonFieldClassSpec<bt_field_class> final
  52 {
  53     static bt_value *userAttributes(bt_field_class * const libObjPtr) noexcept
  54     {
  55         return bt_field_class_borrow_user_attributes(libObjPtr);
  56     }
  57 };
  58
  59 /* Functions specific to constant field classes */
  60 template <>
  61 struct CommonFieldClassSpec<const bt_field_class> final
  62 {
  63     static const bt_value *userAttributes(const bt_field_class * const libObjPtr) noexcept
  64     {
  65         return bt_field_class_borrow_user_attributes_const(libObjPtr);
  66     }
  67 };
  68
  69 } /* namespace internal */
  70
  71 template <typename ObjT, typename LibObjT>
  72 using SharedFieldClass = SharedObject<ObjT, LibObjT, internal::FieldClassRefFuncs>;
  73
  74 template <typename LibObjT>
  75 class CommonBitArrayFieldClass;
  76
  77 template <typename LibObjT>
  78 class CommonIntegerFieldClass;
  79
  80 template <typename LibObjT>
  81 class ConstEnumerationFieldClassMapping;
  82
  83 template <typename LibObjT>
  84 class CommonBaseEnumerationFieldClass;
  85
  86 template <typename LibObjT, typename MappingT>
  87 class CommonEnumerationFieldClass;
  88
  89 template <typename LibObjT>
  90 class CommonStructureFieldClass;
  91
  92 template <typename LibObjT>
  93 class CommonArrayFieldClass;
  94
  95 template <typename LibObjT>
  96 class CommonStaticArrayFieldClass;
  97
  98 template <typename LibObjT>
  99 class CommonDynamicArrayWithLengthFieldClass;
 100
 101 template <typename LibObjT>
 102 class CommonBlobFieldClass;
 103
 104 template <typename LibObjT>
 105 class CommonStaticBlobFieldClass;
 106
 107 template <typename LibObjT>
 108 class CommonDynamicBlobWithLengthFieldClass;
 109
 110 template <typename LibObjT>
 111 class CommonOptionFieldClass;
 112
 113 template <typename LibObjT>
 114 class CommonOptionWithSelectorFieldClass;
 115
 116 template <typename LibObjT>
 117 class CommonOptionWithBoolSelectorFieldClass;
 118
 119 template <typename LibObjT>
 120 class CommonVariantFieldClass;
 121
 122 template <typename LibObjT, typename RangeSetT>
 123 class CommonOptionWithIntegerSelectorFieldClass;
 124
 125 template <typename LibObjT>
 126 class CommonVariantWithoutSelectorFieldClass;
 127
 128 template <typename LibObjT>
 129 class CommonVariantWithSelectorFieldClass;
 130
 131 template <typename LibObjT>
 132 class ConstVariantWithIntegerSelectorFieldClassOption;
 133
 134 template <typename LibObjT, typename RangeSetT>
 135 class CommonVariantWithIntegerSelectorFieldClass;
 136
 137 template <typename LibObjT>
 138 class CommonEventClass;
 139
 140 template <typename LibObjT>
 141 class CommonStreamClass;
 142
 143 template <typename LibObjT>
 144 class CommonTraceClass;
 145
 146 enum class FieldClassType : std::uint64_t
 147 {
 148     Bool = BT_FIELD_CLASS_TYPE_BOOL,
 149     BitArray = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
 150     UnsignedInteger = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER,
 151     SignedInteger = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER,
 152     UnsignedEnumeration = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
 153     SignedEnumeration = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
 154     SinglePrecisionReal = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL,
 155     DoublePrecisionReal = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL,
 156     String = BT_FIELD_CLASS_TYPE_STRING,
 157     Structure = BT_FIELD_CLASS_TYPE_STRUCTURE,
 158     StaticArray = BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
 159     DynamicArrayWithoutLength = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD,
 160     DynamicArrayWithLength = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD,
 161     OptionWithoutSelector = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD,
 162     OptionWithBoolSelector = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD,
 163     OptionWithUnsignedIntegerSelector =
 164         BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
 165     OptionWithSignedIntegerSelector = BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
 166     VariantWithoutSelector = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD,
 167     VariantWithUnsignedIntegerSelector =
 168         BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
 169     VariantWithSignedIntegerSelector =
 170         BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
 171     StaticBlob = BT_FIELD_CLASS_TYPE_STATIC_BLOB,
 172     DynamicBlob = BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB,
 173     DynamicBlobWithoutLengthField = BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITHOUT_LENGTH_FIELD,
 174     DynamicBlobWithLengthField = BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITH_LENGTH_FIELD,
 175 };
 176
 177 template <typename LibObjT>
 178 class CommonFieldClass : public BorrowedObject<LibObjT>
 179 {
 180 private:
 181     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 182
 183 protected:
 184     using _ThisCommonFieldClass = CommonFieldClass<LibObjT>;
 185
 186 public:
 187     using typename BorrowedObject<LibObjT>::LibObjPtr;
 188     using Shared = SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
 189     using UserAttributes = internal::DepUserAttrs<LibObjT>;
 190
 191     explicit CommonFieldClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 192     {
 193     }
 194
 195     template <typename OtherLibObjT>
 196     CommonFieldClass(const CommonFieldClass<OtherLibObjT> fc) noexcept : _ThisBorrowedObject {fc}
 197     {
 198     }
 199
 200     template <typename OtherLibObjT>
 201     CommonFieldClass operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
 202     {
 203         _ThisBorrowedObject::operator=(fc);
 204         return *this;
 205     }
 206
 207     CommonFieldClass<const bt_field_class> asConst() const noexcept
 208     {
 209         return CommonFieldClass<const bt_field_class> {*this};
 210     }
 211
 212     FieldClassType type() const noexcept
 213     {
 214         return static_cast<FieldClassType>(bt_field_class_get_type(this->libObjPtr()));
 215     }
 216
 217     bool isBool() const noexcept
 218     {
 219         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BOOL);
 220     }
 221
 222     bool isBitArray() const noexcept
 223     {
 224         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BIT_ARRAY);
 225     }
 226
 227     bool isInteger() const noexcept
 228     {
 229         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_INTEGER);
 230     }
 231
 232     bool isUnsignedInteger() const noexcept
 233     {
 234         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER);
 235     }
 236
 237     bool isSignedInteger() const noexcept
 238     {
 239         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
 240     }
 241
 242     bool isEnumeration() const noexcept
 243     {
 244         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ENUMERATION);
 245     }
 246
 247     bool isUnsignedEnumeration() const noexcept
 248     {
 249         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
 250     }
 251
 252     bool isSignedEnumeration() const noexcept
 253     {
 254         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
 255     }
 256
 257     bool isReal() const noexcept
 258     {
 259         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_REAL);
 260     }
 261
 262     bool isSinglePrecisionReal() const noexcept
 263     {
 264         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL);
 265     }
 266
 267     bool isDoublePrecisionReal() const noexcept
 268     {
 269         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL);
 270     }
 271
 272     bool isString() const noexcept
 273     {
 274         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRING);
 275     }
 276
 277     bool isStructure() const noexcept
 278     {
 279         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STRUCTURE);
 280     }
 281
 282     bool isArray() const noexcept
 283     {
 284         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_ARRAY);
 285     }
 286
 287     bool isStaticArray() const noexcept
 288     {
 289         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STATIC_ARRAY);
 290     }
 291
 292     bool isDynamicArray() const noexcept
 293     {
 294         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY);
 295     }
 296
 297     bool isDynamicArrayWithoutLength() const noexcept
 298     {
 299         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD);
 300     }
 301
 302     bool isDynamicArrayWithLength() const noexcept
 303     {
 304         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
 305     }
 306
 307     bool isOption() const noexcept
 308     {
 309         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION);
 310     }
 311
 312     bool isOptionWithoutSelector() const noexcept
 313     {
 314         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD);
 315     }
 316
 317     bool isOptionWithSelector() const noexcept
 318     {
 319         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD);
 320     }
 321
 322     bool isOptionWithBoolSelector() const noexcept
 323     {
 324         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD);
 325     }
 326
 327     bool isOptionWithIntegerSelector() const noexcept
 328     {
 329         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_INTEGER_SELECTOR_FIELD);
 330     }
 331
 332     bool isOptionWithUnsignedIntegerSelector() const noexcept
 333     {
 334         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
 335     }
 336
 337     bool isOptionWithSignedIntegerSelector() const noexcept
 338     {
 339         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
 340     }
 341
 342     bool isVariant() const noexcept
 343     {
 344         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT);
 345     }
 346
 347     bool isVariantWithoutSelector() const noexcept
 348     {
 349         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD);
 350     }
 351
 352     bool isVariantWithSelector() const noexcept
 353     {
 354         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD);
 355     }
 356
 357     bool isVariantWithIntegerSelector() const noexcept
 358     {
 359         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_INTEGER_SELECTOR_FIELD);
 360     }
 361
 362     bool isVariantWithUnsignedIntegerSelector() const noexcept
 363     {
 364         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD);
 365     }
 366
 367     bool isVariantWithSignedIntegerSelector() const noexcept
 368     {
 369         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD);
 370     }
 371
 372     bool isBlob() const noexcept
 373     {
 374         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_BLOB);
 375     }
 376
 377     bool isStaticBlob() const noexcept
 378     {
 379         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_STATIC_BLOB);
 380     }
 381
 382     bool isDynamicBlob() const noexcept
 383     {
 384         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB);
 385     }
 386
 387     bool isDynamicBlobWithoutLength() const noexcept
 388     {
 389         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITHOUT_LENGTH_FIELD);
 390     }
 391
 392     bool isDynamicBlobWithLength() const noexcept
 393     {
 394         return this->_libTypeIs(BT_FIELD_CLASS_TYPE_DYNAMIC_BLOB_WITH_LENGTH_FIELD);
 395     }
 396
 397     template <typename FieldClassT>
 398     FieldClassT as() const noexcept
 399     {
 400         return FieldClassT {this->libObjPtr()};
 401     }
 402
 403     CommonBitArrayFieldClass<LibObjT> asBitArray() const noexcept;
 404     CommonIntegerFieldClass<LibObjT> asInteger() const noexcept;
 405     CommonBaseEnumerationFieldClass<LibObjT> asEnumeration() const noexcept;
 406     CommonEnumerationFieldClass<LibObjT, ConstEnumerationFieldClassMapping<
 407                                              const bt_field_class_enumeration_unsigned_mapping>>
 408     asUnsignedEnumeration() const noexcept;
 409
 410     CommonEnumerationFieldClass<
 411         LibObjT, ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>>
 412     asSignedEnumeration() const noexcept;
 413
 414     CommonStructureFieldClass<LibObjT> asStructure() const noexcept;
 415     CommonArrayFieldClass<LibObjT> asArray() const noexcept;
 416     CommonStaticArrayFieldClass<LibObjT> asStaticArray() const noexcept;
 417     CommonDynamicArrayWithLengthFieldClass<LibObjT> asDynamicArrayWithLength() const noexcept;
 418     CommonBlobFieldClass<LibObjT> asBlob() const noexcept;
 419     CommonStaticBlobFieldClass<LibObjT> asStaticBlob() const noexcept;
 420     CommonDynamicBlobWithLengthFieldClass<LibObjT> asDynamicBlobWithLength() const noexcept;
 421     CommonOptionFieldClass<LibObjT> asOption() const noexcept;
 422     CommonOptionWithSelectorFieldClass<LibObjT> asOptionWithSelector() const noexcept;
 423     CommonOptionWithBoolSelectorFieldClass<LibObjT> asOptionWithBoolSelector() const noexcept;
 424
 425     CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
 426     asOptionWithUnsignedIntegerSelector() const noexcept;
 427
 428     CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
 429     asOptionWithSignedIntegerSelector() const noexcept;
 430
 431     CommonVariantFieldClass<LibObjT> asVariant() const noexcept;
 432     CommonVariantWithoutSelectorFieldClass<LibObjT> asVariantWithoutSelector() const noexcept;
 433     CommonVariantWithSelectorFieldClass<LibObjT> asVariantWithSelector() const noexcept;
 434
 435     CommonVariantWithIntegerSelectorFieldClass<
 436         LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
 437                      const bt_field_class_variant_with_selector_field_integer_unsigned_option>>
 438     asVariantWithUnsignedIntegerSelector() const noexcept;
 439
 440     CommonVariantWithIntegerSelectorFieldClass<
 441         LibObjT, ConstVariantWithIntegerSelectorFieldClassOption<
 442                      const bt_field_class_variant_with_selector_field_integer_signed_option>>
 443     asVariantWithSignedIntegerSelector() const noexcept;
 444
 445     template <typename LibValT>
 446     CommonFieldClass userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
 447     {
 448         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstFieldClass`.");
 449
 450         bt_field_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
 451         return *this;
 452     }
 453
 454     UserAttributes userAttributes() const noexcept
 455     {
 456         return UserAttributes {
 457             internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
 458     }
 459
 460     Shared shared() const noexcept
 461     {
 462         return Shared::createWithRef(*this);
 463     }
 464
 465 protected:
 466     bool _libTypeIs(const bt_field_class_type type) const noexcept
 467     {
 468         return bt_field_class_type_is(bt_field_class_get_type(this->libObjPtr()), type);
 469     }
 470 };
 471
 472 using FieldClass = CommonFieldClass<bt_field_class>;
 473 using ConstFieldClass = CommonFieldClass<const bt_field_class>;
 474
 475 namespace internal {
 476
 477 struct FieldClassTypeDescr
 478 {
 479     using Const = ConstFieldClass;
 480     using NonConst = FieldClass;
 481 };
 482
 483 template <>
 484 struct TypeDescr<FieldClass> : public FieldClassTypeDescr
 485 {
 486 };
 487
 488 template <>
 489 struct TypeDescr<ConstFieldClass> : public FieldClassTypeDescr
 490 {
 491 };
 492
 493 } /* namespace internal */
 494
 495 class ConstBitArrayFieldClassFlag final : public BorrowedObject<const bt_field_class_bit_array_flag>
 496 {
 497 public:
 498     using RangeSet = ConstUnsignedIntegerRangeSet;
 499
 500     explicit ConstBitArrayFieldClassFlag(const LibObjPtr libObjPtr) noexcept :
 501         _ThisBorrowedObject {libObjPtr}
 502     {
 503     }
 504
 505     RangeSet ranges() const noexcept
 506     {
 507         return RangeSet {
 508             bt_field_class_bit_array_flag_borrow_index_ranges_const(this->libObjPtr())};
 509     }
 510
 511     bt2c::CStringView label() const noexcept
 512     {
 513         return bt_field_class_bit_array_flag_get_label(this->libObjPtr());
 514     }
 515 };
 516
 517 template <typename LibObjT>
 518 class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
 519 {
 520 private:
 521     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
 522
 523 public:
 524     using typename CommonFieldClass<LibObjT>::LibObjPtr;
 525     using Shared = SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
 526     using Iterator = BorrowedObjectIterator<CommonBitArrayFieldClass>;
 527
 528     explicit CommonBitArrayFieldClass(const LibObjPtr libObjPtr) noexcept :
 529         _ThisCommonFieldClass {libObjPtr}
 530     {
 531         BT_ASSERT_DBG(this->isBitArray());
 532     }
 533
 534     template <typename OtherLibObjT>
 535     CommonBitArrayFieldClass(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept :
 536         _ThisCommonFieldClass {fc}
 537     {
 538     }
 539
 540     template <typename OtherLibObjT>
 541     CommonBitArrayFieldClass<LibObjT>
 542     operator=(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept
 543     {
 544         _ThisCommonFieldClass::operator=(fc);
 545         return *this;
 546     }
 547
 548     CommonBitArrayFieldClass<const bt_field_class> asConst() const noexcept
 549     {
 550         return CommonBitArrayFieldClass<const bt_field_class> {*this};
 551     }
 552
 553     std::uint64_t length() const noexcept
 554     {
 555         return bt_field_class_bit_array_get_length(this->libObjPtr());
 556     }
 557
 558     ConstBitArrayFieldClassFlag operator[](const std::uint64_t index) const noexcept
 559     {
 560         return ConstBitArrayFieldClassFlag {
 561             bt_field_class_bit_array_borrow_flag_by_index_const(this->libObjPtr(), index)};
 562     }
 563
 564     OptionalBorrowedObject<ConstBitArrayFieldClassFlag>
 565     operator[](const bt2c::CStringView label) const noexcept
 566     {
 567         return bt_field_class_bit_array_borrow_flag_by_label_const(this->libObjPtr(), label);
 568     }
 569
 570     CommonBitArrayFieldClass addFlag(const bt2c::CStringView label,
 571                                      const ConstBitArrayFieldClassFlag::RangeSet ranges) const
 572     {
 573         static_assert(!std::is_const<LibObjT>::value,
 574                       "Not available with `bt2::ConstBitArrayFieldClass`.");
 575
 576         if (bt_field_class_bit_array_add_flag(this->libObjPtr(), label, ranges.libObjPtr()) ==
 577             BT_FIELD_CLASS_BIT_ARRAY_ADD_FLAG_STATUS_MEMORY_ERROR) {
 578             throw MemoryError {};
 579         }
 580
 581         return *this;
 582     }
 583
 584     Iterator begin() const noexcept
 585     {
 586         return Iterator {*this, 0};
 587     }
 588
 589     Iterator end() const noexcept
 590     {
 591         return Iterator {*this, this->length()};
 592     }
 593
 594     Shared shared() const noexcept
 595     {
 596         return Shared::createWithRef(*this);
 597     }
 598 };
 599
 600 using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
 601 using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
 602
 603 namespace internal {
 604
 605 struct BitArrayFieldClassTypeDescr
 606 {
 607     using Const = ConstBitArrayFieldClass;
 608     using NonConst = BitArrayFieldClass;
 609 };
 610
 611 template <>
 612 struct TypeDescr<BitArrayFieldClass> : public BitArrayFieldClassTypeDescr
 613 {
 614 };
 615
 616 template <>
 617 struct TypeDescr<ConstBitArrayFieldClass> : public BitArrayFieldClassTypeDescr
 618 {
 619 };
 620
 621 } /* namespace internal */
 622
 623 enum class DisplayBase
 624 {
 625     Binary = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
 626     Octal = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL,
 627     Decimal = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL,
 628     Hexadecimal = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL,
 629 };
 630
 631 template <typename LibObjT>
 632 class CommonIntegerFieldClass : public CommonFieldClass<LibObjT>
 633 {
 634 private:
 635     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
 636
 637 protected:
 638     using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass<LibObjT>;
 639
 640 public:
 641     using typename CommonFieldClass<LibObjT>::LibObjPtr;
 642     using Shared = SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
 643
 644     explicit CommonIntegerFieldClass(const LibObjPtr libObjPtr) noexcept :
 645         _ThisCommonFieldClass {libObjPtr}
 646     {
 647         BT_ASSERT_DBG(this->isInteger());
 648     }
 649
 650     template <typename OtherLibObjT>
 651     CommonIntegerFieldClass(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept :
 652         _ThisCommonFieldClass {fc}
 653     {
 654     }
 655
 656     template <typename OtherLibObjT>
 657     CommonIntegerFieldClass operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
 658     {
 659         _ThisCommonFieldClass::operator=(fc);
 660         return *this;
 661     }
 662
 663     CommonIntegerFieldClass<const bt_field_class> asConst() const noexcept
 664     {
 665         return CommonIntegerFieldClass<const bt_field_class> {*this};
 666     }
 667
 668     CommonIntegerFieldClass fieldValueRange(const std::uint64_t n) const noexcept
 669     {
 670         static_assert(!std::is_const<LibObjT>::value,
 671                       "Not available with `bt2::ConstIntegerFieldClass`.");
 672
 673         bt_field_class_integer_set_field_value_range(this->libObjPtr(), n);
 674         return *this;
 675     }
 676
 677     std::uint64_t fieldValueRange() const noexcept
 678     {
 679         return bt_field_class_integer_get_field_value_range(this->libObjPtr());
 680     }
 681
 682     CommonIntegerFieldClass preferredDisplayBase(const DisplayBase base) const noexcept
 683     {
 684         static_assert(!std::is_const<LibObjT>::value,
 685                       "Not available with `bt2::ConstIntegerFieldClass`.");
 686
 687         bt_field_class_integer_set_preferred_display_base(
 688             this->libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
 689         return *this;
 690     }
 691
 692     DisplayBase preferredDisplayBase() const noexcept
 693     {
 694         return static_cast<DisplayBase>(
 695             bt_field_class_integer_get_preferred_display_base(this->libObjPtr()));
 696     }
 697
 698     Shared shared() const noexcept
 699     {
 700         return Shared::createWithRef(*this);
 701     }
 702 };
 703
 704 using IntegerFieldClass = CommonIntegerFieldClass<bt_field_class>;
 705 using ConstIntegerFieldClass = CommonIntegerFieldClass<const bt_field_class>;
 706
 707 namespace internal {
 708
 709 struct IntegerFieldClassTypeDescr
 710 {
 711     using Const = ConstIntegerFieldClass;
 712     using NonConst = IntegerFieldClass;
 713 };
 714
 715 template <>
 716 struct TypeDescr<IntegerFieldClass> : public IntegerFieldClassTypeDescr
 717 {
 718 };
 719
 720 template <>
 721 struct TypeDescr<ConstIntegerFieldClass> : public IntegerFieldClassTypeDescr
 722 {
 723 };
 724
 725 template <typename LibObjT>
 726 struct ConstEnumerationFieldClassMappingSpec;
 727
 728 /* Functions specific to unsigned enumeration field class mappings */
 729 template <>
 730 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_unsigned_mapping>
 731     final
 732 {
 733     static const bt_integer_range_set_unsigned *
 734     ranges(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
 735     {
 736         return bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(libObjPtr);
 737     }
 738
 739     static const char *
 740     label(const bt_field_class_enumeration_unsigned_mapping * const libObjPtr) noexcept
 741     {
 742         return bt_field_class_enumeration_mapping_get_label(
 743             bt_field_class_enumeration_unsigned_mapping_as_mapping_const(libObjPtr));
 744     }
 745 };
 746
 747 /* Functions specific to signed enumeration field class mappings */
 748 template <>
 749 struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_signed_mapping> final
 750 {
 751     static const bt_integer_range_set_signed *
 752     ranges(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
 753     {
 754         return bt_field_class_enumeration_signed_mapping_borrow_ranges_const(libObjPtr);
 755     }
 756
 757     static const char *
 758     label(const bt_field_class_enumeration_signed_mapping * const libObjPtr) noexcept
 759     {
 760         return bt_field_class_enumeration_mapping_get_label(
 761             bt_field_class_enumeration_signed_mapping_as_mapping_const(libObjPtr));
 762     }
 763 };
 764
 765 } /* namespace internal */
 766
 767 template <typename LibObjT>
 768 class ConstEnumerationFieldClassMapping final : public BorrowedObject<LibObjT>
 769 {
 770 private:
 771     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 772
 773 public:
 774     using typename BorrowedObject<LibObjT>::LibObjPtr;
 775
 776     using RangeSet = typename std::conditional<
 777         std::is_same<LibObjT, const bt_field_class_enumeration_unsigned_mapping>::value,
 778         ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
 779
 780     explicit ConstEnumerationFieldClassMapping(const LibObjPtr libObjPtr) noexcept :
 781         _ThisBorrowedObject {libObjPtr}
 782     {
 783     }
 784
 785     ConstEnumerationFieldClassMapping(const ConstEnumerationFieldClassMapping& mapping) noexcept :
 786         _ThisBorrowedObject {mapping}
 787     {
 788     }
 789
 790     ConstEnumerationFieldClassMapping
 791     operator=(const ConstEnumerationFieldClassMapping& mapping) noexcept
 792     {
 793         _ThisBorrowedObject::operator=(mapping);
 794         return *this;
 795     }
 796
 797     RangeSet ranges() const noexcept
 798     {
 799         return RangeSet {
 800             internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->libObjPtr())};
 801     }
 802
 803     bt2c::CStringView label() const noexcept
 804     {
 805         return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->libObjPtr());
 806     }
 807 };
 808
 809 using ConstUnsignedEnumerationFieldClassMapping =
 810     ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_unsigned_mapping>;
 811
 812 using ConstSignedEnumerationFieldClassMapping =
 813     ConstEnumerationFieldClassMapping<const bt_field_class_enumeration_signed_mapping>;
 814
 815 namespace internal {
 816
 817 template <typename MappingT>
 818 struct CommonEnumerationFieldClassSpec;
 819
 820 /* Functions specific to unsigned enumeration field classes */
 821 template <>
 822 struct CommonEnumerationFieldClassSpec<ConstUnsignedEnumerationFieldClassMapping> final
 823 {
 824     static const bt_field_class_enumeration_unsigned_mapping *
 825     mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
 826     {
 827         return bt_field_class_enumeration_unsigned_borrow_mapping_by_index_const(libObjPtr, index);
 828     }
 829
 830     static const bt_field_class_enumeration_unsigned_mapping *
 831     mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
 832     {
 833         return bt_field_class_enumeration_unsigned_borrow_mapping_by_label_const(libObjPtr, label);
 834     }
 835
 836     static bt_field_class_enumeration_add_mapping_status
 837     addMapping(bt_field_class * const libObjPtr, const char * const label,
 838                const bt_integer_range_set_unsigned * const libRanges) noexcept
 839     {
 840         return bt_field_class_enumeration_unsigned_add_mapping(libObjPtr, label, libRanges);
 841     }
 842 };
 843
 844 /* Functions specific to signed enumeration field classes */
 845 template <>
 846 struct CommonEnumerationFieldClassSpec<ConstSignedEnumerationFieldClassMapping> final
 847 {
 848     static const bt_field_class_enumeration_signed_mapping *
 849     mappingByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
 850     {
 851         return bt_field_class_enumeration_signed_borrow_mapping_by_index_const(libObjPtr, index);
 852     }
 853
 854     static const bt_field_class_enumeration_signed_mapping *
 855     mappingByLabel(const bt_field_class * const libObjPtr, const char * const label) noexcept
 856     {
 857         return bt_field_class_enumeration_signed_borrow_mapping_by_label_const(libObjPtr, label);
 858     }
 859
 860     static bt_field_class_enumeration_add_mapping_status
 861     addMapping(bt_field_class * const libObjPtr, const char * const label,
 862                const bt_integer_range_set_signed * const libRanges) noexcept
 863     {
 864         return bt_field_class_enumeration_signed_add_mapping(libObjPtr, label, libRanges);
 865     }
 866 };
 867
 868 } /* namespace internal */
 869
 870 template <typename LibObjT>
 871 class CommonBaseEnumerationFieldClass : public CommonIntegerFieldClass<LibObjT>
 872 {
 873 private:
 874     using typename CommonIntegerFieldClass<LibObjT>::_ThisCommonIntegerFieldClass;
 875
 876 protected:
 877     using _ThisCommonBaseEnumerationFieldClass = CommonBaseEnumerationFieldClass<LibObjT>;
 878
 879 public:
 880     using typename CommonFieldClass<LibObjT>::LibObjPtr;
 881     using Shared = SharedFieldClass<_ThisCommonBaseEnumerationFieldClass, LibObjT>;
 882
 883     explicit CommonBaseEnumerationFieldClass(const LibObjPtr libObjPtr) noexcept :
 884         _ThisCommonIntegerFieldClass {libObjPtr}
 885     {
 886         BT_ASSERT_DBG(this->isEnumeration());
 887     }
 888
 889     template <typename OtherLibObjT>
 890     CommonBaseEnumerationFieldClass(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
 891         :
 892         _ThisCommonIntegerFieldClass {fc}
 893     {
 894     }
 895
 896     template <typename OtherLibObjT>
 897     CommonBaseEnumerationFieldClass
 898     operator=(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
 899     {
 900         _ThisCommonIntegerFieldClass::operator=(fc);
 901         return *this;
 902     }
 903
 904     CommonBaseEnumerationFieldClass<const bt_field_class> asConst() const noexcept
 905     {
 906         return CommonBaseEnumerationFieldClass<const bt_field_class> {*this};
 907     }
 908
 909     std::uint64_t length() const noexcept
 910     {
 911         return bt_field_class_enumeration_get_mapping_count(this->libObjPtr());
 912     }
 913
 914     Shared shared() const noexcept
 915     {
 916         return Shared::createWithRef(*this);
 917     }
 918 };
 919
 920 template <typename LibObjT, typename MappingT>
 921 class CommonEnumerationFieldClass final : public CommonBaseEnumerationFieldClass<LibObjT>
 922 {
 923 private:
 924     using typename CommonBaseEnumerationFieldClass<LibObjT>::_ThisCommonBaseEnumerationFieldClass;
 925
 926 public:
 927     using typename CommonFieldClass<LibObjT>::LibObjPtr;
 928     using Shared = SharedFieldClass<CommonEnumerationFieldClass, LibObjT>;
 929     using Iterator = BorrowedObjectIterator<CommonEnumerationFieldClass>;
 930     using Mapping = MappingT;
 931
 932     explicit CommonEnumerationFieldClass(const LibObjPtr libObjPtr) noexcept :
 933         _ThisCommonBaseEnumerationFieldClass {libObjPtr}
 934     {
 935         BT_ASSERT_DBG(this->isEnumeration());
 936     }
 937
 938     template <typename OtherLibObjT>
 939     CommonEnumerationFieldClass(
 940         const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept :
 941         CommonEnumerationFieldClass {fc}
 942     {
 943     }
 944
 945     template <typename OtherLibObjT>
 946     CommonEnumerationFieldClass
 947     operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept
 948     {
 949         CommonEnumerationFieldClass::operator=(fc);
 950         return *this;
 951     }
 952
 953     Mapping operator[](const std::uint64_t index) const noexcept
 954     {
 955         return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
 956             this->libObjPtr(), index)};
 957     }
 958
 959     OptionalBorrowedObject<Mapping> operator[](const bt2c::CStringView label) const noexcept
 960     {
 961         return internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
 962             this->libObjPtr(), label);
 963     }
 964
 965     CommonEnumerationFieldClass addMapping(const bt2c::CStringView label,
 966                                            const typename Mapping::RangeSet ranges) const
 967     {
 968         static_assert(!std::is_const<LibObjT>::value,
 969                       "Not available with `bt2::Const*EnumerationFieldClass`.");
 970
 971         const auto status = internal::CommonEnumerationFieldClassSpec<MappingT>::addMapping(
 972             this->libObjPtr(), label, ranges.libObjPtr());
 973
 974         if (status == BT_FIELD_CLASS_ENUMERATION_ADD_MAPPING_STATUS_MEMORY_ERROR) {
 975             throw MemoryError {};
 976         }
 977
 978         return *this;
 979     }
 980
 981     Iterator begin() const noexcept
 982     {
 983         return Iterator {*this, 0};
 984     }
 985
 986     Iterator end() const noexcept
 987     {
 988         return Iterator {*this, this->length()};
 989     }
 990
 991     Shared shared() const noexcept
 992     {
 993         return Shared::createWithRef(*this);
 994     }
 995 };
 996
 997 using EnumerationFieldClass = CommonBaseEnumerationFieldClass<bt_field_class>;
 998 using ConstEnumerationFieldClass = CommonBaseEnumerationFieldClass<const bt_field_class>;
 999
1000 using UnsignedEnumerationFieldClass =
1001     CommonEnumerationFieldClass<bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
1002
1003 using ConstUnsignedEnumerationFieldClass =
1004     CommonEnumerationFieldClass<const bt_field_class, ConstUnsignedEnumerationFieldClassMapping>;
1005
1006 using SignedEnumerationFieldClass =
1007     CommonEnumerationFieldClass<bt_field_class, ConstSignedEnumerationFieldClassMapping>;
1008
1009 using ConstSignedEnumerationFieldClass =
1010     CommonEnumerationFieldClass<const bt_field_class, ConstSignedEnumerationFieldClassMapping>;
1011
1012 namespace internal {
1013
1014 struct UnsignedEnumerationFieldClassTypeDescr
1015 {
1016     using Const = ConstUnsignedEnumerationFieldClass;
1017     using NonConst = UnsignedEnumerationFieldClass;
1018 };
1019
1020 template <>
1021 struct TypeDescr<UnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
1022 {
1023 };
1024
1025 template <>
1026 struct TypeDescr<ConstUnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
1027 {
1028 };
1029
1030 struct SignedEnumerationFieldClassTypeDescr
1031 {
1032     using Const = ConstSignedEnumerationFieldClass;
1033     using NonConst = SignedEnumerationFieldClass;
1034 };
1035
1036 template <>
1037 struct TypeDescr<SignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
1038 {
1039 };
1040
1041 template <>
1042 struct TypeDescr<ConstSignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
1043 {
1044 };
1045
1046 template <typename LibObjT>
1047 struct CommonStructureFieldClassMemberSpec;
1048
1049 /* Functions specific to mutable structure field class members */
1050 template <>
1051 struct CommonStructureFieldClassMemberSpec<bt_field_class_structure_member> final
1052 {
1053     static bt_field_class *fieldClass(bt_field_class_structure_member * const libObjPtr) noexcept
1054     {
1055         return bt_field_class_structure_member_borrow_field_class(libObjPtr);
1056     }
1057
1058     static bt_value *userAttributes(bt_field_class_structure_member * const libObjPtr) noexcept
1059     {
1060         return bt_field_class_structure_member_borrow_user_attributes(libObjPtr);
1061     }
1062 };
1063
1064 /* Functions specific to constant structure field class members */
1065 template <>
1066 struct CommonStructureFieldClassMemberSpec<const bt_field_class_structure_member> final
1067 {
1068     static const bt_field_class *
1069     fieldClass(const bt_field_class_structure_member * const libObjPtr) noexcept
1070     {
1071         return bt_field_class_structure_member_borrow_field_class_const(libObjPtr);
1072     }
1073
1074     static const bt_value *
1075     userAttributes(const bt_field_class_structure_member * const libObjPtr) noexcept
1076     {
1077         return bt_field_class_structure_member_borrow_user_attributes_const(libObjPtr);
1078     }
1079 };
1080
1081 } /* namespace internal */
1082
1083 template <typename LibObjT>
1084 class CommonStructureFieldClassMember final : public BorrowedObject<LibObjT>
1085 {
1086 private:
1087     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1088     using _FieldClass = internal::DepFc<LibObjT>;
1089
1090 public:
1091     using typename BorrowedObject<LibObjT>::LibObjPtr;
1092     using UserAttributes = internal::DepUserAttrs<LibObjT>;
1093
1094     explicit CommonStructureFieldClassMember(const LibObjPtr libObjPtr) noexcept :
1095         _ThisBorrowedObject {libObjPtr}
1096     {
1097     }
1098
1099     template <typename OtherLibObjT>
1100     CommonStructureFieldClassMember(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
1101         :
1102         _ThisBorrowedObject {fc}
1103     {
1104     }
1105
1106     template <typename OtherLibObjT>
1107     CommonStructureFieldClassMember<LibObjT>
1108     operator=(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
1109     {
1110         _ThisBorrowedObject::operator=(fc);
1111         return *this;
1112     }
1113
1114     CommonStructureFieldClassMember<const bt_field_class_structure_member> asConst() const noexcept
1115     {
1116         return CommonStructureFieldClassMember<const bt_field_class_structure_member> {*this};
1117     }
1118
1119     bt2c::CStringView name() const noexcept
1120     {
1121         return bt_field_class_structure_member_get_name(this->libObjPtr());
1122     }
1123
1124     _FieldClass fieldClass() const noexcept
1125     {
1126         return _FieldClass {
1127             internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->libObjPtr())};
1128     }
1129
1130     template <typename LibValT>
1131     CommonStructureFieldClassMember
1132     userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1133     {
1134         static_assert(!std::is_const<LibObjT>::value,
1135                       "Not available with `bt2::ConstStructureFieldClassMember`.");
1136
1137         bt_field_class_structure_member_set_user_attributes(this->libObjPtr(),
1138                                                             userAttrs.libObjPtr());
1139         return *this;
1140     }
1141
1142     UserAttributes userAttributes() const noexcept
1143     {
1144         return UserAttributes {
1145             internal::CommonStructureFieldClassMemberSpec<LibObjT>::userAttributes(
1146                 this->libObjPtr())};
1147     }
1148 };
1149
1150 using StructureFieldClassMember = CommonStructureFieldClassMember<bt_field_class_structure_member>;
1151
1152 using ConstStructureFieldClassMember =
1153     CommonStructureFieldClassMember<const bt_field_class_structure_member>;
1154
1155 namespace internal {
1156
1157 struct StructureFieldClassMemberTypeDescr
1158 {
1159     using Const = ConstStructureFieldClassMember;
1160     using NonConst = StructureFieldClassMember;
1161 };
1162
1163 template <>
1164 struct TypeDescr<StructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
1165 {
1166 };
1167
1168 template <>
1169 struct TypeDescr<ConstStructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
1170 {
1171 };
1172
1173 template <typename LibObjT>
1174 struct CommonStructureFieldClassSpec;
1175
1176 /* Functions specific to mutable structure field classes */
1177 template <>
1178 struct CommonStructureFieldClassSpec<bt_field_class> final
1179 {
1180     static bt_field_class_structure_member *memberByIndex(bt_field_class * const libObjPtr,
1181                                                           const std::uint64_t index) noexcept
1182     {
1183         return bt_field_class_structure_borrow_member_by_index(libObjPtr, index);
1184     }
1185
1186     static bt_field_class_structure_member *memberByName(bt_field_class * const libObjPtr,
1187                                                          const char * const name) noexcept
1188     {
1189         return bt_field_class_structure_borrow_member_by_name(libObjPtr, name);
1190     }
1191 };
1192
1193 /* Functions specific to constant structure field classes */
1194 template <>
1195 struct CommonStructureFieldClassSpec<const bt_field_class> final
1196 {
1197     static const bt_field_class_structure_member *
1198     memberByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
1199     {
1200         return bt_field_class_structure_borrow_member_by_index_const(libObjPtr, index);
1201     }
1202
1203     static const bt_field_class_structure_member *
1204     memberByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
1205     {
1206         return bt_field_class_structure_borrow_member_by_name_const(libObjPtr, name);
1207     }
1208 };
1209
1210 } /* namespace internal */
1211
1212 template <typename LibObjT>
1213 class CommonStructureFieldClass final : public CommonFieldClass<LibObjT>
1214 {
1215 private:
1216     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1217
1218 public:
1219     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1220     using Shared = SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
1221     using Iterator = BorrowedObjectIterator<CommonStructureFieldClass<LibObjT>>;
1222
1223     using Member =
1224         internal::DepType<LibObjT, StructureFieldClassMember, ConstStructureFieldClassMember>;
1225
1226     explicit CommonStructureFieldClass(const LibObjPtr libObjPtr) noexcept :
1227         _ThisCommonFieldClass {libObjPtr}
1228     {
1229         BT_ASSERT_DBG(this->isStructure());
1230     }
1231
1232     template <typename OtherLibObjT>
1233     CommonStructureFieldClass(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept :
1234         _ThisCommonFieldClass {fc}
1235     {
1236     }
1237
1238     template <typename OtherLibObjT>
1239     CommonStructureFieldClass operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
1240     {
1241         _ThisCommonFieldClass::operator=(fc);
1242         return *this;
1243     }
1244
1245     CommonStructureFieldClass<const bt_field_class> asConst() const noexcept
1246     {
1247         return CommonStructureFieldClass<const bt_field_class> {*this};
1248     }
1249
1250     CommonStructureFieldClass appendMember(const bt2c::CStringView name, const FieldClass fc) const
1251     {
1252         static_assert(!std::is_const<LibObjT>::value,
1253                       "Not available with `bt2::ConstStructureFieldClass`.");
1254
1255         const auto status =
1256             bt_field_class_structure_append_member(this->libObjPtr(), name, fc.libObjPtr());
1257
1258         if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
1259             throw MemoryError {};
1260         }
1261
1262         return *this;
1263     }
1264
1265     std::uint64_t length() const noexcept
1266     {
1267         return bt_field_class_structure_get_member_count(this->libObjPtr());
1268     }
1269
1270     Iterator begin() const noexcept
1271     {
1272         return Iterator {*this, 0};
1273     }
1274
1275     Iterator end() const noexcept
1276     {
1277         return Iterator {*this, this->length()};
1278     }
1279
1280     Member operator[](const std::uint64_t index) const noexcept
1281     {
1282         return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
1283             this->libObjPtr(), index)};
1284     }
1285
1286     OptionalBorrowedObject<Member> operator[](const bt2c::CStringView name) const noexcept
1287     {
1288         return internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(),
1289                                                                               name);
1290     }
1291
1292     Shared shared() const noexcept
1293     {
1294         return Shared::createWithRef(*this);
1295     }
1296 };
1297
1298 using StructureFieldClass = CommonStructureFieldClass<bt_field_class>;
1299 using ConstStructureFieldClass = CommonStructureFieldClass<const bt_field_class>;
1300
1301 namespace internal {
1302
1303 struct StructureFieldClassTypeDescr
1304 {
1305     using Const = ConstStructureFieldClass;
1306     using NonConst = StructureFieldClass;
1307 };
1308
1309 template <>
1310 struct TypeDescr<StructureFieldClass> : public StructureFieldClassTypeDescr
1311 {
1312 };
1313
1314 template <>
1315 struct TypeDescr<ConstStructureFieldClass> : public StructureFieldClassTypeDescr
1316 {
1317 };
1318
1319 template <typename LibObjT>
1320 struct CommonArrayFieldClassSpec;
1321
1322 /* Functions specific to mutable array field classes */
1323 template <>
1324 struct CommonArrayFieldClassSpec<bt_field_class> final
1325 {
1326     static bt_field_class *elementFieldClass(bt_field_class * const libObjPtr) noexcept
1327     {
1328         return bt_field_class_array_borrow_element_field_class(libObjPtr);
1329     }
1330 };
1331
1332 /* Functions specific to constant array field classes */
1333 template <>
1334 struct CommonArrayFieldClassSpec<const bt_field_class> final
1335 {
1336     static const bt_field_class *elementFieldClass(const bt_field_class * const libObjPtr) noexcept
1337     {
1338         return bt_field_class_array_borrow_element_field_class_const(libObjPtr);
1339     }
1340 };
1341
1342 } /* namespace internal */
1343
1344 template <typename LibObjT>
1345 class CommonArrayFieldClass : public CommonFieldClass<LibObjT>
1346 {
1347 private:
1348     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1349     using _FieldClass = internal::DepFc<LibObjT>;
1350
1351 protected:
1352     using _ThisCommonArrayFieldClass = CommonArrayFieldClass<LibObjT>;
1353
1354 public:
1355     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1356     using Shared = SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
1357
1358     explicit CommonArrayFieldClass(const LibObjPtr libObjPtr) noexcept :
1359         _ThisCommonFieldClass {libObjPtr}
1360     {
1361         BT_ASSERT_DBG(this->isArray());
1362     }
1363
1364     template <typename OtherLibObjT>
1365     CommonArrayFieldClass(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept :
1366         _ThisCommonFieldClass {fc}
1367     {
1368     }
1369
1370     template <typename OtherLibObjT>
1371     CommonArrayFieldClass operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
1372     {
1373         _ThisCommonFieldClass::operator=(fc);
1374         return *this;
1375     }
1376
1377     CommonArrayFieldClass<const bt_field_class> asConst() const noexcept
1378     {
1379         return CommonArrayFieldClass<const bt_field_class> {*this};
1380     }
1381
1382     _FieldClass elementFieldClass() const noexcept
1383     {
1384         return _FieldClass {
1385             internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->libObjPtr())};
1386     }
1387
1388     Shared shared() const noexcept
1389     {
1390         return Shared::createWithRef(*this);
1391     }
1392 };
1393
1394 using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
1395 using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
1396
1397 namespace internal {
1398
1399 struct ArrayFieldClassTypeDescr
1400 {
1401     using Const = ConstArrayFieldClass;
1402     using NonConst = ArrayFieldClass;
1403 };
1404
1405 template <>
1406 struct TypeDescr<ArrayFieldClass> : public ArrayFieldClassTypeDescr
1407 {
1408 };
1409
1410 template <>
1411 struct TypeDescr<ConstArrayFieldClass> : public ArrayFieldClassTypeDescr
1412 {
1413 };
1414
1415 } /* namespace internal */
1416
1417 template <typename LibObjT>
1418 class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
1419 {
1420 private:
1421     using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1422
1423 public:
1424     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1425     using Shared = SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
1426
1427     explicit CommonStaticArrayFieldClass(const LibObjPtr libObjPtr) noexcept :
1428         _ThisCommonArrayFieldClass {libObjPtr}
1429     {
1430         BT_ASSERT_DBG(this->isStaticArray());
1431     }
1432
1433     template <typename OtherLibObjT>
1434     CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept :
1435         _ThisCommonArrayFieldClass {fc}
1436     {
1437     }
1438
1439     template <typename OtherLibObjT>
1440     CommonStaticArrayFieldClass
1441     operator=(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept
1442     {
1443         _ThisCommonArrayFieldClass::operator=(fc);
1444         return *this;
1445     }
1446
1447     CommonStaticArrayFieldClass<const bt_field_class> asConst() const noexcept
1448     {
1449         return CommonStaticArrayFieldClass<const bt_field_class> {*this};
1450     }
1451
1452     std::uint64_t length() const noexcept
1453     {
1454         return bt_field_class_array_static_get_length(this->libObjPtr());
1455     }
1456
1457     Shared shared() const noexcept
1458     {
1459         return Shared::createWithRef(*this);
1460     }
1461 };
1462
1463 using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
1464 using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
1465
1466 namespace internal {
1467
1468 struct StaticArrayFieldClassTypeDescr
1469 {
1470     using Const = ConstStaticArrayFieldClass;
1471     using NonConst = StaticArrayFieldClass;
1472 };
1473
1474 template <>
1475 struct TypeDescr<StaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
1476 {
1477 };
1478
1479 template <>
1480 struct TypeDescr<ConstStaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
1481 {
1482 };
1483
1484 } /* namespace internal */
1485
1486 template <typename LibObjT>
1487 class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
1488 {
1489 private:
1490     using typename CommonArrayFieldClass<LibObjT>::_ThisCommonArrayFieldClass;
1491
1492 public:
1493     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1494     using Shared = SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
1495
1496     explicit CommonDynamicArrayWithLengthFieldClass(const LibObjPtr libObjPtr) noexcept :
1497         _ThisCommonArrayFieldClass {libObjPtr}
1498     {
1499         BT_ASSERT_DBG(this->isDynamicArrayWithLength());
1500     }
1501
1502     template <typename OtherLibObjT>
1503     CommonDynamicArrayWithLengthFieldClass(
1504         const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept :
1505         _ThisCommonArrayFieldClass {fc}
1506     {
1507     }
1508
1509     template <typename OtherLibObjT>
1510     CommonDynamicArrayWithLengthFieldClass
1511     operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept
1512     {
1513         _ThisCommonArrayFieldClass::operator=(fc);
1514         return *this;
1515     }
1516
1517     CommonDynamicArrayWithLengthFieldClass<const bt_field_class> asConst() const noexcept
1518     {
1519         return CommonDynamicArrayWithLengthFieldClass<const bt_field_class> {*this};
1520     }
1521
1522     ConstFieldPath lengthFieldPath() const noexcept
1523     {
1524         return ConstFieldPath {
1525             bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
1526                 this->libObjPtr())};
1527     }
1528
1529     ConstFieldLocation lengthFieldLocation() const noexcept
1530     {
1531         return ConstFieldLocation {
1532             bt_field_class_array_dynamic_with_length_field_borrow_length_field_location_const(
1533                 this->libObjPtr())};
1534     }
1535
1536     Shared shared() const noexcept
1537     {
1538         return Shared::createWithRef(*this);
1539     }
1540 };
1541
1542 using DynamicArrayWithLengthFieldClass = CommonDynamicArrayWithLengthFieldClass<bt_field_class>;
1543
1544 using ConstDynamicArrayWithLengthFieldClass =
1545     CommonDynamicArrayWithLengthFieldClass<const bt_field_class>;
1546
1547 namespace internal {
1548
1549 struct DynamicArrayWithLengthFieldClassTypeDescr
1550 {
1551     using Const = ConstDynamicArrayWithLengthFieldClass;
1552     using NonConst = DynamicArrayWithLengthFieldClass;
1553 };
1554
1555 template <>
1556 struct TypeDescr<DynamicArrayWithLengthFieldClass> :
1557     public DynamicArrayWithLengthFieldClassTypeDescr
1558 {
1559 };
1560
1561 template <>
1562 struct TypeDescr<ConstDynamicArrayWithLengthFieldClass> :
1563     public DynamicArrayWithLengthFieldClassTypeDescr
1564 {
1565 };
1566
1567 } /* namespace internal */
1568
1569 template <typename LibObjT>
1570 class CommonBlobFieldClass : public CommonFieldClass<LibObjT>
1571 {
1572 private:
1573     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1574
1575 protected:
1576     using _ThisCommonBlobFieldClass = CommonBlobFieldClass<LibObjT>;
1577
1578 public:
1579     using Shared = SharedFieldClass<CommonBlobFieldClass<LibObjT>, LibObjT>;
1580     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1581
1582     explicit CommonBlobFieldClass(const LibObjPtr libObjPtr) noexcept :
1583         _ThisCommonFieldClass {libObjPtr}
1584     {
1585         BT_ASSERT_DBG(this->isBlob());
1586     }
1587
1588     template <typename OtherLibObjT>
1589     CommonBlobFieldClass(const CommonBlobFieldClass<OtherLibObjT> fc) noexcept :
1590         _ThisCommonFieldClass {fc}
1591     {
1592     }
1593
1594     template <typename OtherLibObjT>
1595     CommonBlobFieldClass operator=(const CommonBlobFieldClass<OtherLibObjT> fc) noexcept
1596     {
1597         _ThisCommonFieldClass::operator=(fc);
1598         return *this;
1599     }
1600
1601     CommonBlobFieldClass<const bt_field_class> asConst() const noexcept
1602     {
1603         return CommonBlobFieldClass<const bt_field_class> {*this};
1604     }
1605
1606     bt2c::CStringView mediaType() const noexcept
1607     {
1608         return bt_field_class_blob_get_media_type(this->libObjPtr());
1609     }
1610
1611     CommonBlobFieldClass mediaType(const bt2c::CStringView mediaType) const
1612     {
1613         static_assert(!std::is_const<LibObjT>::value,
1614                       "Not available with `bt2::ConstBlobFieldClass`.");
1615
1616         if (bt_field_class_blob_set_media_type(this->libObjPtr(), mediaType) ==
1617             BT_FIELD_CLASS_BLOB_SET_MEDIA_TYPE_STATUS_MEMORY_ERROR) {
1618             throw MemoryError {};
1619         }
1620
1621         return *this;
1622     }
1623
1624     Shared shared() const noexcept
1625     {
1626         return Shared::createWithRef(*this);
1627     }
1628 };
1629
1630 using BlobFieldClass = CommonBlobFieldClass<bt_field_class>;
1631 using ConstBlobFieldClass = CommonBlobFieldClass<const bt_field_class>;
1632
1633 namespace internal {
1634
1635 struct BlobFieldClassTypeDescr
1636 {
1637     using Const = ConstBlobFieldClass;
1638     using NonConst = BlobFieldClass;
1639 };
1640
1641 template <>
1642 struct TypeDescr<BlobFieldClass> : public BlobFieldClassTypeDescr
1643 {
1644 };
1645
1646 template <>
1647 struct TypeDescr<ConstBlobFieldClass> : public BlobFieldClassTypeDescr
1648 {
1649 };
1650
1651 } /* namespace internal */
1652
1653 template <typename LibObjT>
1654 class CommonStaticBlobFieldClass final : public CommonBlobFieldClass<LibObjT>
1655 {
1656 private:
1657     using typename CommonBlobFieldClass<LibObjT>::_ThisCommonBlobFieldClass;
1658
1659 public:
1660     using Shared = SharedFieldClass<CommonStaticBlobFieldClass<LibObjT>, LibObjT>;
1661     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1662
1663     explicit CommonStaticBlobFieldClass(const LibObjPtr libObjPtr) noexcept :
1664         _ThisCommonBlobFieldClass {libObjPtr}
1665     {
1666         BT_ASSERT_DBG(this->isStaticBlob());
1667     }
1668
1669     template <typename OtherLibObjT>
1670     CommonStaticBlobFieldClass(const CommonStaticBlobFieldClass<OtherLibObjT> fc) noexcept :
1671         _ThisCommonBlobFieldClass {fc}
1672     {
1673     }
1674
1675     template <typename OtherLibObjT>
1676     CommonStaticBlobFieldClass operator=(const CommonStaticBlobFieldClass<OtherLibObjT> fc) noexcept
1677     {
1678         _ThisCommonBlobFieldClass::operator=(fc);
1679         return *this;
1680     }
1681
1682     CommonStaticBlobFieldClass<const bt_field_class> asConst() const noexcept
1683     {
1684         return CommonStaticBlobFieldClass<const bt_field_class> {*this};
1685     }
1686
1687     std::uint64_t length() const noexcept
1688     {
1689         return bt_field_class_blob_static_get_length(this->libObjPtr());
1690     }
1691
1692     Shared shared() const noexcept
1693     {
1694         return Shared::createWithRef(*this);
1695     }
1696 };
1697
1698 using StaticBlobFieldClass = CommonStaticBlobFieldClass<bt_field_class>;
1699 using ConstStaticBlobFieldClass = CommonStaticBlobFieldClass<const bt_field_class>;
1700
1701 namespace internal {
1702
1703 struct StaticBlobFieldClassTypeDescr
1704 {
1705     using Const = ConstStaticBlobFieldClass;
1706     using NonConst = StaticBlobFieldClass;
1707 };
1708
1709 template <>
1710 struct TypeDescr<StaticBlobFieldClass> : public StaticBlobFieldClassTypeDescr
1711 {
1712 };
1713
1714 template <>
1715 struct TypeDescr<ConstStaticBlobFieldClass> : public StaticBlobFieldClassTypeDescr
1716 {
1717 };
1718
1719 } /* namespace internal */
1720
1721 template <typename LibObjT>
1722 class CommonDynamicBlobWithLengthFieldClass final : public CommonBlobFieldClass<LibObjT>
1723 {
1724 private:
1725     using typename CommonBlobFieldClass<LibObjT>::_ThisCommonBlobFieldClass;
1726
1727 public:
1728     using Shared = SharedFieldClass<CommonDynamicBlobWithLengthFieldClass<LibObjT>, LibObjT>;
1729     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1730
1731     explicit CommonDynamicBlobWithLengthFieldClass(const LibObjPtr libObjPtr) noexcept :
1732         _ThisCommonBlobFieldClass {libObjPtr}
1733     {
1734         BT_ASSERT_DBG(this->isDynamicBlobWithLength());
1735     }
1736
1737     template <typename OtherLibObjT>
1738     CommonDynamicBlobWithLengthFieldClass(
1739         const CommonDynamicBlobWithLengthFieldClass<OtherLibObjT> fc) noexcept :
1740         _ThisCommonBlobFieldClass {fc}
1741     {
1742     }
1743
1744     template <typename OtherLibObjT>
1745     CommonDynamicBlobWithLengthFieldClass
1746     operator=(const CommonDynamicBlobWithLengthFieldClass<OtherLibObjT> fc) noexcept
1747     {
1748         _ThisCommonBlobFieldClass::operator=(fc);
1749         return *this;
1750     }
1751
1752     CommonDynamicBlobWithLengthFieldClass<const bt_field_class> asConst() const noexcept
1753     {
1754         return CommonDynamicBlobWithLengthFieldClass<const bt_field_class> {*this};
1755     }
1756
1757     ConstFieldLocation lengthFieldLocation() const noexcept
1758     {
1759         return ConstFieldLocation {
1760             bt_field_class_blob_dynamic_with_length_field_borrow_length_field_location_const(
1761                 this->libObjPtr())};
1762     }
1763
1764     Shared shared() const noexcept
1765     {
1766         return Shared::createWithRef(*this);
1767     }
1768 };
1769
1770 using DynamicBlobWithLengthFieldClass = CommonDynamicBlobWithLengthFieldClass<bt_field_class>;
1771
1772 using ConstDynamicBlobWithLengthFieldClass =
1773     CommonDynamicBlobWithLengthFieldClass<const bt_field_class>;
1774
1775 namespace internal {
1776
1777 struct DynamicBlobWithLengthFieldClassTypeDescr
1778 {
1779     using Const = ConstDynamicBlobWithLengthFieldClass;
1780     using NonConst = DynamicBlobWithLengthFieldClass;
1781 };
1782
1783 template <>
1784 struct TypeDescr<DynamicBlobWithLengthFieldClass> : public DynamicBlobWithLengthFieldClassTypeDescr
1785 {
1786 };
1787
1788 template <>
1789 struct TypeDescr<ConstDynamicBlobWithLengthFieldClass> :
1790     public DynamicBlobWithLengthFieldClassTypeDescr
1791 {
1792 };
1793
1794 template <typename LibObjT>
1795 struct CommonOptionFieldClassSpec;
1796
1797 /* Functions specific to mutable option field classes */
1798 template <>
1799 struct CommonOptionFieldClassSpec<bt_field_class> final
1800 {
1801     static bt_field_class *fieldClass(bt_field_class * const libObjPtr) noexcept
1802     {
1803         return bt_field_class_option_borrow_field_class(libObjPtr);
1804     }
1805 };
1806
1807 /* Functions specific to constant option field classes */
1808 template <>
1809 struct CommonOptionFieldClassSpec<const bt_field_class> final
1810 {
1811     static const bt_field_class *fieldClass(const bt_field_class * const libObjPtr) noexcept
1812     {
1813         return bt_field_class_option_borrow_field_class_const(libObjPtr);
1814     }
1815 };
1816
1817 } /* namespace internal */
1818
1819 template <typename LibObjT>
1820 class CommonOptionFieldClass : public CommonFieldClass<LibObjT>
1821 {
1822 private:
1823     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
1824     using _FieldClass = internal::DepFc<LibObjT>;
1825
1826 protected:
1827     using _ThisCommonOptionFieldClass = CommonOptionFieldClass<LibObjT>;
1828
1829 public:
1830     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1831     using Shared = SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
1832
1833     explicit CommonOptionFieldClass(const LibObjPtr libObjPtr) noexcept :
1834         _ThisCommonFieldClass {libObjPtr}
1835     {
1836         BT_ASSERT_DBG(this->isOption());
1837     }
1838
1839     template <typename OtherLibObjT>
1840     CommonOptionFieldClass(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept :
1841         _ThisCommonFieldClass {fc}
1842     {
1843     }
1844
1845     template <typename OtherLibObjT>
1846     CommonOptionFieldClass operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
1847     {
1848         _ThisCommonFieldClass::operator=(fc);
1849         return *this;
1850     }
1851
1852     CommonOptionFieldClass<const bt_field_class> asConst() const noexcept
1853     {
1854         return CommonOptionFieldClass<const bt_field_class> {*this};
1855     }
1856
1857     _FieldClass fieldClass() const noexcept
1858     {
1859         return _FieldClass {
1860             internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->libObjPtr())};
1861     }
1862
1863     Shared shared() const noexcept
1864     {
1865         return Shared::createWithRef(*this);
1866     }
1867 };
1868
1869 using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
1870 using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
1871
1872 namespace internal {
1873
1874 struct OptionFieldClassTypeDescr
1875 {
1876     using Const = ConstOptionFieldClass;
1877     using NonConst = OptionFieldClass;
1878 };
1879
1880 template <>
1881 struct TypeDescr<OptionFieldClass> : public OptionFieldClassTypeDescr
1882 {
1883 };
1884
1885 template <>
1886 struct TypeDescr<ConstOptionFieldClass> : public OptionFieldClassTypeDescr
1887 {
1888 };
1889
1890 } /* namespace internal */
1891
1892 template <typename LibObjT>
1893 class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
1894 {
1895 private:
1896     using typename CommonOptionFieldClass<LibObjT>::_ThisCommonOptionFieldClass;
1897
1898 protected:
1899     using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<LibObjT>;
1900
1901 public:
1902     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1903     using Shared = SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
1904
1905     explicit CommonOptionWithSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
1906         _ThisCommonOptionFieldClass {libObjPtr}
1907     {
1908         BT_ASSERT_DBG(this->isOptionWithSelector());
1909     }
1910
1911     template <typename OtherLibObjT>
1912     CommonOptionWithSelectorFieldClass(
1913         const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept :
1914         _ThisCommonOptionFieldClass {fc}
1915     {
1916     }
1917
1918     template <typename OtherLibObjT>
1919     CommonOptionWithSelectorFieldClass
1920     operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept
1921     {
1922         _ThisCommonOptionFieldClass::operator=(fc);
1923         return *this;
1924     }
1925
1926     CommonOptionWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
1927     {
1928         return CommonOptionWithSelectorFieldClass<const bt_field_class> {*this};
1929     }
1930
1931     ConstFieldPath selectorFieldPath() const noexcept
1932     {
1933         return ConstFieldPath {
1934             bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
1935                 this->libObjPtr())};
1936     }
1937
1938     ConstFieldLocation selectorFieldLocation() const noexcept
1939     {
1940         return ConstFieldLocation {
1941             bt_field_class_option_with_selector_field_borrow_selector_field_location_const(
1942                 this->libObjPtr())};
1943     }
1944
1945     Shared shared() const noexcept
1946     {
1947         return Shared::createWithRef(*this);
1948     }
1949 };
1950
1951 using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
1952 using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
1953
1954 namespace internal {
1955
1956 struct OptionWithSelectorFieldClassTypeDescr
1957 {
1958     using Const = ConstOptionWithSelectorFieldClass;
1959     using NonConst = OptionWithSelectorFieldClass;
1960 };
1961
1962 template <>
1963 struct TypeDescr<OptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
1964 {
1965 };
1966
1967 template <>
1968 struct TypeDescr<ConstOptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
1969 {
1970 };
1971
1972 } /* namespace internal */
1973
1974 template <typename LibObjT>
1975 class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
1976 {
1977 private:
1978     using typename CommonOptionWithSelectorFieldClass<
1979         LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
1980
1981 public:
1982     using typename CommonFieldClass<LibObjT>::LibObjPtr;
1983     using Shared = SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
1984
1985     explicit CommonOptionWithBoolSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
1986         _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
1987     {
1988         BT_ASSERT_DBG(this->isOptionWithBoolSelector());
1989     }
1990
1991     template <typename OtherLibObjT>
1992     CommonOptionWithBoolSelectorFieldClass(
1993         const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept :
1994         _ThisCommonOptionWithSelectorFieldClass {fc}
1995     {
1996     }
1997
1998     template <typename OtherLibObjT>
1999     CommonOptionWithBoolSelectorFieldClass
2000     operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept
2001     {
2002         _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
2003         return *this;
2004     }
2005
2006     CommonOptionWithBoolSelectorFieldClass<const bt_field_class> asConst() const noexcept
2007     {
2008         return CommonOptionWithBoolSelectorFieldClass<const bt_field_class> {*this};
2009     }
2010
2011     bool selectorIsReversed() const noexcept
2012     {
2013         return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
2014             this->libObjPtr());
2015     }
2016
2017     Shared shared() const noexcept
2018     {
2019         return Shared::createWithRef(*this);
2020     }
2021 };
2022
2023 using OptionWithBoolSelectorFieldClass = CommonOptionWithBoolSelectorFieldClass<bt_field_class>;
2024
2025 using ConstOptionWithBoolSelectorFieldClass =
2026     CommonOptionWithBoolSelectorFieldClass<const bt_field_class>;
2027
2028 namespace internal {
2029
2030 struct OptionWithBoolSelectorFieldClassTypeDescr
2031 {
2032     using Const = ConstOptionWithBoolSelectorFieldClass;
2033     using NonConst = OptionWithBoolSelectorFieldClass;
2034 };
2035
2036 template <>
2037 struct TypeDescr<OptionWithBoolSelectorFieldClass> :
2038     public OptionWithBoolSelectorFieldClassTypeDescr
2039 {
2040 };
2041
2042 template <>
2043 struct TypeDescr<ConstOptionWithBoolSelectorFieldClass> :
2044     public OptionWithBoolSelectorFieldClassTypeDescr
2045 {
2046 };
2047
2048 template <typename RangeSetT>
2049 struct CommonOptionWithIntegerSelectorFieldClassSpec;
2050
2051 /* Functions specific to option field classes with unsigned integer ranges */
2052 template <>
2053 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstUnsignedIntegerRangeSet> final
2054 {
2055     static const bt_integer_range_set_unsigned *
2056     ranges(const bt_field_class * const libObjPtr) noexcept
2057     {
2058         return bt_field_class_option_with_selector_field_integer_unsigned_borrow_selector_ranges_const(
2059             libObjPtr);
2060     }
2061 };
2062
2063 /* Functions specific to option field classes with signed ranges */
2064 template <>
2065 struct CommonOptionWithIntegerSelectorFieldClassSpec<ConstSignedIntegerRangeSet> final
2066 {
2067     static const bt_integer_range_set_signed *
2068     ranges(const bt_field_class * const libObjPtr) noexcept
2069     {
2070         return bt_field_class_option_with_selector_field_integer_signed_borrow_selector_ranges_const(
2071             libObjPtr);
2072     }
2073 };
2074
2075 } /* namespace internal */
2076
2077 template <typename LibObjT, typename RangeSetT>
2078 class CommonOptionWithIntegerSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
2079 {
2080 private:
2081     using typename CommonOptionWithSelectorFieldClass<
2082         LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
2083
2084 public:
2085     using typename CommonFieldClass<LibObjT>::LibObjPtr;
2086     using Shared = SharedFieldClass<CommonOptionWithIntegerSelectorFieldClass, LibObjT>;
2087     using RangeSet = RangeSetT;
2088
2089     explicit CommonOptionWithIntegerSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
2090         _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
2091     {
2092         BT_ASSERT_DBG(this->isOptionWithIntegerSelector());
2093     }
2094
2095     template <typename OtherLibObjT>
2096     CommonOptionWithIntegerSelectorFieldClass(
2097         const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept :
2098         _ThisCommonOptionWithSelectorFieldClass {fc}
2099     {
2100     }
2101
2102     template <typename OtherLibObjT>
2103     CommonOptionWithIntegerSelectorFieldClass
2104     operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept
2105     {
2106         _ThisCommonOptionWithSelectorFieldClass::operator=(fc);
2107         return *this;
2108     }
2109
2110     RangeSet ranges() const noexcept
2111     {
2112         return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
2113             this->libObjPtr())};
2114     }
2115
2116     Shared shared() const noexcept
2117     {
2118         return Shared::createWithRef(*this);
2119     }
2120 };
2121
2122 using OptionWithUnsignedIntegerSelectorFieldClass =
2123     CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstUnsignedIntegerRangeSet>;
2124
2125 using ConstOptionWithUnsignedIntegerSelectorFieldClass =
2126     CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstUnsignedIntegerRangeSet>;
2127
2128 using OptionWithSignedIntegerSelectorFieldClass =
2129     CommonOptionWithIntegerSelectorFieldClass<bt_field_class, ConstSignedIntegerRangeSet>;
2130
2131 using ConstOptionWithSignedIntegerSelectorFieldClass =
2132     CommonOptionWithIntegerSelectorFieldClass<const bt_field_class, ConstSignedIntegerRangeSet>;
2133
2134 namespace internal {
2135
2136 struct OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
2137 {
2138     using Const = ConstOptionWithUnsignedIntegerSelectorFieldClass;
2139     using NonConst = OptionWithUnsignedIntegerSelectorFieldClass;
2140 };
2141
2142 template <>
2143 struct TypeDescr<OptionWithUnsignedIntegerSelectorFieldClass> :
2144     public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
2145 {
2146 };
2147
2148 template <>
2149 struct TypeDescr<ConstOptionWithUnsignedIntegerSelectorFieldClass> :
2150     public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
2151 {
2152 };
2153
2154 struct OptionWithSignedIntegerSelectorFieldClassTypeDescr
2155 {
2156     using Const = ConstOptionWithSignedIntegerSelectorFieldClass;
2157     using NonConst = OptionWithSignedIntegerSelectorFieldClass;
2158 };
2159
2160 template <>
2161 struct TypeDescr<OptionWithSignedIntegerSelectorFieldClass> :
2162     public OptionWithSignedIntegerSelectorFieldClassTypeDescr
2163 {
2164 };
2165
2166 template <>
2167 struct TypeDescr<ConstOptionWithSignedIntegerSelectorFieldClass> :
2168     public OptionWithSignedIntegerSelectorFieldClassTypeDescr
2169 {
2170 };
2171
2172 template <typename LibObjT>
2173 struct CommonVariantFieldClassOptionSpec;
2174
2175 /* Functions specific to mutable variant field class options */
2176 template <>
2177 struct CommonVariantFieldClassOptionSpec<bt_field_class_variant_option> final
2178 {
2179     static bt_field_class *fieldClass(bt_field_class_variant_option * const libObjPtr) noexcept
2180     {
2181         return bt_field_class_variant_option_borrow_field_class(libObjPtr);
2182     }
2183
2184     static bt_value *userAttributes(bt_field_class_variant_option * const libObjPtr) noexcept
2185     {
2186         return bt_field_class_variant_option_borrow_user_attributes(libObjPtr);
2187     }
2188 };
2189
2190 /* Functions specific to constant variant field class options */
2191 template <>
2192 struct CommonVariantFieldClassOptionSpec<const bt_field_class_variant_option> final
2193 {
2194     static const bt_field_class *
2195     fieldClass(const bt_field_class_variant_option * const libObjPtr) noexcept
2196     {
2197         return bt_field_class_variant_option_borrow_field_class_const(libObjPtr);
2198     }
2199
2200     static const bt_value *
2201     userAttributes(const bt_field_class_variant_option * const libObjPtr) noexcept
2202     {
2203         return bt_field_class_variant_option_borrow_user_attributes_const(libObjPtr);
2204     }
2205 };
2206
2207 } /* namespace internal */
2208
2209 template <typename LibObjT>
2210 class CommonVariantFieldClassOption : public BorrowedObject<LibObjT>
2211 {
2212 private:
2213     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
2214     using _FieldClass = internal::DepFc<LibObjT>;
2215
2216 public:
2217     using typename BorrowedObject<LibObjT>::LibObjPtr;
2218     using UserAttributes = internal::DepUserAttrs<LibObjT>;
2219
2220     explicit CommonVariantFieldClassOption(const LibObjPtr libObjPtr) noexcept :
2221         _ThisBorrowedObject {libObjPtr}
2222     {
2223     }
2224
2225     template <typename OtherLibObjT>
2226     CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept :
2227         _ThisBorrowedObject {fc}
2228     {
2229     }
2230
2231     template <typename OtherLibObjT>
2232     CommonVariantFieldClassOption
2233     operator=(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept
2234     {
2235         _ThisBorrowedObject::operator=(fc);
2236         return *this;
2237     }
2238
2239     CommonVariantFieldClassOption<const bt_field_class_variant_option> asConst() const noexcept
2240     {
2241         return CommonVariantFieldClassOption<const bt_field_class_variant_option> {*this};
2242     }
2243
2244     bt2c::CStringView name() const noexcept
2245     {
2246         return bt_field_class_variant_option_get_name(this->libObjPtr());
2247     }
2248
2249     _FieldClass fieldClass() const noexcept
2250     {
2251         return _FieldClass {
2252             internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
2253     }
2254
2255     template <typename LibValT>
2256     CommonVariantFieldClassOption
2257     userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
2258     {
2259         static_assert(!std::is_const<LibObjT>::value,
2260                       "Not available with `bt2::ConstVariantFieldClassOption`.");
2261
2262         bt_field_class_variant_option_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
2263         return *this;
2264     }
2265
2266     UserAttributes userAttributes() const noexcept
2267     {
2268         return UserAttributes {internal::CommonVariantFieldClassOptionSpec<LibObjT>::userAttributes(
2269             this->libObjPtr())};
2270     }
2271 };
2272
2273 using VariantFieldClassOption = CommonVariantFieldClassOption<bt_field_class_variant_option>;
2274
2275 using ConstVariantFieldClassOption =
2276     CommonVariantFieldClassOption<const bt_field_class_variant_option>;
2277
2278 namespace internal {
2279
2280 struct VariantFieldClassOptionTypeDescr
2281 {
2282     using Const = ConstVariantFieldClassOption;
2283     using NonConst = VariantFieldClassOption;
2284 };
2285
2286 template <>
2287 struct TypeDescr<VariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
2288 {
2289 };
2290
2291 template <>
2292 struct TypeDescr<ConstVariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
2293 {
2294 };
2295
2296 template <typename LibObjT>
2297 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
2298
2299 /* Functions specific to variant field class options with unsigned integer selector */
2300 template <>
2301 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
2302     const bt_field_class_variant_with_selector_field_integer_unsigned_option>
2303     final
2304 {
2305     static const bt_integer_range_set_unsigned *
2306     ranges(const bt_field_class_variant_with_selector_field_integer_unsigned_option
2307                * const libObjPtr) noexcept
2308     {
2309         return bt_field_class_variant_with_selector_field_integer_unsigned_option_borrow_ranges_const(
2310             libObjPtr);
2311     }
2312
2313     static const bt_field_class_variant_option *
2314     asBaseOption(const bt_field_class_variant_with_selector_field_integer_unsigned_option
2315                      * const libObjPtr) noexcept
2316     {
2317         return bt_field_class_variant_with_selector_field_integer_unsigned_option_as_option_const(
2318             libObjPtr);
2319     }
2320 };
2321
2322 /* Functions specific to variant field class options with signed integer selector */
2323 template <>
2324 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
2325     const bt_field_class_variant_with_selector_field_integer_signed_option>
2326     final
2327 {
2328     static const bt_integer_range_set_signed *
2329     ranges(const bt_field_class_variant_with_selector_field_integer_signed_option
2330                * const libObjPtr) noexcept
2331     {
2332         return bt_field_class_variant_with_selector_field_integer_signed_option_borrow_ranges_const(
2333             libObjPtr);
2334     }
2335
2336     static const bt_field_class_variant_option *
2337     asBaseOption(const bt_field_class_variant_with_selector_field_integer_signed_option
2338                      * const libObjPtr) noexcept
2339     {
2340         return bt_field_class_variant_with_selector_field_integer_signed_option_as_option_const(
2341             libObjPtr);
2342     }
2343 };
2344
2345 } /* namespace internal */
2346
2347 template <typename LibObjT>
2348 class ConstVariantWithIntegerSelectorFieldClassOption : public BorrowedObject<LibObjT>
2349 {
2350 private:
2351     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
2352     using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
2353
2354 public:
2355     using typename BorrowedObject<LibObjT>::LibObjPtr;
2356
2357     using RangeSet = typename std::conditional<
2358         std::is_same<
2359             LibObjT,
2360             const bt_field_class_variant_with_selector_field_integer_unsigned_option>::value,
2361         ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
2362
2363     explicit ConstVariantWithIntegerSelectorFieldClassOption(const LibObjPtr libObjPtr) noexcept :
2364         _ThisBorrowedObject {libObjPtr}
2365     {
2366     }
2367
2368     template <typename OtherLibObjT>
2369     ConstVariantWithIntegerSelectorFieldClassOption(
2370         const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept :
2371         _ThisBorrowedObject {fc}
2372     {
2373     }
2374
2375     template <typename OtherLibObjT>
2376     ConstVariantWithIntegerSelectorFieldClassOption
2377     operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept
2378     {
2379         _ThisBorrowedObject::operator=(fc);
2380         return *this;
2381     }
2382
2383     ConstVariantFieldClassOption asBaseOption() const noexcept
2384     {
2385         return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())};
2386     }
2387
2388     bt2c::CStringView name() const noexcept
2389     {
2390         return this->asBaseOption().name();
2391     }
2392
2393     ConstFieldClass fieldClass() const noexcept
2394     {
2395         return this->asBaseOption().fieldClass();
2396     }
2397
2398     RangeSet ranges() const noexcept
2399     {
2400         return RangeSet {_Spec::ranges(this->libObjPtr())};
2401     }
2402 };
2403
2404 using ConstVariantWithUnsignedIntegerSelectorFieldClassOption =
2405     ConstVariantWithIntegerSelectorFieldClassOption<
2406         const bt_field_class_variant_with_selector_field_integer_unsigned_option>;
2407
2408 using ConstVariantWithSignedIntegerSelectorFieldClassOption =
2409     ConstVariantWithIntegerSelectorFieldClassOption<
2410         const bt_field_class_variant_with_selector_field_integer_signed_option>;
2411
2412 namespace internal {
2413
2414 template <typename LibObjT>
2415 struct CommonVariantFieldClassSpec;
2416
2417 /* Functions specific to mutable variant field classes */
2418 template <>
2419 struct CommonVariantFieldClassSpec<bt_field_class> final
2420 {
2421     static bt_field_class_variant_option *optionByIndex(bt_field_class * const libObjPtr,
2422                                                         const std::uint64_t index) noexcept
2423     {
2424         return bt_field_class_variant_borrow_option_by_index(libObjPtr, index);
2425     }
2426
2427     static bt_field_class_variant_option *optionByName(bt_field_class * const libObjPtr,
2428                                                        const char * const name) noexcept
2429     {
2430         return bt_field_class_variant_borrow_option_by_name(libObjPtr, name);
2431     }
2432 };
2433
2434 /* Functions specific to constant variant field classes */
2435 template <>
2436 struct CommonVariantFieldClassSpec<const bt_field_class> final
2437 {
2438     static const bt_field_class_variant_option *
2439     optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2440     {
2441         return bt_field_class_variant_borrow_option_by_index_const(libObjPtr, index);
2442     }
2443
2444     static const bt_field_class_variant_option *optionByName(const bt_field_class * const libObjPtr,
2445                                                              const char * const name) noexcept
2446     {
2447         return bt_field_class_variant_borrow_option_by_name_const(libObjPtr, name);
2448     }
2449 };
2450
2451 } /* namespace internal */
2452
2453 template <typename LibObjT>
2454 class CommonVariantFieldClass : public CommonFieldClass<LibObjT>
2455 {
2456 private:
2457     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
2458
2459 protected:
2460     using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
2461
2462 public:
2463     using typename CommonFieldClass<LibObjT>::LibObjPtr;
2464     using Shared = SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
2465     using Iterator = BorrowedObjectIterator<CommonVariantFieldClass>;
2466
2467     using Option =
2468         internal::DepType<LibObjT, VariantFieldClassOption, ConstVariantFieldClassOption>;
2469
2470     explicit CommonVariantFieldClass(const LibObjPtr libObjPtr) noexcept :
2471         _ThisCommonFieldClass {libObjPtr}
2472     {
2473         BT_ASSERT_DBG(this->isVariant());
2474     }
2475
2476     template <typename OtherLibObjT>
2477     CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept :
2478         _ThisCommonFieldClass {fc}
2479     {
2480     }
2481
2482     template <typename OtherLibObjT>
2483     CommonVariantFieldClass operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
2484     {
2485         _ThisCommonFieldClass::operator=(fc);
2486         return *this;
2487     }
2488
2489     CommonVariantFieldClass<const bt_field_class> asConst() const noexcept
2490     {
2491         return CommonVariantFieldClass<const bt_field_class> {*this};
2492     }
2493
2494     std::uint64_t length() const noexcept
2495     {
2496         return bt_field_class_variant_get_option_count(this->libObjPtr());
2497     }
2498
2499     Iterator begin() const noexcept
2500     {
2501         return Iterator {*this, 0};
2502     }
2503
2504     Iterator end() const noexcept
2505     {
2506         return Iterator {*this, this->length()};
2507     }
2508
2509     Option operator[](const std::uint64_t index) const noexcept
2510     {
2511         return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
2512             this->libObjPtr(), index)};
2513     }
2514
2515     OptionalBorrowedObject<Option> operator[](const bt2c::CStringView name) const noexcept
2516     {
2517         return internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(),
2518                                                                             name);
2519     }
2520
2521     Shared shared() const noexcept
2522     {
2523         return Shared::createWithRef(*this);
2524     }
2525 };
2526
2527 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
2528 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
2529
2530 namespace internal {
2531
2532 struct VariantFieldClassTypeDescr
2533 {
2534     using Const = ConstVariantFieldClass;
2535     using NonConst = VariantFieldClass;
2536 };
2537
2538 template <>
2539 struct TypeDescr<VariantFieldClass> : public VariantFieldClassTypeDescr
2540 {
2541 };
2542
2543 template <>
2544 struct TypeDescr<ConstVariantFieldClass> : public VariantFieldClassTypeDescr
2545 {
2546 };
2547
2548 } /* namespace internal */
2549
2550 template <typename LibObjT>
2551 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
2552 {
2553 private:
2554     using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
2555
2556 public:
2557     using typename CommonFieldClass<LibObjT>::LibObjPtr;
2558     using Shared = SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
2559
2560     explicit CommonVariantWithoutSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
2561         _ThisCommonVariantFieldClass {libObjPtr}
2562     {
2563         BT_ASSERT_DBG(this->isVariantWithoutSelector());
2564     }
2565
2566     template <typename OtherLibObjT>
2567     CommonVariantWithoutSelectorFieldClass(
2568         const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept :
2569         _ThisCommonVariantFieldClass {fc}
2570     {
2571     }
2572
2573     template <typename OtherLibObjT>
2574     CommonVariantWithoutSelectorFieldClass
2575     operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept
2576     {
2577         _ThisCommonVariantFieldClass::operator=(fc);
2578         return *this;
2579     }
2580
2581     CommonVariantWithoutSelectorFieldClass<const bt_field_class> asConst() const noexcept
2582     {
2583         return CommonVariantWithoutSelectorFieldClass<const bt_field_class> {*this};
2584     }
2585
2586     CommonVariantWithoutSelectorFieldClass appendOption(const char * const name,
2587                                                         const FieldClass fc) const
2588     {
2589         static_assert(!std::is_const<LibObjT>::value,
2590                       "Not available with `bt2::ConstVariantWithoutSelectorFieldClass`.");
2591
2592         const auto status = bt_field_class_variant_without_selector_append_option(
2593             this->libObjPtr(), name, fc.libObjPtr());
2594
2595         if (status ==
2596             BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2597             throw MemoryError {};
2598         }
2599
2600         return *this;
2601     }
2602
2603     CommonVariantWithoutSelectorFieldClass appendOption(const bt2c::CStringView name,
2604                                                         const FieldClass fc) const
2605     {
2606         return this->appendOption(name.data(), fc);
2607     }
2608
2609     CommonVariantWithoutSelectorFieldClass appendOption(const bt2s::optional<std::string>& name,
2610                                                         const FieldClass fc) const
2611     {
2612         return this->appendOption(name ? name->data() : nullptr, fc);
2613     }
2614
2615     Shared shared() const noexcept
2616     {
2617         return Shared::createWithRef(*this);
2618     }
2619 };
2620
2621 using VariantWithoutSelectorFieldClass = CommonVariantWithoutSelectorFieldClass<bt_field_class>;
2622 using ConstVariantWithoutSelectorFieldClass =
2623     CommonVariantWithoutSelectorFieldClass<const bt_field_class>;
2624
2625 namespace internal {
2626
2627 struct VariantWithoutSelectorFieldClassTypeDescr
2628 {
2629     using Const = ConstVariantWithoutSelectorFieldClass;
2630     using NonConst = VariantWithoutSelectorFieldClass;
2631 };
2632
2633 template <>
2634 struct TypeDescr<VariantWithoutSelectorFieldClass> :
2635     public VariantWithoutSelectorFieldClassTypeDescr
2636 {
2637 };
2638
2639 template <>
2640 struct TypeDescr<ConstVariantWithoutSelectorFieldClass> :
2641     public VariantWithoutSelectorFieldClassTypeDescr
2642 {
2643 };
2644
2645 template <typename OptionT>
2646 struct CommonVariantWithIntegerSelectorFieldClassSpec;
2647
2648 /* Functions specific to variant field classes with unsigned integer selector */
2649 template <>
2650 struct CommonVariantWithIntegerSelectorFieldClassSpec<
2651     ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2652     final
2653 {
2654     static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
2655     optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2656     {
2657         return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_index_const(
2658             libObjPtr, index);
2659     }
2660
2661     static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
2662     optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
2663     {
2664         return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_name_const(
2665             libObjPtr, name);
2666     }
2667
2668     static bt_field_class_variant_with_selector_field_integer_append_option_status
2669     appendOption(bt_field_class * const libObjPtr, const char * const name,
2670                  bt_field_class * const libOptFcPtr,
2671                  const bt_integer_range_set_unsigned * const libRangesPtr)
2672     {
2673         return bt_field_class_variant_with_selector_field_integer_unsigned_append_option(
2674             libObjPtr, name, libOptFcPtr, libRangesPtr);
2675     }
2676 };
2677
2678 /* Functions specific to variant field classes with signed integer selector */
2679 template <>
2680 struct CommonVariantWithIntegerSelectorFieldClassSpec<
2681     ConstVariantWithSignedIntegerSelectorFieldClassOption>
2682     final
2683 {
2684     static const bt_field_class_variant_with_selector_field_integer_signed_option *
2685     optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2686     {
2687         return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_index_const(
2688             libObjPtr, index);
2689     }
2690
2691     static const bt_field_class_variant_with_selector_field_integer_signed_option *
2692     optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
2693     {
2694         return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_name_const(
2695             libObjPtr, name);
2696     }
2697
2698     static bt_field_class_variant_with_selector_field_integer_append_option_status
2699     appendOption(bt_field_class * const libObjPtr, const char * const name,
2700                  bt_field_class * const libOptFcPtr,
2701                  const bt_integer_range_set_signed * const libRangesPtr)
2702     {
2703         return bt_field_class_variant_with_selector_field_integer_signed_append_option(
2704             libObjPtr, name, libOptFcPtr, libRangesPtr);
2705     }
2706 };
2707
2708 } /* namespace internal */
2709
2710 template <typename LibObjT>
2711 class CommonVariantWithSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
2712 {
2713 private:
2714     using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
2715
2716 protected:
2717     using _ThisCommonVariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<LibObjT>;
2718
2719 public:
2720     using typename CommonFieldClass<LibObjT>::LibObjPtr;
2721     using Shared = SharedFieldClass<_ThisCommonVariantWithSelectorFieldClass, LibObjT>;
2722
2723     explicit CommonVariantWithSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
2724         _ThisCommonVariantFieldClass {libObjPtr}
2725     {
2726         BT_ASSERT_DBG(this->isVariantWithSelector());
2727     }
2728
2729     template <typename OtherLibObjT>
2730     CommonVariantWithSelectorFieldClass(
2731         const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept :
2732         _ThisCommonVariantFieldClass {fc}
2733     {
2734     }
2735
2736     template <typename OtherLibObjT>
2737     CommonVariantWithSelectorFieldClass
2738     operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept
2739     {
2740         _ThisCommonVariantFieldClass::operator=(fc);
2741         return *this;
2742     }
2743
2744     CommonVariantWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
2745     {
2746         return CommonVariantWithSelectorFieldClass<const bt_field_class> {*this};
2747     }
2748
2749     ConstFieldPath selectorFieldPath() const noexcept
2750     {
2751         return ConstFieldPath {
2752             bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
2753                 this->libObjPtr())};
2754     }
2755
2756     ConstFieldLocation selectorFieldLocation() const noexcept
2757     {
2758         return ConstFieldLocation {
2759             bt_field_class_variant_with_selector_field_borrow_selector_field_location_const(
2760                 this->libObjPtr())};
2761     }
2762
2763     Shared shared() const noexcept
2764     {
2765         return Shared::createWithRef(*this);
2766     }
2767 };
2768
2769 using VariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<bt_field_class>;
2770 using ConstVariantWithSelectorFieldClass =
2771     CommonVariantWithSelectorFieldClass<const bt_field_class>;
2772
2773 template <typename LibObjT, typename OptionT>
2774 class CommonVariantWithIntegerSelectorFieldClass :
2775     public CommonVariantWithSelectorFieldClass<LibObjT>
2776 {
2777 private:
2778     using typename CommonVariantWithSelectorFieldClass<
2779         LibObjT>::_ThisCommonVariantWithSelectorFieldClass;
2780
2781     using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
2782
2783 public:
2784     using typename CommonFieldClass<LibObjT>::LibObjPtr;
2785     using Shared = SharedFieldClass<CommonVariantWithIntegerSelectorFieldClass, LibObjT>;
2786     using Option = OptionT;
2787
2788     using Iterator =
2789         BorrowedObjectIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>>;
2790
2791     explicit CommonVariantWithIntegerSelectorFieldClass(const LibObjPtr libObjPtr) noexcept :
2792         _ThisCommonVariantWithSelectorFieldClass {libObjPtr}
2793     {
2794         BT_ASSERT_DBG(this->isVariantWithIntegerSelector());
2795     }
2796
2797     template <typename OtherLibObjT>
2798     CommonVariantWithIntegerSelectorFieldClass(
2799         const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept :
2800         _ThisCommonVariantWithSelectorFieldClass {fc}
2801     {
2802     }
2803
2804     template <typename OtherLibObjT>
2805     CommonVariantWithIntegerSelectorFieldClass
2806     operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept
2807     {
2808         _ThisCommonVariantWithSelectorFieldClass::operator=(fc);
2809         return *this;
2810     }
2811
2812     Option operator[](const std::uint64_t index) const noexcept
2813     {
2814         return Option {_Spec::optionByIndex(this->libObjPtr(), index)};
2815     }
2816
2817     OptionalBorrowedObject<Option> operator[](const bt2c::CStringView name) const noexcept
2818     {
2819         return _Spec::optionByName(this->libObjPtr(), name);
2820     }
2821
2822     CommonVariantWithIntegerSelectorFieldClass
2823     appendOption(const char * const name, const FieldClass fc,
2824                  const typename Option::RangeSet ranges) const
2825     {
2826         static_assert(
2827             !std::is_const<LibObjT>::value,
2828             "Not available with `bt2::ConstVariantWithUnsignedIntegerSelectorFieldClass`.");
2829
2830         const auto status =
2831             _Spec::appendOption(this->libObjPtr(), name, fc.libObjPtr(), ranges.libObjPtr());
2832
2833         if (status ==
2834             BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2835             throw MemoryError {};
2836         }
2837
2838         return *this;
2839     }
2840
2841     CommonVariantWithIntegerSelectorFieldClass
2842     appendOption(const bt2c::CStringView name, const FieldClass fc,
2843                  const typename Option::RangeSet ranges) const
2844     {
2845         return this->appendOption(name.data(), fc, ranges);
2846     }
2847
2848     CommonVariantWithIntegerSelectorFieldClass
2849     appendOption(const bt2s::optional<std::string>& name, const FieldClass fc,
2850                  const typename Option::RangeSet ranges) const
2851     {
2852         return this->appendOption(name ? name->data() : nullptr, fc, ranges);
2853     }
2854
2855     Iterator begin() const noexcept
2856     {
2857         return Iterator {*this, 0};
2858     }
2859
2860     Iterator end() const noexcept
2861     {
2862         return Iterator {*this, this->length()};
2863     }
2864
2865     Shared shared() const noexcept
2866     {
2867         return Shared::createWithRef(*this);
2868     }
2869 };
2870
2871 using VariantWithUnsignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2872     bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2873
2874 using ConstVariantWithUnsignedIntegerSelectorFieldClass =
2875     CommonVariantWithIntegerSelectorFieldClass<
2876         const bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2877
2878 using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2879     bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2880
2881 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2882     const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2883
2884 namespace internal {
2885
2886 struct VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2887 {
2888     using Const = ConstVariantWithUnsignedIntegerSelectorFieldClass;
2889     using NonConst = VariantWithUnsignedIntegerSelectorFieldClass;
2890 };
2891
2892 template <>
2893 struct TypeDescr<VariantWithUnsignedIntegerSelectorFieldClass> :
2894     public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2895 {
2896 };
2897
2898 template <>
2899 struct TypeDescr<ConstVariantWithUnsignedIntegerSelectorFieldClass> :
2900     public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2901 {
2902 };
2903
2904 struct VariantWithSignedIntegerSelectorFieldClassTypeDescr
2905 {
2906     using Const = ConstVariantWithSignedIntegerSelectorFieldClass;
2907     using NonConst = VariantWithSignedIntegerSelectorFieldClass;
2908 };
2909
2910 template <>
2911 struct TypeDescr<VariantWithSignedIntegerSelectorFieldClass> :
2912     public VariantWithSignedIntegerSelectorFieldClassTypeDescr
2913 {
2914 };
2915
2916 template <>
2917 struct TypeDescr<ConstVariantWithSignedIntegerSelectorFieldClass> :
2918     public VariantWithSignedIntegerSelectorFieldClassTypeDescr
2919 {
2920 };
2921
2922 } /* namespace internal */
2923
2924 template <typename LibObjT>
2925 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
2926 {
2927     return CommonBitArrayFieldClass<LibObjT> {this->libObjPtr()};
2928 }
2929
2930 template <typename LibObjT>
2931 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
2932 {
2933     return CommonIntegerFieldClass<LibObjT> {this->libObjPtr()};
2934 }
2935
2936 template <typename LibObjT>
2937 CommonBaseEnumerationFieldClass<LibObjT> CommonFieldClass<LibObjT>::asEnumeration() const noexcept
2938 {
2939     return CommonBaseEnumerationFieldClass<LibObjT> {this->libObjPtr()};
2940 }
2941
2942 template <typename LibObjT>
2943 CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping>
2944 CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
2945 {
2946     BT_ASSERT_DBG(this->isUnsignedEnumeration());
2947     return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
2948         this->libObjPtr()};
2949 }
2950
2951 template <typename LibObjT>
2952 CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping>
2953 CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
2954 {
2955     BT_ASSERT_DBG(this->isSignedEnumeration());
2956     return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
2957         this->libObjPtr()};
2958 }
2959
2960 template <typename LibObjT>
2961 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
2962 {
2963     return CommonStructureFieldClass<LibObjT> {this->libObjPtr()};
2964 }
2965
2966 template <typename LibObjT>
2967 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
2968 {
2969     return CommonArrayFieldClass<LibObjT> {this->libObjPtr()};
2970 }
2971
2972 template <typename LibObjT>
2973 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
2974 {
2975     return CommonStaticArrayFieldClass<LibObjT> {this->libObjPtr()};
2976 }
2977
2978 template <typename LibObjT>
2979 CommonDynamicArrayWithLengthFieldClass<LibObjT>
2980 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
2981 {
2982     return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->libObjPtr()};
2983 }
2984
2985 template <typename LibObjT>
2986 CommonBlobFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBlob() const noexcept
2987 {
2988     BT_ASSERT_DBG(this->isBlob());
2989     return CommonBlobFieldClass<LibObjT> {this->libObjPtr()};
2990 }
2991
2992 template <typename LibObjT>
2993 CommonStaticBlobFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticBlob() const noexcept
2994 {
2995     BT_ASSERT_DBG(this->isStaticBlob());
2996     return CommonStaticBlobFieldClass<LibObjT> {this->libObjPtr()};
2997 }
2998
2999 template <typename LibObjT>
3000 CommonDynamicBlobWithLengthFieldClass<LibObjT>
3001 CommonFieldClass<LibObjT>::asDynamicBlobWithLength() const noexcept
3002 {
3003     BT_ASSERT_DBG(this->isDynamicBlobWithLength());
3004     return CommonDynamicBlobWithLengthFieldClass<LibObjT> {this->libObjPtr()};
3005 }
3006
3007 template <typename LibObjT>
3008 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
3009 {
3010     return CommonOptionFieldClass<LibObjT> {this->libObjPtr()};
3011 }
3012
3013 template <typename LibObjT>
3014 CommonOptionWithSelectorFieldClass<LibObjT>
3015 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
3016 {
3017     return CommonOptionWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
3018 }
3019
3020 template <typename LibObjT>
3021 CommonOptionWithBoolSelectorFieldClass<LibObjT>
3022 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
3023 {
3024     return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->libObjPtr()};
3025 }
3026
3027 template <typename LibObjT>
3028 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
3029 CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
3030 {
3031     BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
3032     return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
3033         this->libObjPtr()};
3034 }
3035
3036 template <typename LibObjT>
3037 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
3038 CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
3039 {
3040     BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
3041     return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
3042         this->libObjPtr()};
3043 }
3044
3045 template <typename LibObjT>
3046 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
3047 {
3048     return CommonVariantFieldClass<LibObjT> {this->libObjPtr()};
3049 }
3050
3051 template <typename LibObjT>
3052 CommonVariantWithoutSelectorFieldClass<LibObjT>
3053 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
3054 {
3055     return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->libObjPtr()};
3056 }
3057
3058 template <typename LibObjT>
3059 CommonVariantWithSelectorFieldClass<LibObjT>
3060 CommonFieldClass<LibObjT>::asVariantWithSelector() const noexcept
3061 {
3062     return CommonVariantWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
3063 }
3064
3065 template <typename LibObjT>
3066 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
3067                                            ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
3068 CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
3069 {
3070     BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
3071     return CommonVariantWithIntegerSelectorFieldClass<
3072         LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
3073 }
3074
3075 template <typename LibObjT>
3076 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
3077                                            ConstVariantWithSignedIntegerSelectorFieldClassOption>
3078 CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
3079 {
3080     BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
3081     return CommonVariantWithIntegerSelectorFieldClass<
3082         LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
3083 }
3084
3085 } /* namespace bt2 */
3086
3087 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP */