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