src/cpp-common/bt2/field.hpp

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