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