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/bt2s/optional.hpp"
  17
  18 #include "borrowed-object.hpp"
  19 #include "field-class.hpp"
  20 #include "internal/utils.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     bt2s::optional<CommonField<LibObjT>> operator[](const char * const name) const noexcept
1121     {
1122         const auto libObjPtr = _Spec::memberFieldByName(this->libObjPtr(), name);
1123
1124         if (libObjPtr) {
1125             return CommonField<LibObjT> {libObjPtr};
1126         }
1127
1128         return bt2s::nullopt;
1129     }
1130
1131     bt2s::optional<CommonField<LibObjT>> operator[](const std::string& name) const noexcept
1132     {
1133         return (*this)[name.data()];
1134     }
1135 };
1136
1137 using StructureField = CommonStructureField<bt_field>;
1138 using ConstStructureField = CommonStructureField<const bt_field>;
1139
1140 namespace internal {
1141
1142 struct StructureFieldTypeDescr
1143 {
1144     using Const = ConstStructureField;
1145     using NonConst = StructureField;
1146 };
1147
1148 template <>
1149 struct TypeDescr<StructureField> : public StructureFieldTypeDescr
1150 {
1151 };
1152
1153 template <>
1154 struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
1155 {
1156 };
1157
1158 template <typename LibObjT>
1159 struct CommonArrayFieldSpec;
1160
1161 /* Functions specific to mutable array fields */
1162 template <>
1163 struct CommonArrayFieldSpec<bt_field> final
1164 {
1165     static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
1166                                          const std::uint64_t index) noexcept
1167     {
1168         return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
1169     }
1170 };
1171
1172 /* Functions specific to constant array fields */
1173 template <>
1174 struct CommonArrayFieldSpec<const bt_field> final
1175 {
1176     static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
1177                                                const std::uint64_t index) noexcept
1178     {
1179         return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
1180     }
1181 };
1182
1183 } /* namespace internal */
1184
1185 template <typename LibObjT>
1186 class CommonArrayField : public CommonField<LibObjT>
1187 {
1188 private:
1189     using typename CommonField<LibObjT>::_ThisCommonField;
1190     using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
1191
1192 protected:
1193     using _ThisCommonArrayField = CommonArrayField<LibObjT>;
1194
1195 public:
1196     using typename CommonField<LibObjT>::LibObjPtr;
1197     using Class = internal::DepType<LibObjT, ArrayFieldClass, ConstArrayFieldClass>;
1198
1199     explicit CommonArrayField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1200     {
1201         BT_ASSERT_DBG(this->isArray());
1202     }
1203
1204     template <typename OtherLibObjT>
1205     CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1206     {
1207     }
1208
1209     template <typename OtherLibObjT>
1210     _ThisCommonArrayField operator=(const CommonArrayField<OtherLibObjT> val) noexcept
1211     {
1212         _ThisCommonField::operator=(val);
1213         return *this;
1214     }
1215
1216     CommonArrayField<const bt_field> asConst() const noexcept
1217     {
1218         return CommonArrayField<const bt_field> {*this};
1219     }
1220
1221     Class cls() const noexcept
1222     {
1223         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1224     }
1225
1226     std::uint64_t length() const noexcept
1227     {
1228         return bt_field_array_get_length(this->libObjPtr());
1229     }
1230
1231     CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1232     {
1233         return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
1234     }
1235 };
1236
1237 using ArrayField = CommonArrayField<bt_field>;
1238 using ConstArrayField = CommonArrayField<const bt_field>;
1239
1240 namespace internal {
1241
1242 struct ArrayFieldTypeDescr
1243 {
1244     using Const = ConstArrayField;
1245     using NonConst = ArrayField;
1246 };
1247
1248 template <>
1249 struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
1250 {
1251 };
1252
1253 template <>
1254 struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
1255 {
1256 };
1257
1258 } /* namespace internal */
1259
1260 template <typename LibObjT>
1261 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1262 {
1263 private:
1264     using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1265
1266 public:
1267     using typename CommonField<LibObjT>::LibObjPtr;
1268
1269     explicit CommonDynamicArrayField(const LibObjPtr libObjPtr) noexcept :
1270         _ThisCommonArrayField {libObjPtr}
1271     {
1272         BT_ASSERT_DBG(this->isDynamicArray());
1273     }
1274
1275     template <typename OtherLibObjT>
1276     CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT> val) noexcept :
1277         _ThisCommonArrayField {val}
1278     {
1279     }
1280
1281     template <typename OtherLibObjT>
1282     CommonDynamicArrayField<LibObjT>
1283     operator=(const CommonDynamicArrayField<OtherLibObjT> val) noexcept
1284     {
1285         _ThisCommonArrayField::operator=(val);
1286         return *this;
1287     }
1288
1289     CommonDynamicArrayField<const bt_field> asConst() const noexcept
1290     {
1291         return CommonDynamicArrayField<const bt_field> {*this};
1292     }
1293
1294     std::uint64_t length() const noexcept
1295     {
1296         return _ThisCommonArrayField::length();
1297     }
1298
1299     void length(const std::uint64_t length) const
1300     {
1301         static_assert(!std::is_const<LibObjT>::value,
1302                       "Not available with `bt2::ConstDynamicArrayField`.");
1303
1304         const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
1305
1306         if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
1307             throw MemoryError {};
1308         }
1309     }
1310 };
1311
1312 using DynamicArrayField = CommonDynamicArrayField<bt_field>;
1313 using ConstDynamicArrayField = CommonDynamicArrayField<const bt_field>;
1314
1315 namespace internal {
1316
1317 struct DynamicArrayFieldTypeDescr
1318 {
1319     using Const = ConstDynamicArrayField;
1320     using NonConst = DynamicArrayField;
1321 };
1322
1323 template <>
1324 struct TypeDescr<DynamicArrayField> : public DynamicArrayFieldTypeDescr
1325 {
1326 };
1327
1328 template <>
1329 struct TypeDescr<ConstDynamicArrayField> : public DynamicArrayFieldTypeDescr
1330 {
1331 };
1332
1333 template <typename LibObjT>
1334 struct CommonOptionFieldSpec;
1335
1336 /* Functions specific to mutable option fields */
1337 template <>
1338 struct CommonOptionFieldSpec<bt_field> final
1339 {
1340     static bt_field *field(bt_field * const libObjPtr) noexcept
1341     {
1342         return bt_field_option_borrow_field(libObjPtr);
1343     }
1344 };
1345
1346 /* Functions specific to constant option fields */
1347 template <>
1348 struct CommonOptionFieldSpec<const bt_field> final
1349 {
1350     static const bt_field *field(const bt_field * const libObjPtr) noexcept
1351     {
1352         return bt_field_option_borrow_field_const(libObjPtr);
1353     }
1354 };
1355
1356 } /* namespace internal */
1357
1358 template <typename LibObjT>
1359 class CommonOptionField : public CommonField<LibObjT>
1360 {
1361 private:
1362     using typename CommonField<LibObjT>::_ThisCommonField;
1363     using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1364
1365 public:
1366     using typename CommonField<LibObjT>::LibObjPtr;
1367     using Class = internal::DepType<LibObjT, OptionFieldClass, ConstOptionFieldClass>;
1368
1369     explicit CommonOptionField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1370     {
1371         BT_ASSERT_DBG(this->isOption());
1372     }
1373
1374     template <typename OtherLibObjT>
1375     CommonOptionField(const CommonOptionField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1376     {
1377     }
1378
1379     template <typename OtherLibObjT>
1380     CommonOptionField<LibObjT> operator=(const CommonOptionField<OtherLibObjT> val) noexcept
1381     {
1382         _ThisCommonField::operator=(val);
1383         return *this;
1384     }
1385
1386     CommonOptionField<const bt_field> asConst() const noexcept
1387     {
1388         return CommonOptionField<const bt_field> {*this};
1389     }
1390
1391     Class cls() const noexcept
1392     {
1393         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1394     }
1395
1396     void hasField(const bool hasField) const noexcept
1397     {
1398         static_assert(!std::is_const<LibObjT>::value,
1399                       "Not available with `bt2::ConstOptionField`.");
1400
1401         bt_field_option_set_has_field(this->libObjPtr(), static_cast<bt_bool>(hasField));
1402     }
1403
1404     bool hasField() const noexcept
1405     {
1406         return this->field().has_value();
1407     }
1408
1409     bt2s::optional<CommonField<LibObjT>> field() const noexcept
1410     {
1411         const auto libObjPtr = _Spec::field(this->libObjPtr());
1412
1413         if (libObjPtr) {
1414             return CommonField<LibObjT> {libObjPtr};
1415         }
1416
1417         return bt2s::nullopt;
1418     }
1419 };
1420
1421 using OptionField = CommonOptionField<bt_field>;
1422 using ConstOptionField = CommonOptionField<const bt_field>;
1423
1424 namespace internal {
1425
1426 struct OptionFieldTypeDescr
1427 {
1428     using Const = ConstOptionField;
1429     using NonConst = OptionField;
1430 };
1431
1432 template <>
1433 struct TypeDescr<OptionField> : public OptionFieldTypeDescr
1434 {
1435 };
1436
1437 template <>
1438 struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
1439 {
1440 };
1441
1442 template <typename LibObjT>
1443 struct CommonVariantFieldSpec;
1444
1445 /* Functions specific to mutable variant fields */
1446 template <>
1447 struct CommonVariantFieldSpec<bt_field> final
1448 {
1449     static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1450     {
1451         return bt_field_variant_borrow_selected_option_field(libObjPtr);
1452     }
1453 };
1454
1455 /* Functions specific to constant variant fields */
1456 template <>
1457 struct CommonVariantFieldSpec<const bt_field> final
1458 {
1459     static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1460     {
1461         return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1462     }
1463 };
1464
1465 } /* namespace internal */
1466
1467 template <typename LibObjT>
1468 class CommonVariantField : public CommonField<LibObjT>
1469 {
1470 private:
1471     using typename CommonField<LibObjT>::_ThisCommonField;
1472     using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1473
1474 public:
1475     using typename CommonField<LibObjT>::LibObjPtr;
1476     using Class = internal::DepType<LibObjT, VariantFieldClass, ConstVariantFieldClass>;
1477
1478     explicit CommonVariantField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1479     {
1480         BT_ASSERT_DBG(this->isVariant());
1481     }
1482
1483     template <typename OtherLibObjT>
1484     CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1485     {
1486     }
1487
1488     template <typename OtherLibObjT>
1489     CommonVariantField<LibObjT> operator=(const CommonVariantField<OtherLibObjT> val) noexcept
1490     {
1491         _ThisCommonField::operator=(val);
1492         return *this;
1493     }
1494
1495     CommonVariantField<const bt_field> asConst() const noexcept
1496     {
1497         return CommonVariantField<const bt_field> {*this};
1498     }
1499
1500     Class cls() const noexcept
1501     {
1502         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1503     }
1504
1505     void selectOption(const std::uint64_t index) const noexcept
1506     {
1507         static_assert(!std::is_const<LibObjT>::value,
1508                       "Not available with `bt2::ConstVariantField`.");
1509
1510         static_cast<void>(bt_field_variant_select_option_by_index(this->libObjPtr(), index));
1511     }
1512
1513     CommonField<LibObjT> selectedOptionField() const noexcept
1514     {
1515         return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
1516     }
1517
1518     std::uint64_t selectedOptionIndex() const noexcept
1519     {
1520         return bt_field_variant_get_selected_option_index(this->libObjPtr());
1521     }
1522 };
1523
1524 using VariantField = CommonVariantField<bt_field>;
1525 using ConstVariantField = CommonVariantField<const bt_field>;
1526
1527 namespace internal {
1528
1529 struct VariantFieldTypeDescr
1530 {
1531     using Const = ConstVariantField;
1532     using NonConst = VariantField;
1533 };
1534
1535 template <>
1536 struct TypeDescr<VariantField> : public VariantFieldTypeDescr
1537 {
1538 };
1539
1540 template <>
1541 struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
1542 {
1543 };
1544
1545 } /* namespace internal */
1546
1547 template <typename LibObjT>
1548 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1549 {
1550     BT_ASSERT_DBG(this->isBool());
1551     return CommonBoolField<LibObjT> {this->libObjPtr()};
1552 }
1553
1554 template <typename LibObjT>
1555 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1556 {
1557     BT_ASSERT_DBG(this->isBitArray());
1558     return CommonBitArrayField<LibObjT> {this->libObjPtr()};
1559 }
1560
1561 template <typename LibObjT>
1562 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1563 {
1564     BT_ASSERT_DBG(this->isUnsignedInteger());
1565     return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
1566 }
1567
1568 template <typename LibObjT>
1569 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1570 {
1571     BT_ASSERT_DBG(this->isSignedInteger());
1572     return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
1573 }
1574
1575 template <typename LibObjT>
1576 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1577 {
1578     BT_ASSERT_DBG(this->isUnsignedEnumeration());
1579     return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
1580 }
1581
1582 template <typename LibObjT>
1583 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1584 {
1585     BT_ASSERT_DBG(this->isSignedEnumeration());
1586     return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
1587 }
1588
1589 template <typename LibObjT>
1590 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1591 {
1592     BT_ASSERT_DBG(this->isSinglePrecisionReal());
1593     return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
1594 }
1595
1596 template <typename LibObjT>
1597 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1598 {
1599     BT_ASSERT_DBG(this->isDoublePrecisionReal());
1600     return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
1601 }
1602
1603 template <typename LibObjT>
1604 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1605 {
1606     BT_ASSERT_DBG(this->isString());
1607     return CommonStringField<LibObjT> {this->libObjPtr()};
1608 }
1609
1610 template <typename LibObjT>
1611 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1612 {
1613     BT_ASSERT_DBG(this->isStructure());
1614     return CommonStructureField<LibObjT> {this->libObjPtr()};
1615 }
1616
1617 template <typename LibObjT>
1618 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1619 {
1620     BT_ASSERT_DBG(this->isArray());
1621     return CommonArrayField<LibObjT> {this->libObjPtr()};
1622 }
1623
1624 template <typename LibObjT>
1625 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1626 {
1627     BT_ASSERT_DBG(this->isDynamicArray());
1628     return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
1629 }
1630
1631 template <typename LibObjT>
1632 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1633 {
1634     BT_ASSERT_DBG(this->isOption());
1635     return CommonOptionField<LibObjT> {this->libObjPtr()};
1636 }
1637
1638 template <typename LibObjT>
1639 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1640 {
1641     BT_ASSERT_DBG(this->isVariant());
1642     return CommonVariantField<LibObjT> {this->libObjPtr()};
1643 }
1644
1645 } /* namespace bt2 */
1646
1647 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_HPP */