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