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