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/optional.hpp"
  17 #include "cpp-common/string_view.hpp"
  18
  19 #include "borrowed-object.hpp"
  20 #include "field-class.hpp"
  21 #include "internal/utils.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 typename BorrowedObject<LibObjT>::_LibObjPtr;
 103     using _ThisCommonField = CommonField<LibObjT>;
 104
 105 public:
 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>::_LibObjPtr;
 259     using typename CommonField<LibObjT>::_ThisCommonField;
 260
 261 public:
 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>::_LibObjPtr;
 332     using typename CommonField<LibObjT>::_ThisCommonField;
 333
 334 public:
 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 typename CommonField<LibObjT>::_LibObjPtr;
 422     using _ThisCommonUnsignedIntegerField = CommonUnsignedIntegerField<LibObjT>;
 423
 424 public:
 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 typename CommonField<LibObjT>::_LibObjPtr;
 508     using _ThisCommonSignedIntegerField = CommonSignedIntegerField<LibObjT>;
 509
 510 public:
 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     EnumerationFieldClassMappingLabels(const EnumerationFieldClassMappingLabels&) noexcept =
 597         default;
 598
 599     EnumerationFieldClassMappingLabels&
 600     operator=(const EnumerationFieldClassMappingLabels&) noexcept = default;
 601
 602     std::uint64_t length() const noexcept
 603     {
 604         return _mLen;
 605     }
 606
 607     bpstd::string_view operator[](const std::uint64_t index) const noexcept
 608     {
 609         return _mLabels[index];
 610     }
 611
 612 private:
 613     bt_field_class_enumeration_mapping_label_array _mLabels;
 614     std::uint64_t _mLen;
 615 };
 616
 617 template <typename LibObjT>
 618 class CommonUnsignedEnumerationField final : public CommonUnsignedIntegerField<LibObjT>
 619 {
 620 private:
 621     using typename CommonUnsignedIntegerField<LibObjT>::_ThisCommonUnsignedIntegerField;
 622     using typename CommonField<LibObjT>::_LibObjPtr;
 623
 624 public:
 625     using Class = internal::DepType<LibObjT, UnsignedEnumerationFieldClass,
 626                                     ConstUnsignedEnumerationFieldClass>;
 627
 628     explicit CommonUnsignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
 629         _ThisCommonUnsignedIntegerField {libObjPtr}
 630     {
 631         BT_ASSERT_DBG(this->isUnsignedEnumeration());
 632     }
 633
 634     template <typename OtherLibObjT>
 635     CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
 636         :
 637         _ThisCommonUnsignedIntegerField {val}
 638     {
 639     }
 640
 641     template <typename OtherLibObjT>
 642     CommonUnsignedEnumerationField<LibObjT>&
 643     operator=(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
 644     {
 645         _ThisCommonUnsignedIntegerField::operator=(val);
 646         return *this;
 647     }
 648
 649     CommonUnsignedEnumerationField<const bt_field> asConst() const noexcept
 650     {
 651         return CommonUnsignedEnumerationField<const bt_field> {*this};
 652     }
 653
 654     Class cls() const noexcept
 655     {
 656         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
 657     }
 658
 659     EnumerationFieldClassMappingLabels labels() const
 660     {
 661         bt_field_class_enumeration_mapping_label_array labelArray;
 662         std::uint64_t count;
 663         const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->libObjPtr(),
 664                                                                              &labelArray, &count);
 665
 666         if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
 667             throw MemoryError {};
 668         }
 669
 670         return EnumerationFieldClassMappingLabels {labelArray, count};
 671     }
 672 };
 673
 674 using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
 675 using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
 676
 677 namespace internal {
 678
 679 struct UnsignedEnumerationFieldTypeDescr
 680 {
 681     using Const = ConstUnsignedEnumerationField;
 682     using NonConst = UnsignedEnumerationField;
 683 };
 684
 685 template <>
 686 struct TypeDescr<UnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
 687 {
 688 };
 689
 690 template <>
 691 struct TypeDescr<ConstUnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
 692 {
 693 };
 694
 695 } /* namespace internal */
 696
 697 template <typename LibObjT>
 698 class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
 699 {
 700 private:
 701     using typename CommonSignedIntegerField<LibObjT>::_ThisCommonSignedIntegerField;
 702     using typename CommonField<LibObjT>::_LibObjPtr;
 703
 704 public:
 705     using Class =
 706         internal::DepType<LibObjT, SignedEnumerationFieldClass, ConstSignedEnumerationFieldClass>;
 707
 708     explicit CommonSignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
 709         _ThisCommonSignedIntegerField {libObjPtr}
 710     {
 711         BT_ASSERT_DBG(this->isSignedEnumeration());
 712     }
 713
 714     template <typename OtherLibObjT>
 715     CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept :
 716         _ThisCommonSignedIntegerField {val}
 717     {
 718     }
 719
 720     template <typename OtherLibObjT>
 721     CommonSignedEnumerationField<LibObjT>&
 722     operator=(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept
 723     {
 724         _ThisCommonSignedIntegerField::operator=(val);
 725         return *this;
 726     }
 727
 728     CommonSignedEnumerationField<const bt_field> asConst() const noexcept
 729     {
 730         return CommonSignedEnumerationField<const bt_field> {*this};
 731     }
 732
 733     Class cls() const noexcept
 734     {
 735         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
 736     }
 737
 738     EnumerationFieldClassMappingLabels labels() const
 739     {
 740         bt_field_class_enumeration_mapping_label_array labelArray;
 741         std::uint64_t count;
 742         const auto status =
 743             bt_field_enumeration_signed_get_mapping_labels(this->libObjPtr(), &labelArray, &count);
 744
 745         if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
 746             throw MemoryError {};
 747         }
 748
 749         return EnumerationFieldClassMappingLabels {labelArray, count};
 750     }
 751 };
 752
 753 using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
 754 using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
 755
 756 namespace internal {
 757
 758 struct SignedEnumerationFieldTypeDescr
 759 {
 760     using Const = ConstSignedEnumerationField;
 761     using NonConst = SignedEnumerationField;
 762 };
 763
 764 template <>
 765 struct TypeDescr<SignedEnumerationField> : public SignedEnumerationFieldTypeDescr
 766 {
 767 };
 768
 769 template <>
 770 struct TypeDescr<ConstSignedEnumerationField> : public SignedEnumerationFieldTypeDescr
 771 {
 772 };
 773
 774 } /* namespace internal */
 775
 776 template <typename LibObjT>
 777 class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
 778 {
 779 private:
 780     using typename CommonField<LibObjT>::_LibObjPtr;
 781     using typename CommonField<LibObjT>::_ThisCommonField;
 782
 783 public:
 784     using Value = float;
 785
 786     explicit CommonSinglePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
 787         _ThisCommonField {libObjPtr}
 788     {
 789         BT_ASSERT_DBG(this->isSinglePrecisionReal());
 790     }
 791
 792     template <typename OtherLibObjT>
 793     CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
 794         :
 795         _ThisCommonField {val}
 796     {
 797     }
 798
 799     template <typename OtherLibObjT>
 800     CommonSinglePrecisionRealField<LibObjT>&
 801     operator=(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
 802     {
 803         _ThisCommonField::operator=(val);
 804         return *this;
 805     }
 806
 807     CommonSinglePrecisionRealField<const bt_field> asConst() const noexcept
 808     {
 809         return CommonSinglePrecisionRealField<const bt_field> {*this};
 810     }
 811
 812     RawValueProxy<CommonSinglePrecisionRealField> operator*() const noexcept
 813     {
 814         return RawValueProxy<CommonSinglePrecisionRealField> {*this};
 815     }
 816
 817     void value(const Value val) const noexcept
 818     {
 819         static_assert(!std::is_const<LibObjT>::value,
 820                       "Not available with `bt2::ConstSinglePrecisionRealField`.");
 821
 822         bt_field_real_single_precision_set_value(this->libObjPtr(), val);
 823     }
 824
 825     Value value() const noexcept
 826     {
 827         return bt_field_real_single_precision_get_value(this->libObjPtr());
 828     }
 829 };
 830
 831 using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
 832 using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
 833
 834 namespace internal {
 835
 836 struct SinglePrecisionRealFieldTypeDescr
 837 {
 838     using Const = ConstSinglePrecisionRealField;
 839     using NonConst = SinglePrecisionRealField;
 840 };
 841
 842 template <>
 843 struct TypeDescr<SinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
 844 {
 845 };
 846
 847 template <>
 848 struct TypeDescr<ConstSinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
 849 {
 850 };
 851
 852 } /* namespace internal */
 853
 854 template <typename LibObjT>
 855 class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
 856 {
 857 private:
 858     using typename CommonField<LibObjT>::_LibObjPtr;
 859     using typename CommonField<LibObjT>::_ThisCommonField;
 860
 861 public:
 862     using Value = double;
 863
 864     explicit CommonDoublePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
 865         _ThisCommonField {libObjPtr}
 866     {
 867         BT_ASSERT_DBG(this->isDoublePrecisionReal());
 868     }
 869
 870     template <typename OtherLibObjT>
 871     CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
 872         :
 873         _ThisCommonField {val}
 874     {
 875     }
 876
 877     template <typename OtherLibObjT>
 878     CommonDoublePrecisionRealField<LibObjT>&
 879     operator=(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
 880     {
 881         _ThisCommonField::operator=(val);
 882         return *this;
 883     }
 884
 885     CommonDoublePrecisionRealField<const bt_field> asConst() const noexcept
 886     {
 887         return CommonDoublePrecisionRealField<const bt_field> {*this};
 888     }
 889
 890     RawValueProxy<CommonDoublePrecisionRealField> operator*() const noexcept
 891     {
 892         return RawValueProxy<CommonDoublePrecisionRealField> {*this};
 893     }
 894
 895     void value(const Value val) const noexcept
 896     {
 897         static_assert(!std::is_const<LibObjT>::value,
 898                       "Not available with `bt2::ConstDoublePrecisionRealField`.");
 899
 900         bt_field_real_double_precision_set_value(this->libObjPtr(), val);
 901     }
 902
 903     Value value() const noexcept
 904     {
 905         return bt_field_real_double_precision_get_value(this->libObjPtr());
 906     }
 907 };
 908
 909 using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
 910 using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
 911
 912 namespace internal {
 913
 914 struct DoublePrecisionRealFieldTypeDescr
 915 {
 916     using Const = ConstDoublePrecisionRealField;
 917     using NonConst = DoublePrecisionRealField;
 918 };
 919
 920 template <>
 921 struct TypeDescr<DoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
 922 {
 923 };
 924
 925 template <>
 926 struct TypeDescr<ConstDoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
 927 {
 928 };
 929
 930 } /* namespace internal */
 931
 932 template <typename LibObjT>
 933 class CommonStringField final : public CommonField<LibObjT>
 934 {
 935 private:
 936     using typename CommonField<LibObjT>::_LibObjPtr;
 937     using typename CommonField<LibObjT>::_ThisCommonField;
 938
 939 public:
 940     using Value = const char *;
 941
 942     explicit CommonStringField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
 943     {
 944         BT_ASSERT_DBG(this->isString());
 945     }
 946
 947     template <typename OtherLibObjT>
 948     CommonStringField(const CommonStringField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
 949     {
 950     }
 951
 952     template <typename OtherLibObjT>
 953     CommonStringField<LibObjT>& operator=(const CommonStringField<OtherLibObjT> val) noexcept
 954     {
 955         _ThisCommonField::operator=(val);
 956         return *this;
 957     }
 958
 959     CommonStringField<const bt_field> asConst() const noexcept
 960     {
 961         return CommonStringField<const bt_field> {*this};
 962     }
 963
 964     RawStringValueProxy<CommonStringField> operator*() const noexcept
 965     {
 966         return RawStringValueProxy<CommonStringField> {*this};
 967     }
 968
 969     void value(const char * const val) const
 970     {
 971         static_assert(!std::is_const<LibObjT>::value,
 972                       "Not available with `bt2::ConstStringField`.");
 973
 974         const auto status = bt_field_string_set_value(this->libObjPtr(), val);
 975
 976         if (status == BT_FIELD_STRING_SET_VALUE_STATUS_MEMORY_ERROR) {
 977             throw MemoryError {};
 978         }
 979     }
 980
 981     void value(const std::string& val) const
 982     {
 983         this->value(val.data());
 984     }
 985
 986     void append(const char * const begin, const std::uint64_t len) const
 987     {
 988         static_assert(!std::is_const<LibObjT>::value,
 989                       "Not available with `bt2::ConstStringField`.");
 990
 991         const auto status = bt_field_string_append_with_length(this->libObjPtr(), begin, len);
 992
 993         if (status == BT_FIELD_STRING_APPEND_STATUS_MEMORY_ERROR) {
 994             throw MemoryError {};
 995         }
 996     }
 997
 998     void append(const std::string& val) const
 999     {
1000         this->append(val.data(), val.size());
1001     }
1002
1003     void clear() const noexcept
1004     {
1005         static_assert(!std::is_const<LibObjT>::value,
1006                       "Not available with `bt2::ConstStringField`.");
1007
1008         bt_field_string_clear(this->libObjPtr());
1009     }
1010
1011     const char *value() const noexcept
1012     {
1013         return bt_field_string_get_value(this->libObjPtr());
1014     }
1015 };
1016
1017 using StringField = CommonStringField<bt_field>;
1018 using ConstStringField = CommonStringField<const bt_field>;
1019
1020 namespace internal {
1021
1022 struct StringFieldTypeDescr
1023 {
1024     using Const = ConstStringField;
1025     using NonConst = StringField;
1026 };
1027
1028 template <>
1029 struct TypeDescr<StringField> : public StringFieldTypeDescr
1030 {
1031 };
1032
1033 template <>
1034 struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
1035 {
1036 };
1037
1038 template <typename LibObjT>
1039 struct CommonStructureFieldSpec;
1040
1041 /* Functions specific to mutable structure fields */
1042 template <>
1043 struct CommonStructureFieldSpec<bt_field> final
1044 {
1045     static bt_field *memberFieldByIndex(bt_field * const libObjPtr,
1046                                         const std::uint64_t index) noexcept
1047     {
1048         return bt_field_structure_borrow_member_field_by_index(libObjPtr, index);
1049     }
1050
1051     static bt_field *memberFieldByName(bt_field * const libObjPtr, const char * const name) noexcept
1052     {
1053         return bt_field_structure_borrow_member_field_by_name(libObjPtr, name);
1054     }
1055 };
1056
1057 /* Functions specific to constant structure fields */
1058 template <>
1059 struct CommonStructureFieldSpec<const bt_field> final
1060 {
1061     static const bt_field *memberFieldByIndex(const bt_field * const libObjPtr,
1062                                               const std::uint64_t index) noexcept
1063     {
1064         return bt_field_structure_borrow_member_field_by_index_const(libObjPtr, index);
1065     }
1066
1067     static const bt_field *memberFieldByName(const bt_field * const libObjPtr,
1068                                              const char * const name) noexcept
1069     {
1070         return bt_field_structure_borrow_member_field_by_name_const(libObjPtr, name);
1071     }
1072 };
1073
1074 } /* namespace internal */
1075
1076 template <typename LibObjT>
1077 class CommonStructureField final : public CommonField<LibObjT>
1078 {
1079 private:
1080     using typename CommonField<LibObjT>::_LibObjPtr;
1081     using typename CommonField<LibObjT>::_ThisCommonField;
1082     using _Spec = internal::CommonStructureFieldSpec<LibObjT>;
1083
1084 public:
1085     using Class = internal::DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
1086
1087     explicit CommonStructureField(const _LibObjPtr libObjPtr) noexcept :
1088         _ThisCommonField {libObjPtr}
1089     {
1090         BT_ASSERT_DBG(this->isStructure());
1091     }
1092
1093     template <typename OtherLibObjT>
1094     CommonStructureField(const CommonStructureField<OtherLibObjT> val) noexcept :
1095         _ThisCommonField {val}
1096     {
1097     }
1098
1099     template <typename OtherLibObjT>
1100     CommonStructureField<LibObjT>& operator=(const CommonStructureField<OtherLibObjT> val) noexcept
1101     {
1102         _ThisCommonField::operator=(val);
1103         return *this;
1104     }
1105
1106     CommonStructureField<const bt_field> asConst() const noexcept
1107     {
1108         return CommonStructureField<const bt_field> {*this};
1109     }
1110
1111     Class cls() const noexcept
1112     {
1113         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1114     }
1115
1116     std::uint64_t length() const noexcept
1117     {
1118         return this->cls().length();
1119     }
1120
1121     CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1122     {
1123         return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
1124     }
1125
1126     nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) const noexcept
1127     {
1128         const auto libObjPtr = _Spec::memberFieldByName(this->libObjPtr(), name);
1129
1130         if (libObjPtr) {
1131             return CommonField<LibObjT> {libObjPtr};
1132         }
1133
1134         return nonstd::nullopt;
1135     }
1136
1137     nonstd::optional<CommonField<LibObjT>> operator[](const std::string& name) const noexcept
1138     {
1139         return (*this)[name.data()];
1140     }
1141 };
1142
1143 using StructureField = CommonStructureField<bt_field>;
1144 using ConstStructureField = CommonStructureField<const bt_field>;
1145
1146 namespace internal {
1147
1148 struct StructureFieldTypeDescr
1149 {
1150     using Const = ConstStructureField;
1151     using NonConst = StructureField;
1152 };
1153
1154 template <>
1155 struct TypeDescr<StructureField> : public StructureFieldTypeDescr
1156 {
1157 };
1158
1159 template <>
1160 struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
1161 {
1162 };
1163
1164 template <typename LibObjT>
1165 struct CommonArrayFieldSpec;
1166
1167 /* Functions specific to mutable array fields */
1168 template <>
1169 struct CommonArrayFieldSpec<bt_field> final
1170 {
1171     static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
1172                                          const std::uint64_t index) noexcept
1173     {
1174         return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
1175     }
1176 };
1177
1178 /* Functions specific to constant array fields */
1179 template <>
1180 struct CommonArrayFieldSpec<const bt_field> final
1181 {
1182     static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
1183                                                const std::uint64_t index) noexcept
1184     {
1185         return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
1186     }
1187 };
1188
1189 } /* namespace internal */
1190
1191 template <typename LibObjT>
1192 class CommonArrayField : public CommonField<LibObjT>
1193 {
1194 private:
1195     using typename CommonField<LibObjT>::_ThisCommonField;
1196     using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
1197
1198 protected:
1199     using typename CommonField<LibObjT>::_LibObjPtr;
1200     using _ThisCommonArrayField = CommonArrayField<LibObjT>;
1201
1202 public:
1203     using Class = internal::DepType<LibObjT, ArrayFieldClass, ConstArrayFieldClass>;
1204
1205     explicit CommonArrayField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1206     {
1207         BT_ASSERT_DBG(this->isArray());
1208     }
1209
1210     template <typename OtherLibObjT>
1211     CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1212     {
1213     }
1214
1215     template <typename OtherLibObjT>
1216     _ThisCommonArrayField& operator=(const CommonArrayField<OtherLibObjT> val) noexcept
1217     {
1218         _ThisCommonField::operator=(val);
1219         return *this;
1220     }
1221
1222     CommonArrayField<const bt_field> asConst() const noexcept
1223     {
1224         return CommonArrayField<const bt_field> {*this};
1225     }
1226
1227     Class cls() const noexcept
1228     {
1229         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1230     }
1231
1232     std::uint64_t length() const noexcept
1233     {
1234         return bt_field_array_get_length(this->libObjPtr());
1235     }
1236
1237     CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1238     {
1239         return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
1240     }
1241 };
1242
1243 using ArrayField = CommonArrayField<bt_field>;
1244 using ConstArrayField = CommonArrayField<const bt_field>;
1245
1246 namespace internal {
1247
1248 struct ArrayFieldTypeDescr
1249 {
1250     using Const = ConstArrayField;
1251     using NonConst = ArrayField;
1252 };
1253
1254 template <>
1255 struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
1256 {
1257 };
1258
1259 template <>
1260 struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
1261 {
1262 };
1263
1264 } /* namespace internal */
1265
1266 template <typename LibObjT>
1267 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1268 {
1269 private:
1270     using typename CommonField<LibObjT>::_LibObjPtr;
1271     using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1272
1273 public:
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>::_LibObjPtr;
1368     using typename CommonField<LibObjT>::_ThisCommonField;
1369     using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1370
1371 public:
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     nonstd::optional<CommonField<LibObjT>> field() const noexcept
1415     {
1416         const auto libObjPtr = _Spec::field(this->libObjPtr());
1417
1418         if (libObjPtr) {
1419             return CommonField<LibObjT> {libObjPtr};
1420         }
1421
1422         return nonstd::nullopt;
1423     }
1424 };
1425
1426 using OptionField = CommonOptionField<bt_field>;
1427 using ConstOptionField = CommonOptionField<const bt_field>;
1428
1429 namespace internal {
1430
1431 struct OptionFieldTypeDescr
1432 {
1433     using Const = ConstOptionField;
1434     using NonConst = OptionField;
1435 };
1436
1437 template <>
1438 struct TypeDescr<OptionField> : public OptionFieldTypeDescr
1439 {
1440 };
1441
1442 template <>
1443 struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
1444 {
1445 };
1446
1447 template <typename LibObjT>
1448 struct CommonVariantFieldSpec;
1449
1450 /* Functions specific to mutable variant fields */
1451 template <>
1452 struct CommonVariantFieldSpec<bt_field> final
1453 {
1454     static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1455     {
1456         return bt_field_variant_borrow_selected_option_field(libObjPtr);
1457     }
1458 };
1459
1460 /* Functions specific to constant variant fields */
1461 template <>
1462 struct CommonVariantFieldSpec<const bt_field> final
1463 {
1464     static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1465     {
1466         return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1467     }
1468 };
1469
1470 } /* namespace internal */
1471
1472 template <typename LibObjT>
1473 class CommonVariantField : public CommonField<LibObjT>
1474 {
1475 private:
1476     using typename CommonField<LibObjT>::_LibObjPtr;
1477     using typename CommonField<LibObjT>::_ThisCommonField;
1478     using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1479
1480 public:
1481     using Class = internal::DepType<LibObjT, VariantFieldClass, ConstVariantFieldClass>;
1482
1483     explicit CommonVariantField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1484     {
1485         BT_ASSERT_DBG(this->isVariant());
1486     }
1487
1488     template <typename OtherLibObjT>
1489     CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1490     {
1491     }
1492
1493     template <typename OtherLibObjT>
1494     CommonVariantField<LibObjT>& operator=(const CommonVariantField<OtherLibObjT> val) noexcept
1495     {
1496         _ThisCommonField::operator=(val);
1497         return *this;
1498     }
1499
1500     CommonVariantField<const bt_field> asConst() const noexcept
1501     {
1502         return CommonVariantField<const bt_field> {*this};
1503     }
1504
1505     Class cls() const noexcept
1506     {
1507         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1508     }
1509
1510     void selectOption(const std::uint64_t index) const noexcept
1511     {
1512         static_assert(!std::is_const<LibObjT>::value,
1513                       "Not available with `bt2::ConstVariantField`.");
1514
1515         static_cast<void>(bt_field_variant_select_option_by_index(this->libObjPtr(), index));
1516     }
1517
1518     CommonField<LibObjT> selectedOptionField() const noexcept
1519     {
1520         return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
1521     }
1522
1523     std::uint64_t selectedOptionIndex() const noexcept
1524     {
1525         return bt_field_variant_get_selected_option_index(this->libObjPtr());
1526     }
1527 };
1528
1529 using VariantField = CommonVariantField<bt_field>;
1530 using ConstVariantField = CommonVariantField<const bt_field>;
1531
1532 namespace internal {
1533
1534 struct VariantFieldTypeDescr
1535 {
1536     using Const = ConstVariantField;
1537     using NonConst = VariantField;
1538 };
1539
1540 template <>
1541 struct TypeDescr<VariantField> : public VariantFieldTypeDescr
1542 {
1543 };
1544
1545 template <>
1546 struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
1547 {
1548 };
1549
1550 } /* namespace internal */
1551
1552 template <typename LibObjT>
1553 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1554 {
1555     BT_ASSERT_DBG(this->isBool());
1556     return CommonBoolField<LibObjT> {this->libObjPtr()};
1557 }
1558
1559 template <typename LibObjT>
1560 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1561 {
1562     BT_ASSERT_DBG(this->isBitArray());
1563     return CommonBitArrayField<LibObjT> {this->libObjPtr()};
1564 }
1565
1566 template <typename LibObjT>
1567 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1568 {
1569     BT_ASSERT_DBG(this->isUnsignedInteger());
1570     return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
1571 }
1572
1573 template <typename LibObjT>
1574 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1575 {
1576     BT_ASSERT_DBG(this->isSignedInteger());
1577     return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
1578 }
1579
1580 template <typename LibObjT>
1581 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1582 {
1583     BT_ASSERT_DBG(this->isUnsignedEnumeration());
1584     return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
1585 }
1586
1587 template <typename LibObjT>
1588 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1589 {
1590     BT_ASSERT_DBG(this->isSignedEnumeration());
1591     return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
1592 }
1593
1594 template <typename LibObjT>
1595 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1596 {
1597     BT_ASSERT_DBG(this->isSinglePrecisionReal());
1598     return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
1599 }
1600
1601 template <typename LibObjT>
1602 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1603 {
1604     BT_ASSERT_DBG(this->isDoublePrecisionReal());
1605     return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
1606 }
1607
1608 template <typename LibObjT>
1609 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1610 {
1611     BT_ASSERT_DBG(this->isString());
1612     return CommonStringField<LibObjT> {this->libObjPtr()};
1613 }
1614
1615 template <typename LibObjT>
1616 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1617 {
1618     BT_ASSERT_DBG(this->isStructure());
1619     return CommonStructureField<LibObjT> {this->libObjPtr()};
1620 }
1621
1622 template <typename LibObjT>
1623 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1624 {
1625     BT_ASSERT_DBG(this->isArray());
1626     return CommonArrayField<LibObjT> {this->libObjPtr()};
1627 }
1628
1629 template <typename LibObjT>
1630 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1631 {
1632     BT_ASSERT_DBG(this->isDynamicArray());
1633     return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
1634 }
1635
1636 template <typename LibObjT>
1637 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1638 {
1639     BT_ASSERT_DBG(this->isOption());
1640     return CommonOptionField<LibObjT> {this->libObjPtr()};
1641 }
1642
1643 template <typename LibObjT>
1644 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1645 {
1646     BT_ASSERT_DBG(this->isVariant());
1647     return CommonVariantField<LibObjT> {this->libObjPtr()};
1648 }
1649
1650 } /* namespace bt2 */
1651
1652 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_HPP */