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     RawValueProxy<CommonStringField> operator*() const noexcept
 961     {
 962         return RawValueProxy<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 append(const bt2c::CStringView begin, const std::uint64_t len) const
 978     {
 979         static_assert(!std::is_const<LibObjT>::value,
 980                       "Not available with `bt2::ConstStringField`.");
 981
 982         const auto status = bt_field_string_append_with_length(this->libObjPtr(), begin, len);
 983
 984         if (status == BT_FIELD_STRING_APPEND_STATUS_MEMORY_ERROR) {
 985             throw MemoryError {};
 986         }
 987     }
 988
 989     void append(const bt2c::CStringView val) const
 990     {
 991         this->append(val, std::strlen(val));
 992     }
 993
 994     void append(const std::string& val) const
 995     {
 996         this->append(val.data(), val.size());
 997     }
 998
 999     void clear() const noexcept
1000     {
1001         static_assert(!std::is_const<LibObjT>::value,
1002                       "Not available with `bt2::ConstStringField`.");
1003
1004         bt_field_string_clear(this->libObjPtr());
1005     }
1006
1007     Value value() const noexcept
1008     {
1009         return bt_field_string_get_value(this->libObjPtr());
1010     }
1011 };
1012
1013 using StringField = CommonStringField<bt_field>;
1014 using ConstStringField = CommonStringField<const bt_field>;
1015
1016 namespace internal {
1017
1018 struct StringFieldTypeDescr
1019 {
1020     using Const = ConstStringField;
1021     using NonConst = StringField;
1022 };
1023
1024 template <>
1025 struct TypeDescr<StringField> : public StringFieldTypeDescr
1026 {
1027 };
1028
1029 template <>
1030 struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
1031 {
1032 };
1033
1034 template <typename LibObjT>
1035 struct CommonStructureFieldSpec;
1036
1037 /* Functions specific to mutable structure fields */
1038 template <>
1039 struct CommonStructureFieldSpec<bt_field> final
1040 {
1041     static bt_field *memberFieldByIndex(bt_field * const libObjPtr,
1042                                         const std::uint64_t index) noexcept
1043     {
1044         return bt_field_structure_borrow_member_field_by_index(libObjPtr, index);
1045     }
1046
1047     static bt_field *memberFieldByName(bt_field * const libObjPtr, const char * const name) noexcept
1048     {
1049         return bt_field_structure_borrow_member_field_by_name(libObjPtr, name);
1050     }
1051 };
1052
1053 /* Functions specific to constant structure fields */
1054 template <>
1055 struct CommonStructureFieldSpec<const bt_field> final
1056 {
1057     static const bt_field *memberFieldByIndex(const bt_field * const libObjPtr,
1058                                               const std::uint64_t index) noexcept
1059     {
1060         return bt_field_structure_borrow_member_field_by_index_const(libObjPtr, index);
1061     }
1062
1063     static const bt_field *memberFieldByName(const bt_field * const libObjPtr,
1064                                              const char * const name) noexcept
1065     {
1066         return bt_field_structure_borrow_member_field_by_name_const(libObjPtr, name);
1067     }
1068 };
1069
1070 } /* namespace internal */
1071
1072 template <typename LibObjT>
1073 class CommonStructureField final : public CommonField<LibObjT>
1074 {
1075 private:
1076     using typename CommonField<LibObjT>::_ThisCommonField;
1077     using _Spec = internal::CommonStructureFieldSpec<LibObjT>;
1078
1079 public:
1080     using typename CommonField<LibObjT>::LibObjPtr;
1081     using Class = internal::DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
1082
1083     explicit CommonStructureField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1084     {
1085         BT_ASSERT_DBG(this->isStructure());
1086     }
1087
1088     template <typename OtherLibObjT>
1089     CommonStructureField(const CommonStructureField<OtherLibObjT> val) noexcept :
1090         _ThisCommonField {val}
1091     {
1092     }
1093
1094     template <typename OtherLibObjT>
1095     CommonStructureField<LibObjT> operator=(const CommonStructureField<OtherLibObjT> val) noexcept
1096     {
1097         _ThisCommonField::operator=(val);
1098         return *this;
1099     }
1100
1101     CommonStructureField<const bt_field> asConst() const noexcept
1102     {
1103         return CommonStructureField<const bt_field> {*this};
1104     }
1105
1106     Class cls() const noexcept
1107     {
1108         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1109     }
1110
1111     std::uint64_t length() const noexcept
1112     {
1113         return this->cls().length();
1114     }
1115
1116     CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1117     {
1118         return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
1119     }
1120
1121     OptionalBorrowedObject<CommonField<LibObjT>>
1122     operator[](const bt2c::CStringView name) const noexcept
1123     {
1124         return _Spec::memberFieldByName(this->libObjPtr(), name);
1125     }
1126 };
1127
1128 using StructureField = CommonStructureField<bt_field>;
1129 using ConstStructureField = CommonStructureField<const bt_field>;
1130
1131 namespace internal {
1132
1133 struct StructureFieldTypeDescr
1134 {
1135     using Const = ConstStructureField;
1136     using NonConst = StructureField;
1137 };
1138
1139 template <>
1140 struct TypeDescr<StructureField> : public StructureFieldTypeDescr
1141 {
1142 };
1143
1144 template <>
1145 struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
1146 {
1147 };
1148
1149 template <typename LibObjT>
1150 struct CommonArrayFieldSpec;
1151
1152 /* Functions specific to mutable array fields */
1153 template <>
1154 struct CommonArrayFieldSpec<bt_field> final
1155 {
1156     static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
1157                                          const std::uint64_t index) noexcept
1158     {
1159         return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
1160     }
1161 };
1162
1163 /* Functions specific to constant array fields */
1164 template <>
1165 struct CommonArrayFieldSpec<const bt_field> final
1166 {
1167     static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
1168                                                const std::uint64_t index) noexcept
1169     {
1170         return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
1171     }
1172 };
1173
1174 } /* namespace internal */
1175
1176 template <typename LibObjT>
1177 class CommonArrayField : public CommonField<LibObjT>
1178 {
1179 private:
1180     using typename CommonField<LibObjT>::_ThisCommonField;
1181     using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
1182
1183 protected:
1184     using _ThisCommonArrayField = CommonArrayField<LibObjT>;
1185
1186 public:
1187     using typename CommonField<LibObjT>::LibObjPtr;
1188     using Class = internal::DepType<LibObjT, ArrayFieldClass, ConstArrayFieldClass>;
1189
1190     explicit CommonArrayField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1191     {
1192         BT_ASSERT_DBG(this->isArray());
1193     }
1194
1195     template <typename OtherLibObjT>
1196     CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1197     {
1198     }
1199
1200     template <typename OtherLibObjT>
1201     _ThisCommonArrayField operator=(const CommonArrayField<OtherLibObjT> val) noexcept
1202     {
1203         _ThisCommonField::operator=(val);
1204         return *this;
1205     }
1206
1207     CommonArrayField<const bt_field> asConst() const noexcept
1208     {
1209         return CommonArrayField<const bt_field> {*this};
1210     }
1211
1212     Class cls() const noexcept
1213     {
1214         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1215     }
1216
1217     std::uint64_t length() const noexcept
1218     {
1219         return bt_field_array_get_length(this->libObjPtr());
1220     }
1221
1222     CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1223     {
1224         return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
1225     }
1226 };
1227
1228 using ArrayField = CommonArrayField<bt_field>;
1229 using ConstArrayField = CommonArrayField<const bt_field>;
1230
1231 namespace internal {
1232
1233 struct ArrayFieldTypeDescr
1234 {
1235     using Const = ConstArrayField;
1236     using NonConst = ArrayField;
1237 };
1238
1239 template <>
1240 struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
1241 {
1242 };
1243
1244 template <>
1245 struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
1246 {
1247 };
1248
1249 } /* namespace internal */
1250
1251 template <typename LibObjT>
1252 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1253 {
1254 private:
1255     using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1256
1257 public:
1258     using typename CommonField<LibObjT>::LibObjPtr;
1259
1260     explicit CommonDynamicArrayField(const LibObjPtr libObjPtr) noexcept :
1261         _ThisCommonArrayField {libObjPtr}
1262     {
1263         BT_ASSERT_DBG(this->isDynamicArray());
1264     }
1265
1266     template <typename OtherLibObjT>
1267     CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT> val) noexcept :
1268         _ThisCommonArrayField {val}
1269     {
1270     }
1271
1272     template <typename OtherLibObjT>
1273     CommonDynamicArrayField<LibObjT>
1274     operator=(const CommonDynamicArrayField<OtherLibObjT> val) noexcept
1275     {
1276         _ThisCommonArrayField::operator=(val);
1277         return *this;
1278     }
1279
1280     CommonDynamicArrayField<const bt_field> asConst() const noexcept
1281     {
1282         return CommonDynamicArrayField<const bt_field> {*this};
1283     }
1284
1285     std::uint64_t length() const noexcept
1286     {
1287         return _ThisCommonArrayField::length();
1288     }
1289
1290     void length(const std::uint64_t length) const
1291     {
1292         static_assert(!std::is_const<LibObjT>::value,
1293                       "Not available with `bt2::ConstDynamicArrayField`.");
1294
1295         const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
1296
1297         if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
1298             throw MemoryError {};
1299         }
1300     }
1301 };
1302
1303 using DynamicArrayField = CommonDynamicArrayField<bt_field>;
1304 using ConstDynamicArrayField = CommonDynamicArrayField<const bt_field>;
1305
1306 namespace internal {
1307
1308 struct DynamicArrayFieldTypeDescr
1309 {
1310     using Const = ConstDynamicArrayField;
1311     using NonConst = DynamicArrayField;
1312 };
1313
1314 template <>
1315 struct TypeDescr<DynamicArrayField> : public DynamicArrayFieldTypeDescr
1316 {
1317 };
1318
1319 template <>
1320 struct TypeDescr<ConstDynamicArrayField> : public DynamicArrayFieldTypeDescr
1321 {
1322 };
1323
1324 template <typename LibObjT>
1325 struct CommonOptionFieldSpec;
1326
1327 /* Functions specific to mutable option fields */
1328 template <>
1329 struct CommonOptionFieldSpec<bt_field> final
1330 {
1331     static bt_field *field(bt_field * const libObjPtr) noexcept
1332     {
1333         return bt_field_option_borrow_field(libObjPtr);
1334     }
1335 };
1336
1337 /* Functions specific to constant option fields */
1338 template <>
1339 struct CommonOptionFieldSpec<const bt_field> final
1340 {
1341     static const bt_field *field(const bt_field * const libObjPtr) noexcept
1342     {
1343         return bt_field_option_borrow_field_const(libObjPtr);
1344     }
1345 };
1346
1347 } /* namespace internal */
1348
1349 template <typename LibObjT>
1350 class CommonOptionField : public CommonField<LibObjT>
1351 {
1352 private:
1353     using typename CommonField<LibObjT>::_ThisCommonField;
1354     using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1355
1356 public:
1357     using typename CommonField<LibObjT>::LibObjPtr;
1358     using Class = internal::DepType<LibObjT, OptionFieldClass, ConstOptionFieldClass>;
1359
1360     explicit CommonOptionField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1361     {
1362         BT_ASSERT_DBG(this->isOption());
1363     }
1364
1365     template <typename OtherLibObjT>
1366     CommonOptionField(const CommonOptionField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1367     {
1368     }
1369
1370     template <typename OtherLibObjT>
1371     CommonOptionField<LibObjT> operator=(const CommonOptionField<OtherLibObjT> val) noexcept
1372     {
1373         _ThisCommonField::operator=(val);
1374         return *this;
1375     }
1376
1377     CommonOptionField<const bt_field> asConst() const noexcept
1378     {
1379         return CommonOptionField<const bt_field> {*this};
1380     }
1381
1382     Class cls() const noexcept
1383     {
1384         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1385     }
1386
1387     void hasField(const bool hasField) const noexcept
1388     {
1389         static_assert(!std::is_const<LibObjT>::value,
1390                       "Not available with `bt2::ConstOptionField`.");
1391
1392         bt_field_option_set_has_field(this->libObjPtr(), static_cast<bt_bool>(hasField));
1393     }
1394
1395     bool hasField() const noexcept
1396     {
1397         return this->field().has_value();
1398     }
1399
1400     OptionalBorrowedObject<CommonField<LibObjT>> field() const noexcept
1401     {
1402         return _Spec::field(this->libObjPtr());
1403     }
1404 };
1405
1406 using OptionField = CommonOptionField<bt_field>;
1407 using ConstOptionField = CommonOptionField<const bt_field>;
1408
1409 namespace internal {
1410
1411 struct OptionFieldTypeDescr
1412 {
1413     using Const = ConstOptionField;
1414     using NonConst = OptionField;
1415 };
1416
1417 template <>
1418 struct TypeDescr<OptionField> : public OptionFieldTypeDescr
1419 {
1420 };
1421
1422 template <>
1423 struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
1424 {
1425 };
1426
1427 template <typename LibObjT>
1428 struct CommonVariantFieldSpec;
1429
1430 /* Functions specific to mutable variant fields */
1431 template <>
1432 struct CommonVariantFieldSpec<bt_field> final
1433 {
1434     static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1435     {
1436         return bt_field_variant_borrow_selected_option_field(libObjPtr);
1437     }
1438 };
1439
1440 /* Functions specific to constant variant fields */
1441 template <>
1442 struct CommonVariantFieldSpec<const bt_field> final
1443 {
1444     static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1445     {
1446         return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1447     }
1448 };
1449
1450 } /* namespace internal */
1451
1452 template <typename LibObjT>
1453 class CommonVariantField : public CommonField<LibObjT>
1454 {
1455 private:
1456     using typename CommonField<LibObjT>::_ThisCommonField;
1457     using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1458
1459 public:
1460     using typename CommonField<LibObjT>::LibObjPtr;
1461     using Class = internal::DepType<LibObjT, VariantFieldClass, ConstVariantFieldClass>;
1462
1463     explicit CommonVariantField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1464     {
1465         BT_ASSERT_DBG(this->isVariant());
1466     }
1467
1468     template <typename OtherLibObjT>
1469     CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1470     {
1471     }
1472
1473     template <typename OtherLibObjT>
1474     CommonVariantField<LibObjT> operator=(const CommonVariantField<OtherLibObjT> val) noexcept
1475     {
1476         _ThisCommonField::operator=(val);
1477         return *this;
1478     }
1479
1480     CommonVariantField<const bt_field> asConst() const noexcept
1481     {
1482         return CommonVariantField<const bt_field> {*this};
1483     }
1484
1485     Class cls() const noexcept
1486     {
1487         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1488     }
1489
1490     void selectOption(const std::uint64_t index) const noexcept
1491     {
1492         static_assert(!std::is_const<LibObjT>::value,
1493                       "Not available with `bt2::ConstVariantField`.");
1494
1495         static_cast<void>(bt_field_variant_select_option_by_index(this->libObjPtr(), index));
1496     }
1497
1498     CommonField<LibObjT> selectedOptionField() const noexcept
1499     {
1500         return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
1501     }
1502
1503     std::uint64_t selectedOptionIndex() const noexcept
1504     {
1505         return bt_field_variant_get_selected_option_index(this->libObjPtr());
1506     }
1507 };
1508
1509 using VariantField = CommonVariantField<bt_field>;
1510 using ConstVariantField = CommonVariantField<const bt_field>;
1511
1512 namespace internal {
1513
1514 struct VariantFieldTypeDescr
1515 {
1516     using Const = ConstVariantField;
1517     using NonConst = VariantField;
1518 };
1519
1520 template <>
1521 struct TypeDescr<VariantField> : public VariantFieldTypeDescr
1522 {
1523 };
1524
1525 template <>
1526 struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
1527 {
1528 };
1529
1530 } /* namespace internal */
1531
1532 template <typename LibObjT>
1533 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1534 {
1535     BT_ASSERT_DBG(this->isBool());
1536     return CommonBoolField<LibObjT> {this->libObjPtr()};
1537 }
1538
1539 template <typename LibObjT>
1540 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1541 {
1542     BT_ASSERT_DBG(this->isBitArray());
1543     return CommonBitArrayField<LibObjT> {this->libObjPtr()};
1544 }
1545
1546 template <typename LibObjT>
1547 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1548 {
1549     BT_ASSERT_DBG(this->isUnsignedInteger());
1550     return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
1551 }
1552
1553 template <typename LibObjT>
1554 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1555 {
1556     BT_ASSERT_DBG(this->isSignedInteger());
1557     return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
1558 }
1559
1560 template <typename LibObjT>
1561 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1562 {
1563     BT_ASSERT_DBG(this->isUnsignedEnumeration());
1564     return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
1565 }
1566
1567 template <typename LibObjT>
1568 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1569 {
1570     BT_ASSERT_DBG(this->isSignedEnumeration());
1571     return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
1572 }
1573
1574 template <typename LibObjT>
1575 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1576 {
1577     BT_ASSERT_DBG(this->isSinglePrecisionReal());
1578     return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
1579 }
1580
1581 template <typename LibObjT>
1582 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1583 {
1584     BT_ASSERT_DBG(this->isDoublePrecisionReal());
1585     return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
1586 }
1587
1588 template <typename LibObjT>
1589 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1590 {
1591     BT_ASSERT_DBG(this->isString());
1592     return CommonStringField<LibObjT> {this->libObjPtr()};
1593 }
1594
1595 template <typename LibObjT>
1596 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1597 {
1598     BT_ASSERT_DBG(this->isStructure());
1599     return CommonStructureField<LibObjT> {this->libObjPtr()};
1600 }
1601
1602 template <typename LibObjT>
1603 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1604 {
1605     BT_ASSERT_DBG(this->isArray());
1606     return CommonArrayField<LibObjT> {this->libObjPtr()};
1607 }
1608
1609 template <typename LibObjT>
1610 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1611 {
1612     BT_ASSERT_DBG(this->isDynamicArray());
1613     return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
1614 }
1615
1616 template <typename LibObjT>
1617 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1618 {
1619     BT_ASSERT_DBG(this->isOption());
1620     return CommonOptionField<LibObjT> {this->libObjPtr()};
1621 }
1622
1623 template <typename LibObjT>
1624 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1625 {
1626     BT_ASSERT_DBG(this->isVariant());
1627     return CommonVariantField<LibObjT> {this->libObjPtr()};
1628 }
1629
1630 } /* namespace bt2 */
1631
1632 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_HPP */