src/cpp-common/bt2/field.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_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_FIELD_HPP
   9
  10 #include <cstdint>
  11 #include <type_traits>
  12
  13 #include <babeltrace2/babeltrace.h>
  14
  15 #include "common/assert.h"
  16 #include "cpp-common/bt2c/c-string-view.hpp"
  17
  18 #include "borrowed-object.hpp"
  19 #include "field-class.hpp"
  20 #include "internal/utils.hpp"
  21 #include "optional-borrowed-object.hpp"
  22 #include "raw-value-proxy.hpp"
  23
  24 namespace bt2 {
  25
  26 template <typename LibObjT>
  27 class CommonBoolField;
  28
  29 template <typename LibObjT>
  30 class CommonBitArrayField;
  31
  32 template <typename LibObjT>
  33 class CommonUnsignedIntegerField;
  34
  35 template <typename LibObjT>
  36 class CommonSignedIntegerField;
  37
  38 template <typename LibObjT>
  39 class CommonUnsignedEnumerationField;
  40
  41 template <typename LibObjT>
  42 class CommonSignedEnumerationField;
  43
  44 template <typename LibObjT>
  45 class CommonSinglePrecisionRealField;
  46
  47 template <typename LibObjT>
  48 class CommonDoublePrecisionRealField;
  49
  50 template <typename LibObjT>
  51 class CommonStringField;
  52
  53 template <typename LibObjT>
  54 class CommonStructureField;
  55
  56 template <typename LibObjT>
  57 class CommonArrayField;
  58
  59 template <typename LibObjT>
  60 class CommonDynamicArrayField;
  61
  62 template <typename LibObjT>
  63 class CommonOptionField;
  64
  65 template <typename LibObjT>
  66 class CommonVariantField;
  67
  68 namespace internal {
  69
  70 template <typename LibObjT>
  71 struct CommonFieldSpec;
  72
  73 /* Functions specific to mutable fields */
  74 template <>
  75 struct CommonFieldSpec<bt_field> final
  76 {
  77     static bt_field_class *cls(bt_field * const libObjPtr) noexcept
  78     {
  79         return bt_field_borrow_class(libObjPtr);
  80     }
  81 };
  82
  83 /* Functions specific to constant fields */
  84 template <>
  85 struct CommonFieldSpec<const bt_field> final
  86 {
  87     static const bt_field_class *cls(const bt_field * const libObjPtr) noexcept
  88     {
  89         return bt_field_borrow_class_const(libObjPtr);
  90     }
  91 };
  92
  93 } /* namespace internal */
  94
  95 template <typename LibObjT>
  96 class CommonField : public BorrowedObject<LibObjT>
  97 {
  98 private:
  99     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 100
 101 protected:
 102     using _ThisCommonField = CommonField<LibObjT>;
 103
 104 public:
 105     using typename BorrowedObject<LibObjT>::LibObjPtr;
 106     using Class = internal::DepFc<LibObjT>;
 107
 108     explicit CommonField(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 109     {
 110     }
 111
 112     template <typename OtherLibObjT>
 113     CommonField(const CommonField<OtherLibObjT> val) noexcept : _ThisBorrowedObject {val}
 114     {
 115     }
 116
 117     template <typename OtherLibObjT>
 118     _ThisCommonField operator=(const CommonField<OtherLibObjT> val) noexcept
 119     {
 120         _ThisBorrowedObject::operator=(val);
 121         return *this;
 122     }
 123
 124     CommonField<const bt_field> asConst() const noexcept
 125     {
 126         return CommonField<const bt_field> {*this};
 127     }
 128
 129     FieldClassType classType() const noexcept
 130     {
 131         return static_cast<FieldClassType>(bt_field_get_class_type(this->libObjPtr()));
 132     }
 133
 134     Class cls() const noexcept
 135     {
 136         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
 137     }
 138
 139     bool isBool() const noexcept
 140     {
 141         return this->cls().isBool();
 142     }
 143
 144     bool isBitArray() const noexcept
 145     {
 146         return this->cls().isBitArray();
 147     }
 148
 149     bool isUnsignedInteger() const noexcept
 150     {
 151         return this->cls().isUnsignedInteger();
 152     }
 153
 154     bool isSignedInteger() const noexcept
 155     {
 156         return this->cls().isSignedInteger();
 157     }
 158
 159     bool isUnsignedEnumeration() const noexcept
 160     {
 161         return this->cls().isUnsignedEnumeration();
 162     }
 163
 164     bool isSignedEnumeration() const noexcept
 165     {
 166         return this->cls().isSignedEnumeration();
 167     }
 168
 169     bool isSinglePrecisionReal() const noexcept
 170     {
 171         return this->cls().isSinglePrecisionReal();
 172     }
 173
 174     bool isDoublePrecisionReal() const noexcept
 175     {
 176         return this->cls().isDoublePrecisionReal();
 177     }
 178
 179     bool isString() const noexcept
 180     {
 181         return this->cls().isString();
 182     }
 183
 184     bool isStructure() const noexcept
 185     {
 186         return this->cls().isStructure();
 187     }
 188
 189     bool isArray() const noexcept
 190     {
 191         return this->cls().isArray();
 192     }
 193
 194     bool isDynamicArray() const noexcept
 195     {
 196         return this->cls().isDynamicArray();
 197     }
 198
 199     bool isOption() const noexcept
 200     {
 201         return this->cls().isOption();
 202     }
 203
 204     bool isVariant() const noexcept
 205     {
 206         return this->cls().isVariant();
 207     }
 208
 209     template <typename FieldT>
 210     FieldT as() const noexcept
 211     {
 212         return FieldT {this->libObjPtr()};
 213     }
 214
 215     CommonBoolField<LibObjT> asBool() const noexcept;
 216     CommonBitArrayField<LibObjT> asBitArray() const noexcept;
 217     CommonUnsignedIntegerField<LibObjT> asUnsignedInteger() const noexcept;
 218     CommonSignedIntegerField<LibObjT> asSignedInteger() const noexcept;
 219     CommonUnsignedEnumerationField<LibObjT> asUnsignedEnumeration() const noexcept;
 220     CommonSignedEnumerationField<LibObjT> asSignedEnumeration() const noexcept;
 221     CommonSinglePrecisionRealField<LibObjT> asSinglePrecisionReal() const noexcept;
 222     CommonDoublePrecisionRealField<LibObjT> asDoublePrecisionReal() const noexcept;
 223     CommonStringField<LibObjT> asString() const noexcept;
 224     CommonStructureField<LibObjT> asStructure() const noexcept;
 225     CommonArrayField<LibObjT> asArray() const noexcept;
 226     CommonDynamicArrayField<LibObjT> asDynamicArray() const noexcept;
 227     CommonOptionField<LibObjT> asOption() const noexcept;
 228     CommonVariantField<LibObjT> asVariant() const noexcept;
 229 };
 230
 231 using Field = CommonField<bt_field>;
 232 using ConstField = CommonField<const bt_field>;
 233
 234 namespace internal {
 235
 236 struct FieldTypeDescr
 237 {
 238     using Const = ConstField;
 239     using NonConst = Field;
 240 };
 241
 242 template <>
 243 struct TypeDescr<Field> : public FieldTypeDescr
 244 {
 245 };
 246
 247 template <>
 248 struct TypeDescr<ConstField> : public FieldTypeDescr
 249 {
 250 };
 251
 252 } /* namespace internal */
 253
 254 template <typename LibObjT>
 255 class CommonBoolField final : public CommonField<LibObjT>
 256 {
 257 private:
 258     using typename CommonField<LibObjT>::_ThisCommonField;
 259
 260 public:
 261     using typename CommonField<LibObjT>::LibObjPtr;
 262     using Value = bool;
 263
 264     explicit CommonBoolField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
 265     {
 266         BT_ASSERT_DBG(this->isBool());
 267     }
 268
 269     template <typename OtherLibObjT>
 270     CommonBoolField(const CommonBoolField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
 271     {
 272     }
 273
 274     template <typename OtherLibObjT>
 275     CommonBoolField<LibObjT> operator=(const CommonBoolField<OtherLibObjT> val) noexcept
 276     {
 277         _ThisCommonField::operator=(val);
 278         return *this;
 279     }
 280
 281     CommonBoolField<const bt_field> asConst() const noexcept
 282     {
 283         return CommonBoolField<const bt_field> {*this};
 284     }
 285
 286     RawValueProxy<CommonBoolField> operator*() const noexcept
 287     {
 288         return RawValueProxy<CommonBoolField> {*this};
 289     }
 290
 291     void value(const Value val) const noexcept
 292     {
 293         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstBoolField`.");
 294
 295         bt_field_bool_set_value(this->libObjPtr(), static_cast<bt_bool>(val));
 296     }
 297
 298     Value value() const noexcept
 299     {
 300         return static_cast<Value>(bt_field_bool_get_value(this->libObjPtr()));
 301     }
 302 };
 303
 304 using BoolField = CommonBoolField<bt_field>;
 305 using ConstBoolField = CommonBoolField<const bt_field>;
 306
 307 namespace internal {
 308
 309 struct BoolFieldTypeDescr
 310 {
 311     using Const = ConstBoolField;
 312     using NonConst = BoolField;
 313 };
 314
 315 template <>
 316 struct TypeDescr<BoolField> : public BoolFieldTypeDescr
 317 {
 318 };
 319
 320 template <>
 321 struct TypeDescr<ConstBoolField> : public BoolFieldTypeDescr
 322 {
 323 };
 324
 325 } /* namespace internal */
 326
 327 template <typename LibObjT>
 328 class CommonBitArrayField final : public CommonField<LibObjT>
 329 {
 330 private:
 331     using typename CommonField<LibObjT>::_ThisCommonField;
 332
 333 public:
 334     using typename CommonField<LibObjT>::LibObjPtr;
 335     using Class = internal::DepType<LibObjT, BitArrayFieldClass, ConstBitArrayFieldClass>;
 336
 337     explicit CommonBitArrayField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
 338     {
 339         BT_ASSERT_DBG(this->isBitArray());
 340     }
 341
 342     template <typename OtherLibObjT>
 343     CommonBitArrayField(const CommonBitArrayField<OtherLibObjT> val) noexcept :
 344         _ThisCommonField {val}
 345     {
 346     }
 347
 348     template <typename OtherLibObjT>
 349     CommonBitArrayField<LibObjT> operator=(const CommonBitArrayField<OtherLibObjT> val) noexcept
 350     {
 351         _ThisCommonField::operator=(val);
 352         return *this;
 353     }
 354
 355     CommonBitArrayField<const bt_field> asConst() const noexcept
 356     {
 357         return CommonBitArrayField<const bt_field> {*this};
 358     }
 359
 360     ConstBitArrayFieldClass cls() const noexcept
 361     {
 362         return ConstBitArrayFieldClass {
 363             internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
 364     }
 365
 366     Class cls() noexcept
 367     {
 368         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
 369     }
 370
 371     void valueAsInteger(const std::uint64_t bits) const noexcept
 372     {
 373         static_assert(!std::is_const<LibObjT>::value,
 374                       "Not available with `bt2::ConstBitArrayField`.");
 375
 376         bt_field_bit_array_set_value_as_integer(this->libObjPtr(), bits);
 377     }
 378
 379     std::uint64_t valueAsInteger() const noexcept
 380     {
 381         return bt_field_bit_array_get_value_as_integer(this->libObjPtr());
 382     }
 383
 384     bool bitValue(const std::uint64_t index) const noexcept
 385     {
 386         BT_ASSERT_DBG(index < this->cls().length());
 387         return static_cast<bool>(this->valueAsInteger() & (1ULL << index));
 388     }
 389 };
 390
 391 using BitArrayField = CommonBitArrayField<bt_field>;
 392 using ConstBitArrayField = CommonBitArrayField<const bt_field>;
 393
 394 namespace internal {
 395
 396 struct BitArrayFieldTypeDescr
 397 {
 398     using Const = ConstBitArrayField;
 399     using NonConst = BitArrayField;
 400 };
 401
 402 template <>
 403 struct TypeDescr<BitArrayField> : public BitArrayFieldTypeDescr
 404 {
 405 };
 406
 407 template <>
 408 struct TypeDescr<ConstBitArrayField> : public BitArrayFieldTypeDescr
 409 {
 410 };
 411
 412 } /* namespace internal */
 413
 414 template <typename LibObjT>
 415 class CommonUnsignedIntegerField : public CommonField<LibObjT>
 416 {
 417 private:
 418     using typename CommonField<LibObjT>::_ThisCommonField;
 419
 420 protected:
 421     using _ThisCommonUnsignedIntegerField = CommonUnsignedIntegerField<LibObjT>;
 422
 423 public:
 424     using typename CommonField<LibObjT>::LibObjPtr;
 425     using Value = std::uint64_t;
 426     using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
 427
 428     explicit CommonUnsignedIntegerField(const LibObjPtr libObjPtr) noexcept :
 429         _ThisCommonField {libObjPtr}
 430     {
 431         BT_ASSERT_DBG(this->isUnsignedInteger());
 432     }
 433
 434     template <typename OtherLibObjT>
 435     CommonUnsignedIntegerField(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept :
 436         _ThisCommonField {val}
 437     {
 438     }
 439
 440     template <typename OtherLibObjT>
 441     _ThisCommonUnsignedIntegerField
 442     operator=(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept
 443     {
 444         _ThisCommonField::operator=(val);
 445         return *this;
 446     }
 447
 448     CommonUnsignedIntegerField<const bt_field> asConst() const noexcept
 449     {
 450         return CommonUnsignedIntegerField<const bt_field> {*this};
 451     }
 452
 453     Class cls() const noexcept
 454     {
 455         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
 456     }
 457
 458     RawValueProxy<CommonUnsignedIntegerField> operator*() const noexcept
 459     {
 460         return RawValueProxy<CommonUnsignedIntegerField> {*this};
 461     }
 462
 463     void value(const Value val) const noexcept
 464     {
 465         static_assert(!std::is_const<LibObjT>::value,
 466                       "Not available with `bt2::ConstUnsignedIntegerField`.");
 467
 468         bt_field_integer_unsigned_set_value(this->libObjPtr(), val);
 469     }
 470
 471     Value value() const noexcept
 472     {
 473         return bt_field_integer_unsigned_get_value(this->libObjPtr());
 474     }
 475 };
 476
 477 using UnsignedIntegerField = CommonUnsignedIntegerField<bt_field>;
 478 using ConstUnsignedIntegerField = CommonUnsignedIntegerField<const bt_field>;
 479
 480 namespace internal {
 481
 482 struct UnsignedIntegerFieldTypeDescr
 483 {
 484     using Const = ConstUnsignedIntegerField;
 485     using NonConst = UnsignedIntegerField;
 486 };
 487
 488 template <>
 489 struct TypeDescr<UnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
 490 {
 491 };
 492
 493 template <>
 494 struct TypeDescr<ConstUnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
 495 {
 496 };
 497
 498 } /* namespace internal */
 499
 500 template <typename LibObjT>
 501 class CommonSignedIntegerField : public CommonField<LibObjT>
 502 {
 503 private:
 504     using typename CommonField<LibObjT>::_ThisCommonField;
 505
 506 protected:
 507     using _ThisCommonSignedIntegerField = CommonSignedIntegerField<LibObjT>;
 508
 509 public:
 510     using typename CommonField<LibObjT>::LibObjPtr;
 511     using Value = std::int64_t;
 512     using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
 513
 514     explicit CommonSignedIntegerField(const LibObjPtr libObjPtr) noexcept :
 515         _ThisCommonField {libObjPtr}
 516     {
 517         BT_ASSERT_DBG(this->isSignedInteger());
 518     }
 519
 520     template <typename OtherLibObjT>
 521     CommonSignedIntegerField(const CommonSignedIntegerField<OtherLibObjT> val) noexcept :
 522         _ThisCommonField {val}
 523     {
 524     }
 525
 526     template <typename OtherLibObjT>
 527     _ThisCommonSignedIntegerField
 528     operator=(const CommonSignedIntegerField<OtherLibObjT> val) noexcept
 529     {
 530         _ThisCommonField::operator=(val);
 531         return *this;
 532     }
 533
 534     CommonSignedIntegerField<const bt_field> asConst() const noexcept
 535     {
 536         return CommonSignedIntegerField<const bt_field> {*this};
 537     }
 538
 539     Class cls() const noexcept
 540     {
 541         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
 542     }
 543
 544     RawValueProxy<CommonSignedIntegerField> operator*() const noexcept
 545     {
 546         return RawValueProxy<CommonSignedIntegerField> {*this};
 547     }
 548
 549     void value(const Value val) const noexcept
 550     {
 551         static_assert(!std::is_const<LibObjT>::value,
 552                       "Not available with `bt2::ConstSignedIntegerField`.");
 553
 554         bt_field_integer_signed_set_value(this->libObjPtr(), val);
 555     }
 556
 557     Value value() const noexcept
 558     {
 559         return bt_field_integer_signed_get_value(this->libObjPtr());
 560     }
 561 };
 562
 563 using SignedIntegerField = CommonSignedIntegerField<bt_field>;
 564 using ConstSignedIntegerField = CommonSignedIntegerField<const bt_field>;
 565
 566 namespace internal {
 567
 568 struct SignedIntegerFieldTypeDescr
 569 {
 570     using Const = ConstSignedIntegerField;
 571     using NonConst = SignedIntegerField;
 572 };
 573
 574 template <>
 575 struct TypeDescr<SignedIntegerField> : public SignedIntegerFieldTypeDescr
 576 {
 577 };
 578
 579 template <>
 580 struct TypeDescr<ConstSignedIntegerField> : public SignedIntegerFieldTypeDescr
 581 {
 582 };
 583
 584 } /* namespace internal */
 585
 586 class EnumerationFieldClassMappingLabels
 587 {
 588 public:
 589     explicit EnumerationFieldClassMappingLabels(
 590         const bt_field_class_enumeration_mapping_label_array labels, const std::uint64_t size) :
 591         _mLabels {labels},
 592         _mLen {size}
 593     {
 594     }
 595
 596     std::uint64_t length() const noexcept
 597     {
 598         return _mLen;
 599     }
 600
 601     bt2c::CStringView operator[](const std::uint64_t index) const noexcept
 602     {
 603         return _mLabels[index];
 604     }
 605
 606 private:
 607     bt_field_class_enumeration_mapping_label_array _mLabels;
 608     std::uint64_t _mLen;
 609 };
 610
 611 template <typename LibObjT>
 612 class CommonUnsignedEnumerationField final : public CommonUnsignedIntegerField<LibObjT>
 613 {
 614 private:
 615     using typename CommonUnsignedIntegerField<LibObjT>::_ThisCommonUnsignedIntegerField;
 616
 617 public:
 618     using typename CommonField<LibObjT>::LibObjPtr;
 619
 620     using Class = internal::DepType<LibObjT, UnsignedEnumerationFieldClass,
 621                                     ConstUnsignedEnumerationFieldClass>;
 622
 623     explicit CommonUnsignedEnumerationField(const LibObjPtr libObjPtr) noexcept :
 624         _ThisCommonUnsignedIntegerField {libObjPtr}
 625     {
 626         BT_ASSERT_DBG(this->isUnsignedEnumeration());
 627     }
 628
 629     template <typename OtherLibObjT>
 630     CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
 631         :
 632         _ThisCommonUnsignedIntegerField {val}
 633     {
 634     }
 635
 636     template <typename OtherLibObjT>
 637     CommonUnsignedEnumerationField<LibObjT>
 638     operator=(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
 639     {
 640         _ThisCommonUnsignedIntegerField::operator=(val);
 641         return *this;
 642     }
 643
 644     CommonUnsignedEnumerationField<const bt_field> asConst() const noexcept
 645     {
 646         return CommonUnsignedEnumerationField<const bt_field> {*this};
 647     }
 648
 649     Class cls() const noexcept
 650     {
 651         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
 652     }
 653
 654     EnumerationFieldClassMappingLabels labels() const
 655     {
 656         bt_field_class_enumeration_mapping_label_array labelArray;
 657         std::uint64_t count;
 658         const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->libObjPtr(),
 659                                                                              &labelArray, &count);
 660
 661         if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
 662             throw MemoryError {};
 663         }
 664
 665         return EnumerationFieldClassMappingLabels {labelArray, count};
 666     }
 667 };
 668
 669 using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
 670 using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
 671
 672 namespace internal {
 673
 674 struct UnsignedEnumerationFieldTypeDescr
 675 {
 676     using Const = ConstUnsignedEnumerationField;
 677     using NonConst = UnsignedEnumerationField;
 678 };
 679
 680 template <>
 681 struct TypeDescr<UnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
 682 {
 683 };
 684
 685 template <>
 686 struct TypeDescr<ConstUnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
 687 {
 688 };
 689
 690 } /* namespace internal */
 691
 692 template <typename LibObjT>
 693 class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
 694 {
 695 private:
 696     using typename CommonSignedIntegerField<LibObjT>::_ThisCommonSignedIntegerField;
 697
 698 public:
 699     using typename CommonField<LibObjT>::LibObjPtr;
 700
 701     using Class =
 702         internal::DepType<LibObjT, SignedEnumerationFieldClass, ConstSignedEnumerationFieldClass>;
 703
 704     explicit CommonSignedEnumerationField(const LibObjPtr libObjPtr) noexcept :
 705         _ThisCommonSignedIntegerField {libObjPtr}
 706     {
 707         BT_ASSERT_DBG(this->isSignedEnumeration());
 708     }
 709
 710     template <typename OtherLibObjT>
 711     CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept :
 712         _ThisCommonSignedIntegerField {val}
 713     {
 714     }
 715
 716     template <typename OtherLibObjT>
 717     CommonSignedEnumerationField<LibObjT>
 718     operator=(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept
 719     {
 720         _ThisCommonSignedIntegerField::operator=(val);
 721         return *this;
 722     }
 723
 724     CommonSignedEnumerationField<const bt_field> asConst() const noexcept
 725     {
 726         return CommonSignedEnumerationField<const bt_field> {*this};
 727     }
 728
 729     Class cls() const noexcept
 730     {
 731         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
 732     }
 733
 734     EnumerationFieldClassMappingLabels labels() const
 735     {
 736         bt_field_class_enumeration_mapping_label_array labelArray;
 737         std::uint64_t count;
 738         const auto status =
 739             bt_field_enumeration_signed_get_mapping_labels(this->libObjPtr(), &labelArray, &count);
 740
 741         if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
 742             throw MemoryError {};
 743         }
 744
 745         return EnumerationFieldClassMappingLabels {labelArray, count};
 746     }
 747 };
 748
 749 using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
 750 using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
 751
 752 namespace internal {
 753
 754 struct SignedEnumerationFieldTypeDescr
 755 {
 756     using Const = ConstSignedEnumerationField;
 757     using NonConst = SignedEnumerationField;
 758 };
 759
 760 template <>
 761 struct TypeDescr<SignedEnumerationField> : public SignedEnumerationFieldTypeDescr
 762 {
 763 };
 764
 765 template <>
 766 struct TypeDescr<ConstSignedEnumerationField> : public SignedEnumerationFieldTypeDescr
 767 {
 768 };
 769
 770 } /* namespace internal */
 771
 772 template <typename LibObjT>
 773 class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
 774 {
 775 private:
 776     using typename CommonField<LibObjT>::_ThisCommonField;
 777
 778 public:
 779     using typename CommonField<LibObjT>::LibObjPtr;
 780     using Value = float;
 781
 782     explicit CommonSinglePrecisionRealField(const LibObjPtr libObjPtr) noexcept :
 783         _ThisCommonField {libObjPtr}
 784     {
 785         BT_ASSERT_DBG(this->isSinglePrecisionReal());
 786     }
 787
 788     template <typename OtherLibObjT>
 789     CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
 790         :
 791         _ThisCommonField {val}
 792     {
 793     }
 794
 795     template <typename OtherLibObjT>
 796     CommonSinglePrecisionRealField<LibObjT>
 797     operator=(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
 798     {
 799         _ThisCommonField::operator=(val);
 800         return *this;
 801     }
 802
 803     CommonSinglePrecisionRealField<const bt_field> asConst() const noexcept
 804     {
 805         return CommonSinglePrecisionRealField<const bt_field> {*this};
 806     }
 807
 808     RawValueProxy<CommonSinglePrecisionRealField> operator*() const noexcept
 809     {
 810         return RawValueProxy<CommonSinglePrecisionRealField> {*this};
 811     }
 812
 813     void value(const Value val) const noexcept
 814     {
 815         static_assert(!std::is_const<LibObjT>::value,
 816                       "Not available with `bt2::ConstSinglePrecisionRealField`.");
 817
 818         bt_field_real_single_precision_set_value(this->libObjPtr(), val);
 819     }
 820
 821     Value value() const noexcept
 822     {
 823         return bt_field_real_single_precision_get_value(this->libObjPtr());
 824     }
 825 };
 826
 827 using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
 828 using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
 829
 830 namespace internal {
 831
 832 struct SinglePrecisionRealFieldTypeDescr
 833 {
 834     using Const = ConstSinglePrecisionRealField;
 835     using NonConst = SinglePrecisionRealField;
 836 };
 837
 838 template <>
 839 struct TypeDescr<SinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
 840 {
 841 };
 842
 843 template <>
 844 struct TypeDescr<ConstSinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
 845 {
 846 };
 847
 848 } /* namespace internal */
 849
 850 template <typename LibObjT>
 851 class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
 852 {
 853 private:
 854     using typename CommonField<LibObjT>::_ThisCommonField;
 855
 856 public:
 857     using typename CommonField<LibObjT>::LibObjPtr;
 858     using Value = double;
 859
 860     explicit CommonDoublePrecisionRealField(const LibObjPtr libObjPtr) noexcept :
 861         _ThisCommonField {libObjPtr}
 862     {
 863         BT_ASSERT_DBG(this->isDoublePrecisionReal());
 864     }
 865
 866     template <typename OtherLibObjT>
 867     CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
 868         :
 869         _ThisCommonField {val}
 870     {
 871     }
 872
 873     template <typename OtherLibObjT>
 874     CommonDoublePrecisionRealField<LibObjT>
 875     operator=(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
 876     {
 877         _ThisCommonField::operator=(val);
 878         return *this;
 879     }
 880
 881     CommonDoublePrecisionRealField<const bt_field> asConst() const noexcept
 882     {
 883         return CommonDoublePrecisionRealField<const bt_field> {*this};
 884     }
 885
 886     RawValueProxy<CommonDoublePrecisionRealField> operator*() const noexcept
 887     {
 888         return RawValueProxy<CommonDoublePrecisionRealField> {*this};
 889     }
 890
 891     void value(const Value val) const noexcept
 892     {
 893         static_assert(!std::is_const<LibObjT>::value,
 894                       "Not available with `bt2::ConstDoublePrecisionRealField`.");
 895
 896         bt_field_real_double_precision_set_value(this->libObjPtr(), val);
 897     }
 898
 899     Value value() const noexcept
 900     {
 901         return bt_field_real_double_precision_get_value(this->libObjPtr());
 902     }
 903 };
 904
 905 using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
 906 using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
 907
 908 namespace internal {
 909
 910 struct DoublePrecisionRealFieldTypeDescr
 911 {
 912     using Const = ConstDoublePrecisionRealField;
 913     using NonConst = DoublePrecisionRealField;
 914 };
 915
 916 template <>
 917 struct TypeDescr<DoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
 918 {
 919 };
 920
 921 template <>
 922 struct TypeDescr<ConstDoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
 923 {
 924 };
 925
 926 } /* namespace internal */
 927
 928 template <typename LibObjT>
 929 class CommonStringField final : public CommonField<LibObjT>
 930 {
 931 private:
 932     using typename CommonField<LibObjT>::_ThisCommonField;
 933
 934 public:
 935     using typename CommonField<LibObjT>::LibObjPtr;
 936     using Value = bt2c::CStringView;
 937
 938     explicit CommonStringField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
 939     {
 940         BT_ASSERT_DBG(this->isString());
 941     }
 942
 943     template <typename OtherLibObjT>
 944     CommonStringField(const CommonStringField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
 945     {
 946     }
 947
 948     template <typename OtherLibObjT>
 949     CommonStringField<LibObjT> operator=(const CommonStringField<OtherLibObjT> val) noexcept
 950     {
 951         _ThisCommonField::operator=(val);
 952         return *this;
 953     }
 954
 955     CommonStringField<const bt_field> asConst() const noexcept
 956     {
 957         return CommonStringField<const bt_field> {*this};
 958     }
 959
 960     RawStringValueProxy<CommonStringField> operator*() const noexcept
 961     {
 962         return RawStringValueProxy<CommonStringField> {*this};
 963     }
 964
 965     void value(const Value& val) const
 966     {
 967         static_assert(!std::is_const<LibObjT>::value,
 968                       "Not available with `bt2::ConstStringField`.");
 969
 970         const auto status = bt_field_string_set_value(this->libObjPtr(), *val);
 971
 972         if (status == BT_FIELD_STRING_SET_VALUE_STATUS_MEMORY_ERROR) {
 973             throw MemoryError {};
 974         }
 975     }
 976
 977     void value(const char * const val) const
 978     {
 979         this->value(bt2c::CStringView {val});
 980     }
 981
 982     void value(const std::string& val) const
 983     {
 984         this->value(bt2c::CStringView {val.data()});
 985     }
 986
 987     void append(const char * const begin, const std::uint64_t len) const
 988     {
 989         static_assert(!std::is_const<LibObjT>::value,
 990                       "Not available with `bt2::ConstStringField`.");
 991
 992         const auto status = bt_field_string_append_with_length(this->libObjPtr(), begin, len);
 993
 994         if (status == BT_FIELD_STRING_APPEND_STATUS_MEMORY_ERROR) {
 995             throw MemoryError {};
 996         }
 997     }
 998
 999     void append(const char * const val) const
1000     {
1001         this->append(val, std::strlen(val));
1002     }
1003
1004     void append(const std::string& val) const
1005     {
1006         this->append(val.data(), val.size());
1007     }
1008
1009     void clear() const noexcept
1010     {
1011         static_assert(!std::is_const<LibObjT>::value,
1012                       "Not available with `bt2::ConstStringField`.");
1013
1014         bt_field_string_clear(this->libObjPtr());
1015     }
1016
1017     Value value() const noexcept
1018     {
1019         return bt_field_string_get_value(this->libObjPtr());
1020     }
1021 };
1022
1023 using StringField = CommonStringField<bt_field>;
1024 using ConstStringField = CommonStringField<const bt_field>;
1025
1026 namespace internal {
1027
1028 struct StringFieldTypeDescr
1029 {
1030     using Const = ConstStringField;
1031     using NonConst = StringField;
1032 };
1033
1034 template <>
1035 struct TypeDescr<StringField> : public StringFieldTypeDescr
1036 {
1037 };
1038
1039 template <>
1040 struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
1041 {
1042 };
1043
1044 template <typename LibObjT>
1045 struct CommonStructureFieldSpec;
1046
1047 /* Functions specific to mutable structure fields */
1048 template <>
1049 struct CommonStructureFieldSpec<bt_field> final
1050 {
1051     static bt_field *memberFieldByIndex(bt_field * const libObjPtr,
1052                                         const std::uint64_t index) noexcept
1053     {
1054         return bt_field_structure_borrow_member_field_by_index(libObjPtr, index);
1055     }
1056
1057     static bt_field *memberFieldByName(bt_field * const libObjPtr, const char * const name) noexcept
1058     {
1059         return bt_field_structure_borrow_member_field_by_name(libObjPtr, name);
1060     }
1061 };
1062
1063 /* Functions specific to constant structure fields */
1064 template <>
1065 struct CommonStructureFieldSpec<const bt_field> final
1066 {
1067     static const bt_field *memberFieldByIndex(const bt_field * const libObjPtr,
1068                                               const std::uint64_t index) noexcept
1069     {
1070         return bt_field_structure_borrow_member_field_by_index_const(libObjPtr, index);
1071     }
1072
1073     static const bt_field *memberFieldByName(const bt_field * const libObjPtr,
1074                                              const char * const name) noexcept
1075     {
1076         return bt_field_structure_borrow_member_field_by_name_const(libObjPtr, name);
1077     }
1078 };
1079
1080 } /* namespace internal */
1081
1082 template <typename LibObjT>
1083 class CommonStructureField final : public CommonField<LibObjT>
1084 {
1085 private:
1086     using typename CommonField<LibObjT>::_ThisCommonField;
1087     using _Spec = internal::CommonStructureFieldSpec<LibObjT>;
1088
1089 public:
1090     using typename CommonField<LibObjT>::LibObjPtr;
1091     using Class = internal::DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
1092
1093     explicit CommonStructureField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1094     {
1095         BT_ASSERT_DBG(this->isStructure());
1096     }
1097
1098     template <typename OtherLibObjT>
1099     CommonStructureField(const CommonStructureField<OtherLibObjT> val) noexcept :
1100         _ThisCommonField {val}
1101     {
1102     }
1103
1104     template <typename OtherLibObjT>
1105     CommonStructureField<LibObjT> operator=(const CommonStructureField<OtherLibObjT> val) noexcept
1106     {
1107         _ThisCommonField::operator=(val);
1108         return *this;
1109     }
1110
1111     CommonStructureField<const bt_field> asConst() const noexcept
1112     {
1113         return CommonStructureField<const bt_field> {*this};
1114     }
1115
1116     Class cls() const noexcept
1117     {
1118         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1119     }
1120
1121     std::uint64_t length() const noexcept
1122     {
1123         return this->cls().length();
1124     }
1125
1126     CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1127     {
1128         return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
1129     }
1130
1131     OptionalBorrowedObject<CommonField<LibObjT>> operator[](const char * const name) const noexcept
1132     {
1133         return _Spec::memberFieldByName(this->libObjPtr(), name);
1134     }
1135
1136     OptionalBorrowedObject<CommonField<LibObjT>> operator[](const std::string& name) const noexcept
1137     {
1138         return (*this)[name.data()];
1139     }
1140 };
1141
1142 using StructureField = CommonStructureField<bt_field>;
1143 using ConstStructureField = CommonStructureField<const bt_field>;
1144
1145 namespace internal {
1146
1147 struct StructureFieldTypeDescr
1148 {
1149     using Const = ConstStructureField;
1150     using NonConst = StructureField;
1151 };
1152
1153 template <>
1154 struct TypeDescr<StructureField> : public StructureFieldTypeDescr
1155 {
1156 };
1157
1158 template <>
1159 struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
1160 {
1161 };
1162
1163 template <typename LibObjT>
1164 struct CommonArrayFieldSpec;
1165
1166 /* Functions specific to mutable array fields */
1167 template <>
1168 struct CommonArrayFieldSpec<bt_field> final
1169 {
1170     static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
1171                                          const std::uint64_t index) noexcept
1172     {
1173         return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
1174     }
1175 };
1176
1177 /* Functions specific to constant array fields */
1178 template <>
1179 struct CommonArrayFieldSpec<const bt_field> final
1180 {
1181     static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
1182                                                const std::uint64_t index) noexcept
1183     {
1184         return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
1185     }
1186 };
1187
1188 } /* namespace internal */
1189
1190 template <typename LibObjT>
1191 class CommonArrayField : public CommonField<LibObjT>
1192 {
1193 private:
1194     using typename CommonField<LibObjT>::_ThisCommonField;
1195     using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
1196
1197 protected:
1198     using _ThisCommonArrayField = CommonArrayField<LibObjT>;
1199
1200 public:
1201     using typename CommonField<LibObjT>::LibObjPtr;
1202     using Class = internal::DepType<LibObjT, ArrayFieldClass, ConstArrayFieldClass>;
1203
1204     explicit CommonArrayField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1205     {
1206         BT_ASSERT_DBG(this->isArray());
1207     }
1208
1209     template <typename OtherLibObjT>
1210     CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1211     {
1212     }
1213
1214     template <typename OtherLibObjT>
1215     _ThisCommonArrayField operator=(const CommonArrayField<OtherLibObjT> val) noexcept
1216     {
1217         _ThisCommonField::operator=(val);
1218         return *this;
1219     }
1220
1221     CommonArrayField<const bt_field> asConst() const noexcept
1222     {
1223         return CommonArrayField<const bt_field> {*this};
1224     }
1225
1226     Class cls() const noexcept
1227     {
1228         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1229     }
1230
1231     std::uint64_t length() const noexcept
1232     {
1233         return bt_field_array_get_length(this->libObjPtr());
1234     }
1235
1236     CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1237     {
1238         return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
1239     }
1240 };
1241
1242 using ArrayField = CommonArrayField<bt_field>;
1243 using ConstArrayField = CommonArrayField<const bt_field>;
1244
1245 namespace internal {
1246
1247 struct ArrayFieldTypeDescr
1248 {
1249     using Const = ConstArrayField;
1250     using NonConst = ArrayField;
1251 };
1252
1253 template <>
1254 struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
1255 {
1256 };
1257
1258 template <>
1259 struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
1260 {
1261 };
1262
1263 } /* namespace internal */
1264
1265 template <typename LibObjT>
1266 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1267 {
1268 private:
1269     using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1270
1271 public:
1272     using typename CommonField<LibObjT>::LibObjPtr;
1273
1274     explicit CommonDynamicArrayField(const LibObjPtr libObjPtr) noexcept :
1275         _ThisCommonArrayField {libObjPtr}
1276     {
1277         BT_ASSERT_DBG(this->isDynamicArray());
1278     }
1279
1280     template <typename OtherLibObjT>
1281     CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT> val) noexcept :
1282         _ThisCommonArrayField {val}
1283     {
1284     }
1285
1286     template <typename OtherLibObjT>
1287     CommonDynamicArrayField<LibObjT>
1288     operator=(const CommonDynamicArrayField<OtherLibObjT> val) noexcept
1289     {
1290         _ThisCommonArrayField::operator=(val);
1291         return *this;
1292     }
1293
1294     CommonDynamicArrayField<const bt_field> asConst() const noexcept
1295     {
1296         return CommonDynamicArrayField<const bt_field> {*this};
1297     }
1298
1299     std::uint64_t length() const noexcept
1300     {
1301         return _ThisCommonArrayField::length();
1302     }
1303
1304     void length(const std::uint64_t length) const
1305     {
1306         static_assert(!std::is_const<LibObjT>::value,
1307                       "Not available with `bt2::ConstDynamicArrayField`.");
1308
1309         const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
1310
1311         if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
1312             throw MemoryError {};
1313         }
1314     }
1315 };
1316
1317 using DynamicArrayField = CommonDynamicArrayField<bt_field>;
1318 using ConstDynamicArrayField = CommonDynamicArrayField<const bt_field>;
1319
1320 namespace internal {
1321
1322 struct DynamicArrayFieldTypeDescr
1323 {
1324     using Const = ConstDynamicArrayField;
1325     using NonConst = DynamicArrayField;
1326 };
1327
1328 template <>
1329 struct TypeDescr<DynamicArrayField> : public DynamicArrayFieldTypeDescr
1330 {
1331 };
1332
1333 template <>
1334 struct TypeDescr<ConstDynamicArrayField> : public DynamicArrayFieldTypeDescr
1335 {
1336 };
1337
1338 template <typename LibObjT>
1339 struct CommonOptionFieldSpec;
1340
1341 /* Functions specific to mutable option fields */
1342 template <>
1343 struct CommonOptionFieldSpec<bt_field> final
1344 {
1345     static bt_field *field(bt_field * const libObjPtr) noexcept
1346     {
1347         return bt_field_option_borrow_field(libObjPtr);
1348     }
1349 };
1350
1351 /* Functions specific to constant option fields */
1352 template <>
1353 struct CommonOptionFieldSpec<const bt_field> final
1354 {
1355     static const bt_field *field(const bt_field * const libObjPtr) noexcept
1356     {
1357         return bt_field_option_borrow_field_const(libObjPtr);
1358     }
1359 };
1360
1361 } /* namespace internal */
1362
1363 template <typename LibObjT>
1364 class CommonOptionField : public CommonField<LibObjT>
1365 {
1366 private:
1367     using typename CommonField<LibObjT>::_ThisCommonField;
1368     using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1369
1370 public:
1371     using typename CommonField<LibObjT>::LibObjPtr;
1372     using Class = internal::DepType<LibObjT, OptionFieldClass, ConstOptionFieldClass>;
1373
1374     explicit CommonOptionField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1375     {
1376         BT_ASSERT_DBG(this->isOption());
1377     }
1378
1379     template <typename OtherLibObjT>
1380     CommonOptionField(const CommonOptionField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1381     {
1382     }
1383
1384     template <typename OtherLibObjT>
1385     CommonOptionField<LibObjT> operator=(const CommonOptionField<OtherLibObjT> val) noexcept
1386     {
1387         _ThisCommonField::operator=(val);
1388         return *this;
1389     }
1390
1391     CommonOptionField<const bt_field> asConst() const noexcept
1392     {
1393         return CommonOptionField<const bt_field> {*this};
1394     }
1395
1396     Class cls() const noexcept
1397     {
1398         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1399     }
1400
1401     void hasField(const bool hasField) const noexcept
1402     {
1403         static_assert(!std::is_const<LibObjT>::value,
1404                       "Not available with `bt2::ConstOptionField`.");
1405
1406         bt_field_option_set_has_field(this->libObjPtr(), static_cast<bt_bool>(hasField));
1407     }
1408
1409     bool hasField() const noexcept
1410     {
1411         return this->field().has_value();
1412     }
1413
1414     OptionalBorrowedObject<CommonField<LibObjT>> field() const noexcept
1415     {
1416         return _Spec::field(this->libObjPtr());
1417     }
1418 };
1419
1420 using OptionField = CommonOptionField<bt_field>;
1421 using ConstOptionField = CommonOptionField<const bt_field>;
1422
1423 namespace internal {
1424
1425 struct OptionFieldTypeDescr
1426 {
1427     using Const = ConstOptionField;
1428     using NonConst = OptionField;
1429 };
1430
1431 template <>
1432 struct TypeDescr<OptionField> : public OptionFieldTypeDescr
1433 {
1434 };
1435
1436 template <>
1437 struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
1438 {
1439 };
1440
1441 template <typename LibObjT>
1442 struct CommonVariantFieldSpec;
1443
1444 /* Functions specific to mutable variant fields */
1445 template <>
1446 struct CommonVariantFieldSpec<bt_field> final
1447 {
1448     static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1449     {
1450         return bt_field_variant_borrow_selected_option_field(libObjPtr);
1451     }
1452 };
1453
1454 /* Functions specific to constant variant fields */
1455 template <>
1456 struct CommonVariantFieldSpec<const bt_field> final
1457 {
1458     static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1459     {
1460         return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1461     }
1462 };
1463
1464 } /* namespace internal */
1465
1466 template <typename LibObjT>
1467 class CommonVariantField : public CommonField<LibObjT>
1468 {
1469 private:
1470     using typename CommonField<LibObjT>::_ThisCommonField;
1471     using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1472
1473 public:
1474     using typename CommonField<LibObjT>::LibObjPtr;
1475     using Class = internal::DepType<LibObjT, VariantFieldClass, ConstVariantFieldClass>;
1476
1477     explicit CommonVariantField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1478     {
1479         BT_ASSERT_DBG(this->isVariant());
1480     }
1481
1482     template <typename OtherLibObjT>
1483     CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1484     {
1485     }
1486
1487     template <typename OtherLibObjT>
1488     CommonVariantField<LibObjT> operator=(const CommonVariantField<OtherLibObjT> val) noexcept
1489     {
1490         _ThisCommonField::operator=(val);
1491         return *this;
1492     }
1493
1494     CommonVariantField<const bt_field> asConst() const noexcept
1495     {
1496         return CommonVariantField<const bt_field> {*this};
1497     }
1498
1499     Class cls() const noexcept
1500     {
1501         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1502     }
1503
1504     void selectOption(const std::uint64_t index) const noexcept
1505     {
1506         static_assert(!std::is_const<LibObjT>::value,
1507                       "Not available with `bt2::ConstVariantField`.");
1508
1509         static_cast<void>(bt_field_variant_select_option_by_index(this->libObjPtr(), index));
1510     }
1511
1512     CommonField<LibObjT> selectedOptionField() const noexcept
1513     {
1514         return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
1515     }
1516
1517     std::uint64_t selectedOptionIndex() const noexcept
1518     {
1519         return bt_field_variant_get_selected_option_index(this->libObjPtr());
1520     }
1521 };
1522
1523 using VariantField = CommonVariantField<bt_field>;
1524 using ConstVariantField = CommonVariantField<const bt_field>;
1525
1526 namespace internal {
1527
1528 struct VariantFieldTypeDescr
1529 {
1530     using Const = ConstVariantField;
1531     using NonConst = VariantField;
1532 };
1533
1534 template <>
1535 struct TypeDescr<VariantField> : public VariantFieldTypeDescr
1536 {
1537 };
1538
1539 template <>
1540 struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
1541 {
1542 };
1543
1544 } /* namespace internal */
1545
1546 template <typename LibObjT>
1547 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1548 {
1549     BT_ASSERT_DBG(this->isBool());
1550     return CommonBoolField<LibObjT> {this->libObjPtr()};
1551 }
1552
1553 template <typename LibObjT>
1554 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1555 {
1556     BT_ASSERT_DBG(this->isBitArray());
1557     return CommonBitArrayField<LibObjT> {this->libObjPtr()};
1558 }
1559
1560 template <typename LibObjT>
1561 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1562 {
1563     BT_ASSERT_DBG(this->isUnsignedInteger());
1564     return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
1565 }
1566
1567 template <typename LibObjT>
1568 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1569 {
1570     BT_ASSERT_DBG(this->isSignedInteger());
1571     return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
1572 }
1573
1574 template <typename LibObjT>
1575 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1576 {
1577     BT_ASSERT_DBG(this->isUnsignedEnumeration());
1578     return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
1579 }
1580
1581 template <typename LibObjT>
1582 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1583 {
1584     BT_ASSERT_DBG(this->isSignedEnumeration());
1585     return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
1586 }
1587
1588 template <typename LibObjT>
1589 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1590 {
1591     BT_ASSERT_DBG(this->isSinglePrecisionReal());
1592     return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
1593 }
1594
1595 template <typename LibObjT>
1596 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1597 {
1598     BT_ASSERT_DBG(this->isDoublePrecisionReal());
1599     return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
1600 }
1601
1602 template <typename LibObjT>
1603 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1604 {
1605     BT_ASSERT_DBG(this->isString());
1606     return CommonStringField<LibObjT> {this->libObjPtr()};
1607 }
1608
1609 template <typename LibObjT>
1610 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1611 {
1612     BT_ASSERT_DBG(this->isStructure());
1613     return CommonStructureField<LibObjT> {this->libObjPtr()};
1614 }
1615
1616 template <typename LibObjT>
1617 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1618 {
1619     BT_ASSERT_DBG(this->isArray());
1620     return CommonArrayField<LibObjT> {this->libObjPtr()};
1621 }
1622
1623 template <typename LibObjT>
1624 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1625 {
1626     BT_ASSERT_DBG(this->isDynamicArray());
1627     return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
1628 }
1629
1630 template <typename LibObjT>
1631 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1632 {
1633     BT_ASSERT_DBG(this->isOption());
1634     return CommonOptionField<LibObjT> {this->libObjPtr()};
1635 }
1636
1637 template <typename LibObjT>
1638 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1639 {
1640     BT_ASSERT_DBG(this->isVariant());
1641     return CommonVariantField<LibObjT> {this->libObjPtr()};
1642 }
1643
1644 } /* namespace bt2 */
1645
1646 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_HPP */