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