src/cpp-common/bt2/field.hpp

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