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     nonstd::optional<bpstd::string_view> name() const noexcept
1903     {
1904         const auto name = bt_field_class_variant_option_get_name(this->libObjPtr());
1905
1906         if (name) {
1907             return name;
1908         }
1909
1910         return nonstd::nullopt;
1911     }
1912
1913     ConstFieldClass fieldClass() const noexcept
1914     {
1915         return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
1916             const bt_field_class_variant_option>::fieldClass(this->libObjPtr())};
1917     }
1918
1919     _FieldClass fieldClass() noexcept
1920     {
1921         return _FieldClass {
1922             internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
1923     }
1924 };
1925
1926 using VariantFieldClassOption = CommonVariantFieldClassOption<bt_field_class_variant_option>;
1927
1928 using ConstVariantFieldClassOption =
1929     CommonVariantFieldClassOption<const bt_field_class_variant_option>;
1930
1931 namespace internal {
1932
1933 struct VariantFieldClassOptionTypeDescr
1934 {
1935     using Const = ConstVariantFieldClassOption;
1936     using NonConst = VariantFieldClassOption;
1937 };
1938
1939 template <>
1940 struct TypeDescr<VariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
1941 {
1942 };
1943
1944 template <>
1945 struct TypeDescr<ConstVariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
1946 {
1947 };
1948
1949 template <typename LibObjT>
1950 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
1951
1952 /* Functions specific to variant field class options with unsigned integer selector */
1953 template <>
1954 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1955     const bt_field_class_variant_with_selector_field_integer_unsigned_option>
1956     final
1957 {
1958     static const bt_integer_range_set_unsigned *
1959     ranges(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1960                * const libObjPtr) noexcept
1961     {
1962         return bt_field_class_variant_with_selector_field_integer_unsigned_option_borrow_ranges_const(
1963             libObjPtr);
1964     }
1965
1966     static const bt_field_class_variant_option *
1967     asBaseOption(const bt_field_class_variant_with_selector_field_integer_unsigned_option
1968                      * const libObjPtr) noexcept
1969     {
1970         return bt_field_class_variant_with_selector_field_integer_unsigned_option_as_option_const(
1971             libObjPtr);
1972     }
1973 };
1974
1975 /* Functions specific to variant field class options with signed integer selector */
1976 template <>
1977 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
1978     const bt_field_class_variant_with_selector_field_integer_signed_option>
1979     final
1980 {
1981     static const bt_integer_range_set_signed *
1982     ranges(const bt_field_class_variant_with_selector_field_integer_signed_option
1983                * const libObjPtr) noexcept
1984     {
1985         return bt_field_class_variant_with_selector_field_integer_signed_option_borrow_ranges_const(
1986             libObjPtr);
1987     }
1988
1989     static const bt_field_class_variant_option *
1990     asBaseOption(const bt_field_class_variant_with_selector_field_integer_signed_option
1991                      * const libObjPtr) noexcept
1992     {
1993         return bt_field_class_variant_with_selector_field_integer_signed_option_as_option_const(
1994             libObjPtr);
1995     }
1996 };
1997
1998 } /* namespace internal */
1999
2000 template <typename LibObjT>
2001 class ConstVariantWithIntegerSelectorFieldClassOption : public internal::BorrowedObj<LibObjT>
2002 {
2003 private:
2004     using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
2005     using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
2006     using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
2007
2008 public:
2009     using RangeSet = typename std::conditional<
2010         std::is_same<
2011             LibObjT,
2012             const bt_field_class_variant_with_selector_field_integer_unsigned_option>::value,
2013         ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
2014
2015     explicit ConstVariantWithIntegerSelectorFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
2016         _ThisBorrowedObj {libObjPtr}
2017     {
2018     }
2019
2020     template <typename OtherLibObjT>
2021     ConstVariantWithIntegerSelectorFieldClassOption(
2022         const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept :
2023         _ThisBorrowedObj {fc}
2024     {
2025     }
2026
2027     template <typename OtherLibObjT>
2028     ConstVariantWithIntegerSelectorFieldClassOption&
2029     operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept
2030     {
2031         _ThisBorrowedObj::operator=(fc);
2032         return *this;
2033     }
2034
2035     ConstVariantFieldClassOption asBaseOption() const noexcept
2036     {
2037         return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())};
2038     }
2039
2040     nonstd::optional<bpstd::string_view> name() const noexcept
2041     {
2042         return this->asBaseOption().name();
2043     }
2044
2045     ConstFieldClass fieldClass() const noexcept
2046     {
2047         return this->asBaseOption().fieldClass();
2048     }
2049
2050     RangeSet ranges() const noexcept
2051     {
2052         return RangeSet {_Spec::ranges(this->libObjPtr())};
2053     }
2054 };
2055
2056 using ConstVariantWithUnsignedIntegerSelectorFieldClassOption =
2057     ConstVariantWithIntegerSelectorFieldClassOption<
2058         const bt_field_class_variant_with_selector_field_integer_unsigned_option>;
2059
2060 using ConstVariantWithSignedIntegerSelectorFieldClassOption =
2061     ConstVariantWithIntegerSelectorFieldClassOption<
2062         const bt_field_class_variant_with_selector_field_integer_signed_option>;
2063
2064 namespace internal {
2065
2066 template <typename LibObjT>
2067 struct CommonVariantFieldClassSpec;
2068
2069 /* Functions specific to mutable variant field classes */
2070 template <>
2071 struct CommonVariantFieldClassSpec<bt_field_class> final
2072 {
2073     static bt_field_class_variant_option *optionByIndex(bt_field_class * const libObjPtr,
2074                                                         const std::uint64_t index) noexcept
2075     {
2076         return bt_field_class_variant_borrow_option_by_index(libObjPtr, index);
2077     }
2078
2079     static bt_field_class_variant_option *optionByName(bt_field_class * const libObjPtr,
2080                                                        const char * const name) noexcept
2081     {
2082         return bt_field_class_variant_borrow_option_by_name(libObjPtr, name);
2083     }
2084 };
2085
2086 /* Functions specific to constant variant field classes */
2087 template <>
2088 struct CommonVariantFieldClassSpec<const bt_field_class> final
2089 {
2090     static const bt_field_class_variant_option *
2091     optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2092     {
2093         return bt_field_class_variant_borrow_option_by_index_const(libObjPtr, index);
2094     }
2095
2096     static const bt_field_class_variant_option *optionByName(const bt_field_class * const libObjPtr,
2097                                                              const char * const name) noexcept
2098     {
2099         return bt_field_class_variant_borrow_option_by_name_const(libObjPtr, name);
2100     }
2101 };
2102
2103 } /* namespace internal */
2104
2105 template <typename LibObjT>
2106 class CommonVariantFieldClass : public CommonFieldClass<LibObjT>
2107 {
2108 private:
2109     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
2110
2111 protected:
2112     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
2113     using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
2114
2115 public:
2116     using Shared = internal::SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
2117
2118     using Option =
2119         typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
2120                                   VariantFieldClassOption>::type;
2121
2122     using Iterator = CommonIterator<CommonVariantFieldClass, Option>;
2123
2124     explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
2125         _ThisCommonFieldClass {libObjPtr}
2126     {
2127         BT_ASSERT_DBG(this->isVariant());
2128     }
2129
2130     template <typename OtherLibObjT>
2131     CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept :
2132         _ThisCommonFieldClass {fc}
2133     {
2134     }
2135
2136     template <typename OtherLibObjT>
2137     CommonVariantFieldClass& operator=(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept
2138     {
2139         _ThisCommonFieldClass::operator=(fc);
2140         return *this;
2141     }
2142
2143     std::uint64_t size() const noexcept
2144     {
2145         return bt_field_class_variant_get_option_count(this->libObjPtr());
2146     }
2147
2148     Iterator begin() const noexcept
2149     {
2150         return Iterator {*this, 0};
2151     }
2152
2153     Iterator end() const noexcept
2154     {
2155         return Iterator {*this, this->size()};
2156     }
2157
2158     ConstVariantFieldClassOption operator[](const std::uint64_t index) const noexcept
2159     {
2160         return ConstVariantFieldClassOption {
2161             internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
2162                 this->libObjPtr(), index)};
2163     }
2164
2165     Option operator[](const std::uint64_t index) noexcept
2166     {
2167         return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
2168             this->libObjPtr(), index)};
2169     }
2170
2171     nonstd::optional<ConstVariantFieldClassOption>
2172     operator[](const char * const name) const noexcept
2173     {
2174         const auto libObjPtr =
2175             internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
2176                 this->libObjPtr(), name);
2177
2178         if (libObjPtr) {
2179             return ConstVariantFieldClassOption {libObjPtr};
2180         }
2181
2182         return nonstd::nullopt;
2183     }
2184
2185     nonstd::optional<ConstVariantFieldClassOption>
2186     operator[](const std::string& name) const noexcept
2187     {
2188         return (*this)[name.data()];
2189     }
2190
2191     nonstd::optional<Option> operator[](const char * const name) noexcept
2192     {
2193         const auto libObjPtr =
2194             internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(), name);
2195
2196         if (libObjPtr) {
2197             return Option {libObjPtr};
2198         }
2199
2200         return nonstd::nullopt;
2201     }
2202
2203     nonstd::optional<Option> operator[](const std::string& name) noexcept
2204     {
2205         return (*this)[name.data()];
2206     }
2207
2208     Shared shared() const noexcept
2209     {
2210         return Shared::createWithRef(*this);
2211     }
2212 };
2213
2214 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
2215 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
2216
2217 namespace internal {
2218
2219 struct VariantFieldClassTypeDescr
2220 {
2221     using Const = ConstVariantFieldClass;
2222     using NonConst = VariantFieldClass;
2223 };
2224
2225 template <>
2226 struct TypeDescr<VariantFieldClass> : public VariantFieldClassTypeDescr
2227 {
2228 };
2229
2230 template <>
2231 struct TypeDescr<ConstVariantFieldClass> : public VariantFieldClassTypeDescr
2232 {
2233 };
2234
2235 } /* namespace internal */
2236
2237 template <typename LibObjT>
2238 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
2239 {
2240 private:
2241     using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
2242     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
2243
2244 public:
2245     using Shared =
2246         internal::SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
2247
2248     explicit CommonVariantWithoutSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
2249         _ThisCommonVariantFieldClass {libObjPtr}
2250     {
2251         BT_ASSERT_DBG(this->isVariantWithoutSelector());
2252     }
2253
2254     template <typename OtherLibObjT>
2255     CommonVariantWithoutSelectorFieldClass(
2256         const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept :
2257         _ThisCommonVariantFieldClass {fc}
2258     {
2259     }
2260
2261     template <typename OtherLibObjT>
2262     CommonVariantWithoutSelectorFieldClass&
2263     operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept
2264     {
2265         _ThisCommonVariantFieldClass::operator=(fc);
2266         return *this;
2267     }
2268
2269     void appendOption(const char * const name, const FieldClass& fc)
2270     {
2271         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
2272
2273         const auto status = bt_field_class_variant_without_selector_append_option(
2274             this->libObjPtr(), name, fc.libObjPtr());
2275
2276         if (status ==
2277             BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2278             throw LibMemoryError {};
2279         }
2280     }
2281
2282     void appendOption(const nonstd::optional<std::string>& name, const FieldClass& fc)
2283     {
2284         this->appendOption(name ? name->data() : nullptr, fc);
2285     }
2286
2287     Shared shared() const noexcept
2288     {
2289         return Shared::createWithRef(*this);
2290     }
2291 };
2292
2293 using VariantWithoutSelectorFieldClass = CommonVariantWithoutSelectorFieldClass<bt_field_class>;
2294 using ConstVariantWithoutSelectorFieldClass =
2295     CommonVariantWithoutSelectorFieldClass<const bt_field_class>;
2296
2297 namespace internal {
2298
2299 struct VariantWithoutSelectorFieldClassTypeDescr
2300 {
2301     using Const = ConstVariantWithoutSelectorFieldClass;
2302     using NonConst = VariantWithoutSelectorFieldClass;
2303 };
2304
2305 template <>
2306 struct TypeDescr<VariantWithoutSelectorFieldClass> :
2307     public VariantWithoutSelectorFieldClassTypeDescr
2308 {
2309 };
2310
2311 template <>
2312 struct TypeDescr<ConstVariantWithoutSelectorFieldClass> :
2313     public VariantWithoutSelectorFieldClassTypeDescr
2314 {
2315 };
2316
2317 template <typename OptionT>
2318 struct CommonVariantWithIntegerSelectorFieldClassSpec;
2319
2320 /* Functions specific to variant field classes with unsigned integer selector */
2321 template <>
2322 struct CommonVariantWithIntegerSelectorFieldClassSpec<
2323     ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2324     final
2325 {
2326     static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
2327     optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2328     {
2329         return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_index_const(
2330             libObjPtr, index);
2331     }
2332
2333     static const bt_field_class_variant_with_selector_field_integer_unsigned_option *
2334     optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
2335     {
2336         return bt_field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_name_const(
2337             libObjPtr, name);
2338     }
2339
2340     static bt_field_class_variant_with_selector_field_integer_append_option_status
2341     appendOption(bt_field_class * const libObjPtr, const char * const name,
2342                  bt_field_class * const libOptFcPtr,
2343                  const bt_integer_range_set_unsigned * const libRangesPtr)
2344     {
2345         return bt_field_class_variant_with_selector_field_integer_unsigned_append_option(
2346             libObjPtr, name, libOptFcPtr, libRangesPtr);
2347     }
2348 };
2349
2350 /* Functions specific to variant field classes with signed integer selector */
2351 template <>
2352 struct CommonVariantWithIntegerSelectorFieldClassSpec<
2353     ConstVariantWithSignedIntegerSelectorFieldClassOption>
2354     final
2355 {
2356     static const bt_field_class_variant_with_selector_field_integer_signed_option *
2357     optionByIndex(const bt_field_class * const libObjPtr, const std::uint64_t index) noexcept
2358     {
2359         return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_index_const(
2360             libObjPtr, index);
2361     }
2362
2363     static const bt_field_class_variant_with_selector_field_integer_signed_option *
2364     optionByName(const bt_field_class * const libObjPtr, const char * const name) noexcept
2365     {
2366         return bt_field_class_variant_with_selector_field_integer_signed_borrow_option_by_name_const(
2367             libObjPtr, name);
2368     }
2369
2370     static bt_field_class_variant_with_selector_field_integer_append_option_status
2371     appendOption(bt_field_class * const libObjPtr, const char * const name,
2372                  bt_field_class * const libOptFcPtr,
2373                  const bt_integer_range_set_signed * const libRangesPtr)
2374     {
2375         return bt_field_class_variant_with_selector_field_integer_signed_append_option(
2376             libObjPtr, name, libOptFcPtr, libRangesPtr);
2377     }
2378 };
2379
2380 } /* namespace internal */
2381
2382 template <typename LibObjT>
2383 class CommonVariantWithSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
2384 {
2385 private:
2386     using typename CommonVariantFieldClass<LibObjT>::_ThisCommonVariantFieldClass;
2387
2388 protected:
2389     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
2390     using _ThisCommonVariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<LibObjT>;
2391
2392 public:
2393     using Shared = internal::SharedFieldClass<_ThisCommonVariantWithSelectorFieldClass, LibObjT>;
2394
2395     explicit CommonVariantWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
2396         _ThisCommonVariantFieldClass {libObjPtr}
2397     {
2398         BT_ASSERT_DBG(this->isVariantWithSelector());
2399     }
2400
2401     template <typename OtherLibObjT>
2402     CommonVariantWithSelectorFieldClass(
2403         const CommonVariantWithSelectorFieldClass<OtherLibObjT>& fc) noexcept :
2404         _ThisCommonVariantFieldClass {fc}
2405     {
2406     }
2407
2408     template <typename OtherLibObjT>
2409     CommonVariantWithSelectorFieldClass&
2410     operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT>& fc) noexcept
2411     {
2412         _ThisCommonVariantFieldClass::operator=(fc);
2413         return *this;
2414     }
2415
2416     ConstFieldPath selectorFieldPath() const noexcept
2417     {
2418         return ConstFieldPath {
2419             bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
2420                 this->libObjPtr())};
2421     }
2422
2423     Shared shared() const noexcept
2424     {
2425         return Shared::createWithRef(*this);
2426     }
2427 };
2428
2429 using VariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<bt_field_class>;
2430 using ConstVariantWithSelectorFieldClass =
2431     CommonVariantWithSelectorFieldClass<const bt_field_class>;
2432
2433 template <typename LibObjT, typename OptionT>
2434 class CommonVariantWithIntegerSelectorFieldClass :
2435     public CommonVariantWithSelectorFieldClass<LibObjT>
2436 {
2437 private:
2438     using typename CommonVariantWithSelectorFieldClass<
2439         LibObjT>::_ThisCommonVariantWithSelectorFieldClass;
2440     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
2441     using _ThisCommonVariantWithIntegerSelectorFieldClass =
2442         CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
2443
2444     using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
2445
2446 public:
2447     using Shared =
2448         internal::SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
2449
2450     using Option = OptionT;
2451     using Iterator =
2452         CommonIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>, Option>;
2453
2454     explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
2455         _ThisCommonVariantWithSelectorFieldClass {libObjPtr}
2456     {
2457         BT_ASSERT_DBG(this->isVariant());
2458     }
2459
2460     template <typename OtherLibObjT>
2461     CommonVariantWithIntegerSelectorFieldClass(
2462         const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept :
2463         _ThisCommonVariantWithSelectorFieldClass {fc}
2464     {
2465     }
2466
2467     template <typename OtherLibObjT>
2468     CommonVariantWithIntegerSelectorFieldClass&
2469     operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept
2470     {
2471         _ThisCommonVariantWithSelectorFieldClass::operator=(fc);
2472         return *this;
2473     }
2474
2475     Option operator[](const std::uint64_t index) const noexcept
2476     {
2477         return Option {_Spec::optionByIndex(this->libObjPtr(), index)};
2478     }
2479
2480     nonstd::optional<Option> operator[](const char * const name) const noexcept
2481     {
2482         const auto libObjPtr = _Spec::optionByName(this->libObjPtr(), name);
2483
2484         if (libObjPtr) {
2485             return Option {libObjPtr};
2486         }
2487
2488         return nonstd::nullopt;
2489     }
2490
2491     nonstd::optional<Option> operator[](const std::string& name) const noexcept
2492     {
2493         return (*this)[name.data()];
2494     }
2495
2496     void appendOption(const char * const name, const FieldClass& fc,
2497                       const typename Option::RangeSet& ranges)
2498     {
2499         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
2500
2501         const auto status =
2502             _Spec::appendOption(this->libObjPtr(), name, fc.libObjPtr(), ranges.libObjPtr());
2503
2504         if (status ==
2505             BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
2506             throw LibMemoryError {};
2507         }
2508     }
2509
2510     void appendOption(const nonstd::optional<std::string>& name, const FieldClass& fc,
2511                       const typename Option::RangeSet& ranges)
2512     {
2513         this->appendOption(name ? name->data() : nullptr, fc, ranges);
2514     }
2515
2516     Iterator begin() const noexcept
2517     {
2518         return Iterator {*this, 0};
2519     }
2520
2521     Iterator end() const noexcept
2522     {
2523         return Iterator {*this, this->size()};
2524     }
2525
2526     Shared shared() const noexcept
2527     {
2528         return Shared::createWithRef(*this);
2529     }
2530 };
2531
2532 using VariantWithUnsignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2533     bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2534
2535 using ConstVariantWithUnsignedIntegerSelectorFieldClass =
2536     CommonVariantWithIntegerSelectorFieldClass<
2537         const bt_field_class, ConstVariantWithUnsignedIntegerSelectorFieldClassOption>;
2538
2539 using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2540     bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2541
2542 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
2543     const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
2544
2545 namespace internal {
2546
2547 struct VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2548 {
2549     using Const = ConstVariantWithUnsignedIntegerSelectorFieldClass;
2550     using NonConst = VariantWithUnsignedIntegerSelectorFieldClass;
2551 };
2552
2553 template <>
2554 struct TypeDescr<VariantWithUnsignedIntegerSelectorFieldClass> :
2555     public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2556 {
2557 };
2558
2559 template <>
2560 struct TypeDescr<ConstVariantWithUnsignedIntegerSelectorFieldClass> :
2561     public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
2562 {
2563 };
2564
2565 struct VariantWithSignedIntegerSelectorFieldClassTypeDescr
2566 {
2567     using Const = ConstVariantWithSignedIntegerSelectorFieldClass;
2568     using NonConst = VariantWithSignedIntegerSelectorFieldClass;
2569 };
2570
2571 template <>
2572 struct TypeDescr<VariantWithSignedIntegerSelectorFieldClass> :
2573     public VariantWithSignedIntegerSelectorFieldClassTypeDescr
2574 {
2575 };
2576
2577 template <>
2578 struct TypeDescr<ConstVariantWithSignedIntegerSelectorFieldClass> :
2579     public VariantWithSignedIntegerSelectorFieldClassTypeDescr
2580 {
2581 };
2582
2583 } /* namespace internal */
2584
2585 template <typename LibObjT>
2586 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
2587 {
2588     BT_ASSERT_DBG(this->isBitArray());
2589     return CommonBitArrayFieldClass<LibObjT> {this->libObjPtr()};
2590 }
2591
2592 template <typename LibObjT>
2593 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
2594 {
2595     BT_ASSERT_DBG(this->isInteger());
2596     return CommonIntegerFieldClass<LibObjT> {this->libObjPtr()};
2597 }
2598
2599 template <typename LibObjT>
2600 CommonBaseEnumerationFieldClass<LibObjT> CommonFieldClass<LibObjT>::asEnumeration() const noexcept
2601 {
2602     BT_ASSERT_DBG(this->isEnumeration());
2603     return CommonBaseEnumerationFieldClass<LibObjT> {this->libObjPtr()};
2604 }
2605
2606 template <typename LibObjT>
2607 CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping>
2608 CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
2609 {
2610     BT_ASSERT_DBG(this->isUnsignedEnumeration());
2611     return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
2612         this->libObjPtr()};
2613 }
2614
2615 template <typename LibObjT>
2616 CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping>
2617 CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
2618 {
2619     BT_ASSERT_DBG(this->isSignedEnumeration());
2620     return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
2621         this->libObjPtr()};
2622 }
2623
2624 template <typename LibObjT>
2625 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
2626 {
2627     BT_ASSERT_DBG(this->isStructure());
2628     return CommonStructureFieldClass<LibObjT> {this->libObjPtr()};
2629 }
2630
2631 template <typename LibObjT>
2632 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
2633 {
2634     BT_ASSERT_DBG(this->isArray());
2635     return CommonArrayFieldClass<LibObjT> {this->libObjPtr()};
2636 }
2637
2638 template <typename LibObjT>
2639 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
2640 {
2641     BT_ASSERT_DBG(this->isStaticArray());
2642     return CommonStaticArrayFieldClass<LibObjT> {this->libObjPtr()};
2643 }
2644
2645 template <typename LibObjT>
2646 CommonDynamicArrayWithLengthFieldClass<LibObjT>
2647 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
2648 {
2649     BT_ASSERT_DBG(this->isDynamicArrayWithLength());
2650     return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->libObjPtr()};
2651 }
2652
2653 template <typename LibObjT>
2654 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
2655 {
2656     BT_ASSERT_DBG(this->isOption());
2657     return CommonOptionFieldClass<LibObjT> {this->libObjPtr()};
2658 }
2659
2660 template <typename LibObjT>
2661 CommonOptionWithSelectorFieldClass<LibObjT>
2662 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
2663 {
2664     BT_ASSERT_DBG(this->isOptionWithSelector());
2665     return CommonOptionWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
2666 }
2667
2668 template <typename LibObjT>
2669 CommonOptionWithBoolSelectorFieldClass<LibObjT>
2670 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
2671 {
2672     BT_ASSERT_DBG(this->isOptionWithBoolSelector());
2673     return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->libObjPtr()};
2674 }
2675
2676 template <typename LibObjT>
2677 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet>
2678 CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
2679 {
2680     BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
2681     return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
2682         this->libObjPtr()};
2683 }
2684
2685 template <typename LibObjT>
2686 CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet>
2687 CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
2688 {
2689     BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
2690     return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
2691         this->libObjPtr()};
2692 }
2693
2694 template <typename LibObjT>
2695 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
2696 {
2697     BT_ASSERT_DBG(this->isVariant());
2698     return CommonVariantFieldClass<LibObjT> {this->libObjPtr()};
2699 }
2700
2701 template <typename LibObjT>
2702 CommonVariantWithoutSelectorFieldClass<LibObjT>
2703 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
2704 {
2705     BT_ASSERT_DBG(this->isVariantWithoutSelector());
2706     return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->libObjPtr()};
2707 }
2708
2709 template <typename LibObjT>
2710 CommonVariantWithSelectorFieldClass<LibObjT>
2711 CommonFieldClass<LibObjT>::asVariantWithSelector() const noexcept
2712 {
2713     BT_ASSERT_DBG(this->isVariantWithSelector());
2714     return CommonVariantWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
2715 }
2716
2717 template <typename LibObjT>
2718 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2719                                            ConstVariantWithUnsignedIntegerSelectorFieldClassOption>
2720 CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
2721 {
2722     BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
2723     return CommonVariantWithIntegerSelectorFieldClass<
2724         LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
2725 }
2726
2727 template <typename LibObjT>
2728 CommonVariantWithIntegerSelectorFieldClass<LibObjT,
2729                                            ConstVariantWithSignedIntegerSelectorFieldClassOption>
2730 CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
2731 {
2732     BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
2733     return CommonVariantWithIntegerSelectorFieldClass<
2734         LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
2735 }
2736
2737 } /* namespace bt2 */
2738
2739 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_CLASS_HPP */