src/cpp-common/bt2/trace-ir.hpp

   1 /*
   2  * Copyright (c) 2020-2021 Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * SPDX-License-Identifier: MIT
   5  */
   6
   7 #ifndef BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
   9
  10 #include <cstdint>
  11 #include <type_traits>
  12
  13 #include <babeltrace2/babeltrace.h>
  14
  15 #include "cpp-common/bt2s/optional.hpp"
  16
  17 #include "borrowed-object.hpp"
  18 #include "clock-class.hpp"
  19 #include "field-class.hpp"
  20 #include "field.hpp"
  21 #include "internal/utils.hpp"
  22 #include "shared-object.hpp"
  23 #include "value.hpp"
  24
  25 namespace bt2 {
  26
  27 template <typename LibObjT>
  28 class CommonEvent;
  29
  30 template <typename LibObjT>
  31 class CommonPacket;
  32
  33 template <typename LibObjT>
  34 class CommonStream;
  35
  36 template <typename LibObjT>
  37 class CommonTrace;
  38
  39 template <typename LibObjT>
  40 class CommonEventClass;
  41
  42 template <typename LibObjT>
  43 class CommonStreamClass;
  44
  45 template <typename LibObjT>
  46 class CommonTraceClass;
  47
  48 namespace internal {
  49
  50 template <typename LibObjT>
  51 struct CommonEventSpec;
  52
  53 /* Functions specific to mutable events */
  54 template <>
  55 struct CommonEventSpec<bt_event> final
  56 {
  57     static bt_event_class *cls(bt_event * const libObjPtr) noexcept
  58     {
  59         return bt_event_borrow_class(libObjPtr);
  60     }
  61
  62     static bt_stream *stream(bt_event * const libObjPtr) noexcept
  63     {
  64         return bt_event_borrow_stream(libObjPtr);
  65     }
  66
  67     static bt_packet *packet(bt_event * const libObjPtr) noexcept
  68     {
  69         return bt_event_borrow_packet(libObjPtr);
  70     }
  71
  72     static bt_field *payloadField(bt_event * const libObjPtr) noexcept
  73     {
  74         return bt_event_borrow_payload_field(libObjPtr);
  75     }
  76
  77     static bt_field *specificContextField(bt_event * const libObjPtr) noexcept
  78     {
  79         return bt_event_borrow_specific_context_field(libObjPtr);
  80     }
  81
  82     static bt_field *commonContextField(bt_event * const libObjPtr) noexcept
  83     {
  84         return bt_event_borrow_common_context_field(libObjPtr);
  85     }
  86 };
  87
  88 /* Functions specific to constant events */
  89 template <>
  90 struct CommonEventSpec<const bt_event> final
  91 {
  92     static const bt_event_class *cls(const bt_event * const libObjPtr) noexcept
  93     {
  94         return bt_event_borrow_class_const(libObjPtr);
  95     }
  96
  97     static const bt_stream *stream(const bt_event * const libObjPtr) noexcept
  98     {
  99         return bt_event_borrow_stream_const(libObjPtr);
 100     }
 101
 102     static const bt_packet *packet(const bt_event * const libObjPtr) noexcept
 103     {
 104         return bt_event_borrow_packet_const(libObjPtr);
 105     }
 106
 107     static const bt_field *payloadField(const bt_event * const libObjPtr) noexcept
 108     {
 109         return bt_event_borrow_payload_field_const(libObjPtr);
 110     }
 111
 112     static const bt_field *specificContextField(const bt_event * const libObjPtr) noexcept
 113     {
 114         return bt_event_borrow_specific_context_field_const(libObjPtr);
 115     }
 116
 117     static const bt_field *commonContextField(const bt_event * const libObjPtr) noexcept
 118     {
 119         return bt_event_borrow_common_context_field_const(libObjPtr);
 120     }
 121 };
 122
 123 template <typename LibObjT>
 124 using DepStructField = DepType<LibObjT, StructureField, ConstStructureField>;
 125
 126 } /* namespace internal */
 127
 128 template <typename LibObjT>
 129 class CommonEvent final : public BorrowedObject<LibObjT>
 130 {
 131 private:
 132     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 133     using _Spec = internal::CommonEventSpec<LibObjT>;
 134     using _Packet = internal::DepPacket<LibObjT>;
 135     using _Stream = internal::DepStream<LibObjT>;
 136     using _StructureField = internal::DepStructField<LibObjT>;
 137
 138 public:
 139     using typename BorrowedObject<LibObjT>::LibObjPtr;
 140
 141     using Class = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
 142                                     CommonEventClass<const bt_event_class>>;
 143
 144     explicit CommonEvent(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 145     {
 146     }
 147
 148     template <typename OtherLibObjT>
 149     CommonEvent(const CommonEvent<OtherLibObjT> event) noexcept : _ThisBorrowedObject {event}
 150     {
 151     }
 152
 153     template <typename OtherLibObjT>
 154     CommonEvent<LibObjT> operator=(const CommonEvent<OtherLibObjT> event) noexcept
 155     {
 156         _ThisBorrowedObject::operator=(event);
 157         return *this;
 158     }
 159
 160     CommonEvent<const bt_event> asConst() const noexcept
 161     {
 162         return CommonEvent<const bt_event> {*this};
 163     }
 164
 165     Class cls() const noexcept;
 166     _Stream stream() const noexcept;
 167     bt2s::optional<_Packet> packet() const noexcept;
 168
 169     bt2s::optional<_StructureField> payloadField() const noexcept
 170     {
 171         const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
 172
 173         if (libObjPtr) {
 174             return _StructureField {libObjPtr};
 175         }
 176
 177         return bt2s::nullopt;
 178     }
 179
 180     bt2s::optional<_StructureField> specificContextField() const noexcept
 181     {
 182         const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
 183
 184         if (libObjPtr) {
 185             return _StructureField {libObjPtr};
 186         }
 187
 188         return bt2s::nullopt;
 189     }
 190
 191     bt2s::optional<_StructureField> commonContextField() const noexcept
 192     {
 193         const auto libObjPtr = _Spec::commonContextField(this->libObjPtr());
 194
 195         if (libObjPtr) {
 196             return _StructureField {libObjPtr};
 197         }
 198
 199         return bt2s::nullopt;
 200     }
 201 };
 202
 203 using Event = CommonEvent<bt_event>;
 204 using ConstEvent = CommonEvent<const bt_event>;
 205
 206 namespace internal {
 207
 208 struct EventTypeDescr
 209 {
 210     using Const = ConstEvent;
 211     using NonConst = Event;
 212 };
 213
 214 template <>
 215 struct TypeDescr<Event> : public EventTypeDescr
 216 {
 217 };
 218
 219 template <>
 220 struct TypeDescr<ConstEvent> : public EventTypeDescr
 221 {
 222 };
 223
 224 struct PacketRefFuncs final
 225 {
 226     static void get(const bt_packet * const libObjPtr) noexcept
 227     {
 228         bt_packet_get_ref(libObjPtr);
 229     }
 230
 231     static void put(const bt_packet * const libObjPtr) noexcept
 232     {
 233         bt_packet_put_ref(libObjPtr);
 234     }
 235 };
 236
 237 template <typename LibObjT>
 238 struct CommonPacketSpec;
 239
 240 /* Functions specific to mutable packets */
 241 template <>
 242 struct CommonPacketSpec<bt_packet> final
 243 {
 244     static bt_stream *stream(bt_packet * const libObjPtr) noexcept
 245     {
 246         return bt_packet_borrow_stream(libObjPtr);
 247     }
 248
 249     static bt_field *contextField(bt_packet * const libObjPtr) noexcept
 250     {
 251         return bt_packet_borrow_context_field(libObjPtr);
 252     }
 253 };
 254
 255 /* Functions specific to constant packets */
 256 template <>
 257 struct CommonPacketSpec<const bt_packet> final
 258 {
 259     static const bt_stream *stream(const bt_packet * const libObjPtr) noexcept
 260     {
 261         return bt_packet_borrow_stream_const(libObjPtr);
 262     }
 263
 264     static const bt_field *contextField(const bt_packet * const libObjPtr) noexcept
 265     {
 266         return bt_packet_borrow_context_field_const(libObjPtr);
 267     }
 268 };
 269
 270 } /* namespace internal */
 271
 272 template <typename LibObjT>
 273 class CommonPacket final : public BorrowedObject<LibObjT>
 274 {
 275 private:
 276     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 277     using _Spec = internal::CommonPacketSpec<LibObjT>;
 278     using _Stream = internal::DepStream<LibObjT>;
 279     using _StructureField = internal::DepStructField<LibObjT>;
 280
 281 public:
 282     using typename BorrowedObject<LibObjT>::LibObjPtr;
 283     using Shared = SharedObject<CommonPacket, LibObjT, internal::PacketRefFuncs>;
 284
 285     explicit CommonPacket(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 286     {
 287     }
 288
 289     template <typename OtherLibObjT>
 290     CommonPacket(const CommonPacket<OtherLibObjT> packet) noexcept : _ThisBorrowedObject {packet}
 291     {
 292     }
 293
 294     template <typename OtherLibObjT>
 295     CommonPacket operator=(const CommonPacket<OtherLibObjT> packet) noexcept
 296     {
 297         _ThisBorrowedObject::operator=(packet);
 298         return *this;
 299     }
 300
 301     CommonPacket<const bt_packet> asConst() const noexcept
 302     {
 303         return CommonPacket<const bt_packet> {*this};
 304     }
 305
 306     _Stream stream() const noexcept;
 307
 308     bt2s::optional<_StructureField> contextField() const noexcept
 309     {
 310         const auto libObjPtr = _Spec::contextField(this->libObjPtr());
 311
 312         if (libObjPtr) {
 313             return _StructureField {libObjPtr};
 314         }
 315
 316         return bt2s::nullopt;
 317     }
 318
 319     Shared shared() const noexcept
 320     {
 321         return Shared::createWithRef(*this);
 322     }
 323 };
 324
 325 using Packet = CommonPacket<bt_packet>;
 326 using ConstPacket = CommonPacket<const bt_packet>;
 327
 328 namespace internal {
 329
 330 struct PacketTypeDescr
 331 {
 332     using Const = ConstPacket;
 333     using NonConst = Packet;
 334 };
 335
 336 template <>
 337 struct TypeDescr<Packet> : public PacketTypeDescr
 338 {
 339 };
 340
 341 template <>
 342 struct TypeDescr<ConstPacket> : public PacketTypeDescr
 343 {
 344 };
 345
 346 } /* namespace internal */
 347
 348 template <typename LibObjT>
 349 bt2s::optional<typename CommonEvent<LibObjT>::_Packet> CommonEvent<LibObjT>::packet() const noexcept
 350 {
 351     const auto libObjPtr = _Spec::packet(this->libObjPtr());
 352
 353     if (libObjPtr) {
 354         return _Packet {libObjPtr};
 355     }
 356
 357     return bt2s::nullopt;
 358 }
 359
 360 namespace internal {
 361
 362 struct StreamRefFuncs final
 363 {
 364     static void get(const bt_stream * const libObjPtr) noexcept
 365     {
 366         bt_stream_get_ref(libObjPtr);
 367     }
 368
 369     static void put(const bt_stream * const libObjPtr) noexcept
 370     {
 371         bt_stream_put_ref(libObjPtr);
 372     }
 373 };
 374
 375 template <typename LibObjT>
 376 struct CommonStreamSpec;
 377
 378 /* Functions specific to mutable streams */
 379 template <>
 380 struct CommonStreamSpec<bt_stream> final
 381 {
 382     static bt_stream_class *cls(bt_stream * const libObjPtr) noexcept
 383     {
 384         return bt_stream_borrow_class(libObjPtr);
 385     }
 386
 387     static bt_trace *trace(bt_stream * const libObjPtr) noexcept
 388     {
 389         return bt_stream_borrow_trace(libObjPtr);
 390     }
 391
 392     static bt_value *userAttributes(bt_stream * const libObjPtr) noexcept
 393     {
 394         return bt_stream_borrow_user_attributes(libObjPtr);
 395     }
 396 };
 397
 398 /* Functions specific to constant streams */
 399 template <>
 400 struct CommonStreamSpec<const bt_stream> final
 401 {
 402     static const bt_stream_class *cls(const bt_stream * const libObjPtr) noexcept
 403     {
 404         return bt_stream_borrow_class_const(libObjPtr);
 405     }
 406
 407     static const bt_trace *trace(const bt_stream * const libObjPtr) noexcept
 408     {
 409         return bt_stream_borrow_trace_const(libObjPtr);
 410     }
 411
 412     static const bt_value *userAttributes(const bt_stream * const libObjPtr) noexcept
 413     {
 414         return bt_stream_borrow_user_attributes_const(libObjPtr);
 415     }
 416 };
 417
 418 } /* namespace internal */
 419
 420 template <typename LibObjT>
 421 class CommonStream final : public BorrowedObject<LibObjT>
 422 {
 423 private:
 424     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 425     using _Spec = internal::CommonStreamSpec<LibObjT>;
 426     using _Trace = internal::DepType<LibObjT, CommonTrace<bt_trace>, CommonTrace<const bt_trace>>;
 427
 428 public:
 429     using typename BorrowedObject<LibObjT>::LibObjPtr;
 430     using Shared = SharedObject<CommonStream, LibObjT, internal::StreamRefFuncs>;
 431     using UserAttributes = internal::DepUserAttrs<LibObjT>;
 432
 433     using Class = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
 434                                     CommonStreamClass<const bt_stream_class>>;
 435
 436     explicit CommonStream(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 437     {
 438     }
 439
 440     template <typename OtherLibObjT>
 441     CommonStream(const CommonStream<OtherLibObjT> stream) noexcept : _ThisBorrowedObject {stream}
 442     {
 443     }
 444
 445     template <typename OtherLibObjT>
 446     CommonStream operator=(const CommonStream<OtherLibObjT> stream) noexcept
 447     {
 448         _ThisBorrowedObject::operator=(stream);
 449         return *this;
 450     }
 451
 452     CommonStream<const bt_stream> asConst() const noexcept
 453     {
 454         return CommonStream<const bt_stream> {*this};
 455     }
 456
 457     Packet::Shared createPacket() const
 458     {
 459         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
 460
 461         const auto libObjPtr = bt_packet_create(this->libObjPtr());
 462
 463         internal::validateCreatedObjPtr(libObjPtr);
 464         return Packet::Shared::createWithoutRef(libObjPtr);
 465     }
 466
 467     Class cls() const noexcept;
 468     _Trace trace() const noexcept;
 469
 470     std::uint64_t id() const noexcept
 471     {
 472         return bt_stream_get_id(this->libObjPtr());
 473     }
 474
 475     void name(const char * const name) const
 476     {
 477         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
 478
 479         const auto status = bt_stream_set_name(this->libObjPtr(), name);
 480
 481         if (status == BT_STREAM_SET_NAME_STATUS_MEMORY_ERROR) {
 482             throw MemoryError {};
 483         }
 484     }
 485
 486     void name(const std::string& name) const
 487     {
 488         this->name(name.data());
 489     }
 490
 491     const char *name() const noexcept
 492     {
 493         return bt_stream_get_name(this->libObjPtr());
 494     }
 495
 496     template <typename LibValT>
 497     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
 498     {
 499         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
 500
 501         bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
 502     }
 503
 504     UserAttributes userAttributes() const noexcept
 505     {
 506         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
 507     }
 508
 509     Shared shared() const noexcept
 510     {
 511         return Shared::createWithRef(*this);
 512     }
 513 };
 514
 515 using Stream = CommonStream<bt_stream>;
 516 using ConstStream = CommonStream<const bt_stream>;
 517
 518 namespace internal {
 519
 520 struct StreamTypeDescr
 521 {
 522     using Const = ConstStream;
 523     using NonConst = Stream;
 524 };
 525
 526 template <>
 527 struct TypeDescr<Stream> : public StreamTypeDescr
 528 {
 529 };
 530
 531 template <>
 532 struct TypeDescr<ConstStream> : public StreamTypeDescr
 533 {
 534 };
 535
 536 } /* namespace internal */
 537
 538 template <typename LibObjT>
 539 typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() const noexcept
 540 {
 541     return _Stream {_Spec::stream(this->libObjPtr())};
 542 }
 543
 544 template <typename LibObjT>
 545 typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() const noexcept
 546 {
 547     return _Stream {_Spec::stream(this->libObjPtr())};
 548 }
 549
 550 namespace internal {
 551
 552 struct TraceRefFuncs final
 553 {
 554     static void get(const bt_trace * const libObjPtr) noexcept
 555     {
 556         bt_trace_get_ref(libObjPtr);
 557     }
 558
 559     static void put(const bt_trace * const libObjPtr) noexcept
 560     {
 561         bt_trace_put_ref(libObjPtr);
 562     }
 563 };
 564
 565 template <typename LibObjT>
 566 struct CommonTraceSpec;
 567
 568 /* Functions specific to mutable traces */
 569 template <>
 570 struct CommonTraceSpec<bt_trace> final
 571 {
 572     static bt_trace_class *cls(bt_trace * const libObjPtr) noexcept
 573     {
 574         return bt_trace_borrow_class(libObjPtr);
 575     }
 576
 577     static bt_stream *streamByIndex(bt_trace * const libObjPtr, const std::uint64_t index) noexcept
 578     {
 579         return bt_trace_borrow_stream_by_index(libObjPtr, index);
 580     }
 581
 582     static bt_stream *streamById(bt_trace * const libObjPtr, const std::uint64_t id) noexcept
 583     {
 584         return bt_trace_borrow_stream_by_id(libObjPtr, id);
 585     }
 586
 587     static bt_value *userAttributes(bt_trace * const libObjPtr) noexcept
 588     {
 589         return bt_trace_borrow_user_attributes(libObjPtr);
 590     }
 591 };
 592
 593 /* Functions specific to constant traces */
 594 template <>
 595 struct CommonTraceSpec<const bt_trace> final
 596 {
 597     static const bt_trace_class *cls(const bt_trace * const libObjPtr) noexcept
 598     {
 599         return bt_trace_borrow_class_const(libObjPtr);
 600     }
 601
 602     static const bt_stream *streamByIndex(const bt_trace * const libObjPtr,
 603                                           const std::uint64_t index) noexcept
 604     {
 605         return bt_trace_borrow_stream_by_index_const(libObjPtr, index);
 606     }
 607
 608     static const bt_stream *streamById(const bt_trace * const libObjPtr,
 609                                        const std::uint64_t id) noexcept
 610     {
 611         return bt_trace_borrow_stream_by_id_const(libObjPtr, id);
 612     }
 613
 614     static const bt_value *userAttributes(const bt_trace * const libObjPtr) noexcept
 615     {
 616         return bt_trace_borrow_user_attributes_const(libObjPtr);
 617     }
 618 };
 619
 620 } /* namespace internal */
 621
 622 template <typename LibObjT>
 623 class CommonTrace final : public BorrowedObject<LibObjT>
 624 {
 625 private:
 626     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 627     using _Spec = internal::CommonTraceSpec<LibObjT>;
 628     using _Stream = internal::DepStream<LibObjT>;
 629
 630 public:
 631     using typename BorrowedObject<LibObjT>::LibObjPtr;
 632     using Shared = SharedObject<CommonTrace, LibObjT, internal::TraceRefFuncs>;
 633     using UserAttributes = internal::DepUserAttrs<LibObjT>;
 634
 635     using Class = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
 636                                     CommonTraceClass<const bt_trace_class>>;
 637
 638     struct ConstEnvironmentEntry
 639     {
 640         const char *name;
 641         ConstValue value;
 642     };
 643
 644     explicit CommonTrace(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 645     {
 646     }
 647
 648     template <typename OtherLibObjT>
 649     CommonTrace(const CommonTrace<OtherLibObjT> trace) noexcept : _ThisBorrowedObject {trace}
 650     {
 651     }
 652
 653     template <typename OtherLibObjT>
 654     CommonTrace operator=(const CommonTrace<OtherLibObjT> trace) noexcept
 655     {
 656         _ThisBorrowedObject::operator=(trace);
 657         return *this;
 658     }
 659
 660     CommonTrace<const bt_trace> asConst() const noexcept
 661     {
 662         return CommonTrace<const bt_trace> {*this};
 663     }
 664
 665     Class cls() const noexcept;
 666
 667     void name(const char * const name) const
 668     {
 669         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
 670
 671         const auto status = bt_trace_set_name(this->libObjPtr(), name);
 672
 673         if (status == BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR) {
 674             throw MemoryError {};
 675         }
 676     }
 677
 678     void name(const std::string& name) const
 679     {
 680         this->name(name.data());
 681     }
 682
 683     const char *name() const noexcept
 684     {
 685         return bt_trace_get_name(this->libObjPtr());
 686     }
 687
 688     void uuid(const bt2c::UuidView& uuid) const noexcept
 689     {
 690         bt_trace_set_uuid(this->libObjPtr(), uuid.begin());
 691     }
 692
 693     bt2s::optional<bt2c::UuidView> uuid() const noexcept
 694     {
 695         const auto uuid = bt_trace_get_uuid(this->libObjPtr());
 696
 697         if (uuid) {
 698             return bt2c::UuidView {uuid};
 699         }
 700
 701         return bt2s::nullopt;
 702     }
 703
 704     std::uint64_t length() const noexcept
 705     {
 706         return bt_trace_get_stream_count(this->libObjPtr());
 707     }
 708
 709     _Stream operator[](const std::uint64_t index) const noexcept
 710     {
 711         return _Stream {_Spec::streamByIndex(this->libObjPtr(), index)};
 712     }
 713
 714     bt2s::optional<_Stream> streamById(const std::uint64_t id) const noexcept
 715     {
 716         const auto libObjPtr = _Spec::streamById(this->libObjPtr(), id);
 717
 718         if (libObjPtr) {
 719             return _Stream {libObjPtr};
 720         }
 721
 722         return bt2s::nullopt;
 723     }
 724
 725     void environmentEntry(const char * const name, const std::int64_t val) const
 726     {
 727         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
 728
 729         const auto status = bt_trace_set_environment_entry_integer(this->libObjPtr(), name, val);
 730
 731         if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
 732             throw MemoryError {};
 733         }
 734     }
 735
 736     void environmentEntry(const std::string& name, const std::int64_t val) const
 737     {
 738         this->environmentEntry(name.data(), val);
 739     }
 740
 741     void environmentEntry(const char * const name, const char * const val) const
 742     {
 743         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
 744
 745         const auto status = bt_trace_set_environment_entry_string(this->libObjPtr(), name, val);
 746
 747         if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
 748             throw MemoryError {};
 749         }
 750     }
 751
 752     void environmentEntry(const std::string& name, const char * const val) const
 753     {
 754         this->environmentEntry(name.data(), val);
 755     }
 756
 757     void environmentEntry(const char * const name, const std::string& val) const
 758     {
 759         this->environmentEntry(name, val.data());
 760     }
 761
 762     void environmentEntry(const std::string& name, const std::string& val) const
 763     {
 764         this->environmentEntry(name.data(), val.data());
 765     }
 766
 767     std::uint64_t environmentSize() const noexcept
 768     {
 769         return bt_trace_get_environment_entry_count(this->libObjPtr());
 770     }
 771
 772     ConstEnvironmentEntry environmentEntry(const std::uint64_t index) const noexcept
 773     {
 774         const char *name;
 775         const bt_value *libObjPtr;
 776
 777         bt_trace_borrow_environment_entry_by_index_const(this->libObjPtr(), index, &name,
 778                                                          &libObjPtr);
 779         return ConstEnvironmentEntry {name, ConstValue {libObjPtr}};
 780     }
 781
 782     bt2s::optional<ConstValue> environmentEntry(const char * const name) const noexcept
 783     {
 784         const auto libObjPtr =
 785             bt_trace_borrow_environment_entry_value_by_name_const(this->libObjPtr(), name);
 786
 787         if (libObjPtr) {
 788             return ConstValue {libObjPtr};
 789         }
 790
 791         return bt2s::nullopt;
 792     }
 793
 794     bt2s::optional<ConstValue> environmentEntry(const std::string& name) const noexcept
 795     {
 796         return this->environmentEntry(name.data());
 797     }
 798
 799     template <typename LibValT>
 800     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
 801     {
 802         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
 803
 804         bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
 805     }
 806
 807     UserAttributes userAttributes() const noexcept
 808     {
 809         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
 810     }
 811
 812     Shared shared() const noexcept
 813     {
 814         return Shared::createWithRef(*this);
 815     }
 816 };
 817
 818 using Trace = CommonTrace<bt_trace>;
 819 using ConstTrace = CommonTrace<const bt_trace>;
 820
 821 namespace internal {
 822
 823 struct TraceTypeDescr
 824 {
 825     using Const = ConstTrace;
 826     using NonConst = Trace;
 827 };
 828
 829 template <>
 830 struct TypeDescr<Trace> : public TraceTypeDescr
 831 {
 832 };
 833
 834 template <>
 835 struct TypeDescr<ConstTrace> : public TraceTypeDescr
 836 {
 837 };
 838
 839 } /* namespace internal */
 840
 841 template <typename LibObjT>
 842 typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() const noexcept
 843 {
 844     return _Trace {_Spec::trace(this->libObjPtr())};
 845 }
 846
 847 namespace internal {
 848
 849 struct EventClassRefFuncs final
 850 {
 851     static void get(const bt_event_class * const libObjPtr) noexcept
 852     {
 853         bt_event_class_get_ref(libObjPtr);
 854     }
 855
 856     static void put(const bt_event_class * const libObjPtr) noexcept
 857     {
 858         bt_event_class_put_ref(libObjPtr);
 859     }
 860 };
 861
 862 template <typename LibObjT>
 863 struct CommonEventClassSpec;
 864
 865 /* Functions specific to mutable event classes */
 866 template <>
 867 struct CommonEventClassSpec<bt_event_class> final
 868 {
 869     static bt_stream_class *streamClass(bt_event_class * const libObjPtr) noexcept
 870     {
 871         return bt_event_class_borrow_stream_class(libObjPtr);
 872     }
 873
 874     static bt_field_class *payloadFieldClass(bt_event_class * const libObjPtr) noexcept
 875     {
 876         return bt_event_class_borrow_payload_field_class(libObjPtr);
 877     }
 878
 879     static bt_field_class *specificContextFieldClass(bt_event_class * const libObjPtr) noexcept
 880     {
 881         return bt_event_class_borrow_specific_context_field_class(libObjPtr);
 882     }
 883
 884     static bt_value *userAttributes(bt_event_class * const libObjPtr) noexcept
 885     {
 886         return bt_event_class_borrow_user_attributes(libObjPtr);
 887     }
 888 };
 889
 890 /* Functions specific to constant event classes */
 891 template <>
 892 struct CommonEventClassSpec<const bt_event_class> final
 893 {
 894     static const bt_stream_class *streamClass(const bt_event_class * const libObjPtr) noexcept
 895     {
 896         return bt_event_class_borrow_stream_class_const(libObjPtr);
 897     }
 898
 899     static const bt_field_class *payloadFieldClass(const bt_event_class * const libObjPtr) noexcept
 900     {
 901         return bt_event_class_borrow_payload_field_class_const(libObjPtr);
 902     }
 903
 904     static const bt_field_class *
 905     specificContextFieldClass(const bt_event_class * const libObjPtr) noexcept
 906     {
 907         return bt_event_class_borrow_specific_context_field_class_const(libObjPtr);
 908     }
 909
 910     static const bt_value *userAttributes(const bt_event_class * const libObjPtr) noexcept
 911     {
 912         return bt_event_class_borrow_user_attributes_const(libObjPtr);
 913     }
 914 };
 915
 916 template <typename LibObjT>
 917 using DepStructFc = DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
 918
 919 } /* namespace internal */
 920
 921 template <typename LibObjT>
 922 class CommonEventClass final : public BorrowedObject<LibObjT>
 923 {
 924 private:
 925     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 926     using _Spec = internal::CommonEventClassSpec<LibObjT>;
 927     using _StructureFieldClass = internal::DepStructFc<LibObjT>;
 928
 929     using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
 930                                            CommonStreamClass<const bt_stream_class>>;
 931
 932 public:
 933     using typename BorrowedObject<LibObjT>::LibObjPtr;
 934     using Shared = SharedObject<CommonEventClass, LibObjT, internal::EventClassRefFuncs>;
 935     using UserAttributes = internal::DepUserAttrs<LibObjT>;
 936
 937     enum class LogLevel
 938     {
 939         EMERGENCY = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY,
 940         ALERT = BT_EVENT_CLASS_LOG_LEVEL_ALERT,
 941         CRITICAL = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL,
 942         ERR = BT_EVENT_CLASS_LOG_LEVEL_ERROR,
 943         WARNING = BT_EVENT_CLASS_LOG_LEVEL_WARNING,
 944         NOTICE = BT_EVENT_CLASS_LOG_LEVEL_NOTICE,
 945         INFO = BT_EVENT_CLASS_LOG_LEVEL_INFO,
 946         DEBUG_SYSTEM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM,
 947         DEBUG_PROGRAM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM,
 948         DEBUG_PROC = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS,
 949         DEBUG_MODULE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE,
 950         DEBUG_UNIT = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT,
 951         DEBUG_FUNCTION = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION,
 952         DEBUG_LINE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE,
 953         DEBUG = BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
 954     };
 955
 956     explicit CommonEventClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 957     {
 958     }
 959
 960     template <typename OtherLibObjT>
 961     CommonEventClass(const CommonEventClass<OtherLibObjT> eventClass) noexcept :
 962         _ThisBorrowedObject {eventClass}
 963     {
 964     }
 965
 966     template <typename OtherLibObjT>
 967     CommonEventClass operator=(const CommonEventClass<OtherLibObjT> eventClass) noexcept
 968     {
 969         _ThisBorrowedObject::operator=(eventClass);
 970         return *this;
 971     }
 972
 973     CommonEventClass<const bt_event_class> asConst() const noexcept
 974     {
 975         return CommonEventClass<const bt_event_class> {*this};
 976     }
 977
 978     _StreamClass streamClass() const noexcept;
 979
 980     std::uint64_t id() const noexcept
 981     {
 982         return bt_event_class_get_id(this->libObjPtr());
 983     }
 984
 985     void name(const char * const name) const
 986     {
 987         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
 988
 989         const auto status = bt_event_class_set_name(this->libObjPtr(), name);
 990
 991         if (status == BT_EVENT_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
 992             throw MemoryError {};
 993         }
 994     }
 995
 996     void name(const std::string& name) const
 997     {
 998         this->name(name.data());
 999     }
1000
1001     const char *name() const noexcept
1002     {
1003         return bt_event_class_get_name(this->libObjPtr());
1004     }
1005
1006     void logLevel(const LogLevel logLevel) const noexcept
1007     {
1008         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1009
1010         bt_event_class_set_log_level(this->libObjPtr(),
1011                                      static_cast<bt_event_class_log_level>(logLevel));
1012     }
1013
1014     bt2s::optional<LogLevel> logLevel() const noexcept
1015     {
1016         bt_event_class_log_level libLogLevel;
1017         const auto avail = bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel);
1018
1019         if (avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
1020             return static_cast<LogLevel>(libLogLevel);
1021         }
1022
1023         return bt2s::nullopt;
1024     }
1025
1026     void emfUri(const char * const emfUri) const
1027     {
1028         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1029
1030         const auto status = bt_event_class_set_emf_uri(this->libObjPtr(), emfUri);
1031
1032         if (status == BT_EVENT_CLASS_SET_EMF_URI_STATUS_MEMORY_ERROR) {
1033             throw MemoryError {};
1034         }
1035     }
1036
1037     void emfUri(const std::string& emfUri) const
1038     {
1039         this->emfUri(emfUri.data());
1040     }
1041
1042     const char *emfUri() const noexcept
1043     {
1044         return bt_event_class_get_emf_uri(this->libObjPtr());
1045     }
1046
1047     void payloadFieldClass(const StructureFieldClass fc) const
1048     {
1049         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1050
1051         const auto status =
1052             bt_event_class_set_payload_field_class(this->libObjPtr(), fc.libObjPtr());
1053
1054         if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1055             throw MemoryError {};
1056         }
1057     }
1058
1059     bt2s::optional<_StructureFieldClass> payloadFieldClass() const noexcept
1060     {
1061         const auto libObjPtr = _Spec::payloadFieldClass(this->libObjPtr());
1062
1063         if (libObjPtr) {
1064             return _StructureFieldClass {libObjPtr};
1065         }
1066
1067         return bt2s::nullopt;
1068     }
1069
1070     void specificContextFieldClass(const StructureFieldClass fc) const
1071     {
1072         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1073
1074         const auto status =
1075             bt_event_class_set_specific_context_field_class(this->libObjPtr(), fc.libObjPtr());
1076
1077         if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1078             throw MemoryError {};
1079         }
1080     }
1081
1082     bt2s::optional<_StructureFieldClass> specificContextFieldClass() const noexcept
1083     {
1084         const auto libObjPtr = _Spec::specificContextFieldClass(this->libObjPtr());
1085
1086         if (libObjPtr) {
1087             return _StructureFieldClass {libObjPtr};
1088         }
1089
1090         return bt2s::nullopt;
1091     }
1092
1093     template <typename LibValT>
1094     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1095     {
1096         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1097
1098         bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1099     }
1100
1101     UserAttributes userAttributes() const noexcept
1102     {
1103         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1104     }
1105
1106     Shared shared() const noexcept
1107     {
1108         return Shared::createWithRef(*this);
1109     }
1110 };
1111
1112 using EventClass = CommonEventClass<bt_event_class>;
1113 using ConstEventClass = CommonEventClass<const bt_event_class>;
1114
1115 namespace internal {
1116
1117 struct EventClassTypeDescr
1118 {
1119     using Const = ConstEventClass;
1120     using NonConst = EventClass;
1121 };
1122
1123 template <>
1124 struct TypeDescr<EventClass> : public EventClassTypeDescr
1125 {
1126 };
1127
1128 template <>
1129 struct TypeDescr<ConstEventClass> : public EventClassTypeDescr
1130 {
1131 };
1132
1133 } /* namespace internal */
1134
1135 template <typename LibObjT>
1136 typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() const noexcept
1137 {
1138     return Class {_Spec::cls(this->libObjPtr())};
1139 }
1140
1141 namespace internal {
1142
1143 struct StreamClassRefFuncs final
1144 {
1145     static void get(const bt_stream_class * const libObjPtr) noexcept
1146     {
1147         bt_stream_class_get_ref(libObjPtr);
1148     }
1149
1150     static void put(const bt_stream_class * const libObjPtr) noexcept
1151     {
1152         bt_stream_class_put_ref(libObjPtr);
1153     }
1154 };
1155
1156 template <typename LibObjT>
1157 struct CommonStreamClassSpec;
1158
1159 /* Functions specific to mutable stream classes */
1160 template <>
1161 struct CommonStreamClassSpec<bt_stream_class> final
1162 {
1163     static bt_trace_class *traceClass(bt_stream_class * const libObjPtr) noexcept
1164     {
1165         return bt_stream_class_borrow_trace_class(libObjPtr);
1166     }
1167
1168     static bt_event_class *eventClassByIndex(bt_stream_class * const libObjPtr,
1169                                              const std::uint64_t index) noexcept
1170     {
1171         return bt_stream_class_borrow_event_class_by_index(libObjPtr, index);
1172     }
1173
1174     static bt_event_class *eventClassById(bt_stream_class * const libObjPtr,
1175                                           const std::uint64_t id) noexcept
1176     {
1177         return bt_stream_class_borrow_event_class_by_id(libObjPtr, id);
1178     }
1179
1180     static bt_clock_class *defaultClockClass(bt_stream_class * const libObjPtr) noexcept
1181     {
1182         return bt_stream_class_borrow_default_clock_class(libObjPtr);
1183     }
1184
1185     static bt_field_class *packetContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1186     {
1187         return bt_stream_class_borrow_packet_context_field_class(libObjPtr);
1188     }
1189
1190     static bt_field_class *eventCommonContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1191     {
1192         return bt_stream_class_borrow_event_common_context_field_class(libObjPtr);
1193     }
1194
1195     static bt_value *userAttributes(bt_stream_class * const libObjPtr) noexcept
1196     {
1197         return bt_stream_class_borrow_user_attributes(libObjPtr);
1198     }
1199 };
1200
1201 /* Functions specific to constant stream classes */
1202 template <>
1203 struct CommonStreamClassSpec<const bt_stream_class> final
1204 {
1205     static const bt_trace_class *traceClass(const bt_stream_class * const libObjPtr) noexcept
1206     {
1207         return bt_stream_class_borrow_trace_class_const(libObjPtr);
1208     }
1209
1210     static const bt_event_class *eventClassByIndex(const bt_stream_class * const libObjPtr,
1211                                                    const std::uint64_t index) noexcept
1212     {
1213         return bt_stream_class_borrow_event_class_by_index_const(libObjPtr, index);
1214     }
1215
1216     static const bt_event_class *eventClassById(const bt_stream_class * const libObjPtr,
1217                                                 const std::uint64_t id) noexcept
1218     {
1219         return bt_stream_class_borrow_event_class_by_id_const(libObjPtr, id);
1220     }
1221
1222     static const bt_clock_class *defaultClockClass(const bt_stream_class * const libObjPtr) noexcept
1223     {
1224         return bt_stream_class_borrow_default_clock_class_const(libObjPtr);
1225     }
1226
1227     static const bt_field_class *
1228     packetContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1229     {
1230         return bt_stream_class_borrow_packet_context_field_class_const(libObjPtr);
1231     }
1232
1233     static const bt_field_class *
1234     eventCommonContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1235     {
1236         return bt_stream_class_borrow_event_common_context_field_class_const(libObjPtr);
1237     }
1238
1239     static const bt_value *userAttributes(const bt_stream_class * const libObjPtr) noexcept
1240     {
1241         return bt_stream_class_borrow_user_attributes_const(libObjPtr);
1242     }
1243 };
1244
1245 } /* namespace internal */
1246
1247 template <typename LibObjT>
1248 class CommonStreamClass final : public BorrowedObject<LibObjT>
1249 {
1250 private:
1251     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1252     using _Spec = internal::CommonStreamClassSpec<LibObjT>;
1253     using _StructureFieldClass = internal::DepStructFc<LibObjT>;
1254
1255     using _TraceClass = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
1256                                           CommonTraceClass<const bt_trace_class>>;
1257
1258     using _EventClass = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
1259                                           CommonEventClass<const bt_event_class>>;
1260
1261     using _ClockClass = internal::DepType<LibObjT, ClockClass, ConstClockClass>;
1262
1263 public:
1264     using typename BorrowedObject<LibObjT>::LibObjPtr;
1265     using Shared = SharedObject<CommonStreamClass, LibObjT, internal::StreamClassRefFuncs>;
1266     using UserAttributes = internal::DepUserAttrs<LibObjT>;
1267
1268     explicit CommonStreamClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
1269     {
1270     }
1271
1272     template <typename OtherLibObjT>
1273     CommonStreamClass(const CommonStreamClass<OtherLibObjT> streamClass) noexcept :
1274         _ThisBorrowedObject {streamClass}
1275     {
1276     }
1277
1278     template <typename OtherLibObjT>
1279     CommonStreamClass operator=(const CommonStreamClass<OtherLibObjT> streamClass) noexcept
1280     {
1281         _ThisBorrowedObject::operator=(streamClass);
1282         return *this;
1283     }
1284
1285     CommonStreamClass<const bt_stream_class> asConst() const noexcept
1286     {
1287         return CommonStreamClass<const bt_stream_class> {*this};
1288     }
1289
1290     Stream::Shared instantiate(const Trace trace) const
1291     {
1292         static_assert(!std::is_const<LibObjT>::value,
1293                       "Not available with `bt2::ConstStreamClass`.");
1294
1295         const auto libObjPtr = bt_stream_create(this->libObjPtr(), trace.libObjPtr());
1296
1297         internal::validateCreatedObjPtr(libObjPtr);
1298         return Stream::Shared::createWithoutRef(libObjPtr);
1299     }
1300
1301     Stream::Shared instantiate(const Trace trace, const std::uint64_t id) const
1302     {
1303         static_assert(!std::is_const<LibObjT>::value,
1304                       "Not available with `bt2::ConstStreamClass`.");
1305
1306         const auto libObjPtr = bt_stream_create_with_id(this->libObjPtr(), trace.libObjPtr(), id);
1307
1308         internal::validateCreatedObjPtr(libObjPtr);
1309         return Stream::Shared::createWithoutRef(libObjPtr);
1310     }
1311
1312     EventClass::Shared createEventClass() const
1313     {
1314         static_assert(!std::is_const<LibObjT>::value,
1315                       "Not available with `bt2::ConstStreamClass`.");
1316
1317         const auto libObjPtr = bt_event_class_create(this->libObjPtr());
1318
1319         internal::validateCreatedObjPtr(libObjPtr);
1320         return EventClass::Shared::createWithoutRef(libObjPtr);
1321     }
1322
1323     EventClass::Shared createEventClass(const std::uint64_t id) const
1324     {
1325         static_assert(!std::is_const<LibObjT>::value,
1326                       "Not available with `bt2::ConstStreamClass`.");
1327
1328         const auto libObjPtr = bt_event_class_create_with_id(this->libObjPtr(), id);
1329
1330         internal::validateCreatedObjPtr(libObjPtr);
1331         return EventClass::Shared::createWithoutRef(libObjPtr);
1332     }
1333
1334     _TraceClass traceClass() const noexcept;
1335
1336     std::uint64_t id() const noexcept
1337     {
1338         return bt_stream_class_get_id(this->libObjPtr());
1339     }
1340
1341     void name(const char * const name) const
1342     {
1343         static_assert(!std::is_const<LibObjT>::value,
1344                       "Not available with `bt2::ConstStreamClass`.");
1345
1346         const auto status = bt_stream_class_set_name(this->libObjPtr(), name);
1347
1348         if (status == BT_STREAM_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
1349             throw MemoryError {};
1350         }
1351     }
1352
1353     void name(const std::string& name) const
1354     {
1355         this->name(name.data());
1356     }
1357
1358     const char *name() const noexcept
1359     {
1360         return bt_stream_class_get_name(this->libObjPtr());
1361     }
1362
1363     void assignsAutomaticEventClassId(const bool val) const noexcept
1364     {
1365         static_assert(!std::is_const<LibObjT>::value,
1366                       "Not available with `bt2::ConstStreamClass`.");
1367
1368         bt_stream_class_set_assigns_automatic_event_class_id(this->libObjPtr(),
1369                                                              static_cast<bt_bool>(val));
1370     }
1371
1372     bool assignsAutomaticEventClassId() const noexcept
1373     {
1374         return static_cast<bool>(
1375             bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
1376     }
1377
1378     void assignsAutomaticStreamId(const bool val) const noexcept
1379     {
1380         static_assert(!std::is_const<LibObjT>::value,
1381                       "Not available with `bt2::ConstStreamClass`.");
1382
1383         bt_stream_class_set_assigns_automatic_stream_id(this->libObjPtr(),
1384                                                         static_cast<bt_bool>(val));
1385     }
1386
1387     bool assignsAutomaticStreamId() const noexcept
1388     {
1389         return static_cast<bool>(bt_stream_class_assigns_automatic_stream_id(this->libObjPtr()));
1390     }
1391
1392     void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
1393                          const bool withEndDefaultClkSnapshot) const noexcept
1394     {
1395         static_assert(!std::is_const<LibObjT>::value,
1396                       "Not available with `bt2::ConstStreamClass`.");
1397
1398         bt_stream_class_set_supports_packets(this->libObjPtr(),
1399                                              static_cast<bt_bool>(supportsPackets),
1400                                              static_cast<bt_bool>(withBeginningDefaultClkSnapshot),
1401                                              static_cast<bt_bool>(withEndDefaultClkSnapshot));
1402     }
1403
1404     bool supportsPackets() const noexcept
1405     {
1406         return static_cast<bool>(bt_stream_class_supports_packets(this->libObjPtr()));
1407     }
1408
1409     bool packetsHaveBeginningClockSnapshot() const noexcept
1410     {
1411         return static_cast<bool>(
1412             bt_stream_class_packets_have_beginning_default_clock_snapshot(this->libObjPtr()));
1413     }
1414
1415     bool packetsHaveEndClockSnapshot() const noexcept
1416     {
1417         return static_cast<bool>(
1418             bt_stream_class_packets_have_end_default_clock_snapshot(this->libObjPtr()));
1419     }
1420
1421     void supportsDiscardedEvents(const bool supportsDiscardedEvents,
1422                                  const bool withDefaultClkSnapshots) const noexcept
1423     {
1424         static_assert(!std::is_const<LibObjT>::value,
1425                       "Not available with `bt2::ConstStreamClass`.");
1426
1427         bt_stream_class_set_supports_discarded_events(
1428             this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedEvents),
1429             static_cast<bt_bool>(withDefaultClkSnapshots));
1430     }
1431
1432     bool supportsDiscardedEvents() const noexcept
1433     {
1434         return static_cast<bool>(bt_stream_class_supports_discarded_events(this->libObjPtr()));
1435     }
1436
1437     bool discardedEventsHaveDefaultClockSnapshots() const noexcept
1438     {
1439         return static_cast<bool>(
1440             bt_stream_class_discarded_events_have_default_clock_snapshots(this->libObjPtr()));
1441     }
1442
1443     void supportsDiscardedPackets(const bool supportsDiscardedPackets,
1444                                   const bool withDefaultClkSnapshots) const noexcept
1445     {
1446         static_assert(!std::is_const<LibObjT>::value,
1447                       "Not available with `bt2::ConstStreamClass`.");
1448
1449         bt_stream_class_set_supports_discarded_packets(
1450             this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedPackets),
1451             static_cast<bt_bool>(withDefaultClkSnapshots));
1452     }
1453
1454     bool supportsDiscardedPackets() const noexcept
1455     {
1456         return static_cast<bool>(bt_stream_class_supports_discarded_packets(this->libObjPtr()));
1457     }
1458
1459     bool discardedPacketsHaveDefaultClockSnapshots() const noexcept
1460     {
1461         return static_cast<bool>(
1462             bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
1463     }
1464
1465     void defaultClockClass(const ClockClass clkCls) const
1466     {
1467         static_assert(!std::is_const<LibObjT>::value,
1468                       "Not available with `bt2::ConstStreamClass`.");
1469
1470         const auto status =
1471             bt_stream_class_set_default_clock_class(this->libObjPtr(), clkCls.libObjPtr());
1472
1473         BT_ASSERT(status == BT_STREAM_CLASS_SET_DEFAULT_CLOCK_CLASS_STATUS_OK);
1474     }
1475
1476     bt2s::optional<_ClockClass> defaultClockClass() const noexcept
1477     {
1478         const auto libObjPtr = _Spec::defaultClockClass(this->libObjPtr());
1479
1480         if (libObjPtr) {
1481             return _ClockClass {libObjPtr};
1482         }
1483
1484         return bt2s::nullopt;
1485     }
1486
1487     std::uint64_t length() const noexcept
1488     {
1489         return bt_stream_class_get_event_class_count(this->libObjPtr());
1490     }
1491
1492     _EventClass operator[](const std::uint64_t index) const noexcept
1493     {
1494         return _EventClass {_Spec::eventClassByIndex(this->libObjPtr(), index)};
1495     }
1496
1497     bt2s::optional<_EventClass> eventClassById(const std::uint64_t id) const noexcept
1498     {
1499         const auto libObjPtr = _Spec::eventClassById(this->libObjPtr(), id);
1500
1501         if (libObjPtr) {
1502             return _EventClass {libObjPtr};
1503         }
1504
1505         return bt2s::nullopt;
1506     }
1507
1508     void packetContextFieldClass(const StructureFieldClass fc) const
1509     {
1510         static_assert(!std::is_const<LibObjT>::value,
1511                       "Not available with `bt2::ConstStreamClass`.");
1512
1513         const auto status =
1514             bt_stream_class_set_packet_context_field_class(this->libObjPtr(), fc.libObjPtr());
1515
1516         if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1517             throw MemoryError {};
1518         }
1519     }
1520
1521     bt2s::optional<_StructureFieldClass> packetContextFieldClass() const noexcept
1522     {
1523         const auto libObjPtr = _Spec::packetContextFieldClass(this->libObjPtr());
1524
1525         if (libObjPtr) {
1526             return _StructureFieldClass {libObjPtr};
1527         }
1528
1529         return bt2s::nullopt;
1530     }
1531
1532     void eventCommonContextFieldClass(const StructureFieldClass fc) const
1533     {
1534         static_assert(!std::is_const<LibObjT>::value,
1535                       "Not available with `bt2::ConstStreamClass`.");
1536
1537         const auto status =
1538             bt_stream_class_set_event_common_context_field_class(this->libObjPtr(), fc.libObjPtr());
1539
1540         if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1541             throw MemoryError {};
1542         }
1543     }
1544
1545     bt2s::optional<_StructureFieldClass> eventCommonContextFieldClass() const noexcept
1546     {
1547         const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->libObjPtr());
1548
1549         if (libObjPtr) {
1550             return _StructureFieldClass {libObjPtr};
1551         }
1552
1553         return bt2s::nullopt;
1554     }
1555
1556     template <typename LibValT>
1557     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1558     {
1559         static_assert(!std::is_const<LibObjT>::value,
1560                       "Not available with `bt2::ConstStreamClass`.");
1561
1562         bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1563     }
1564
1565     UserAttributes userAttributes() const noexcept
1566     {
1567         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1568     }
1569
1570     Shared shared() const noexcept
1571     {
1572         return Shared::createWithRef(*this);
1573     }
1574 };
1575
1576 using StreamClass = CommonStreamClass<bt_stream_class>;
1577 using ConstStreamClass = CommonStreamClass<const bt_stream_class>;
1578
1579 namespace internal {
1580
1581 struct StreamClassTypeDescr
1582 {
1583     using Const = ConstStreamClass;
1584     using NonConst = StreamClass;
1585 };
1586
1587 template <>
1588 struct TypeDescr<StreamClass> : public StreamClassTypeDescr
1589 {
1590 };
1591
1592 template <>
1593 struct TypeDescr<ConstStreamClass> : public StreamClassTypeDescr
1594 {
1595 };
1596
1597 } /* namespace internal */
1598
1599 template <typename LibObjT>
1600 typename CommonEventClass<LibObjT>::_StreamClass
1601 CommonEventClass<LibObjT>::streamClass() const noexcept
1602 {
1603     return _StreamClass {_Spec::streamClass(this->libObjPtr())};
1604 }
1605
1606 template <typename LibObjT>
1607 typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() const noexcept
1608 {
1609     return Class {_Spec::cls(this->libObjPtr())};
1610 }
1611
1612 namespace internal {
1613
1614 struct TraceClassRefFuncs final
1615 {
1616     static void get(const bt_trace_class * const libObjPtr) noexcept
1617     {
1618         bt_trace_class_get_ref(libObjPtr);
1619     }
1620
1621     static void put(const bt_trace_class * const libObjPtr) noexcept
1622     {
1623         bt_trace_class_put_ref(libObjPtr);
1624     }
1625 };
1626
1627 template <typename LibObjT>
1628 struct CommonTraceClassSpec;
1629
1630 /* Functions specific to mutable stream classes */
1631 template <>
1632 struct CommonTraceClassSpec<bt_trace_class> final
1633 {
1634     static bt_stream_class *streamClassByIndex(bt_trace_class * const libObjPtr,
1635                                                const std::uint64_t index) noexcept
1636     {
1637         return bt_trace_class_borrow_stream_class_by_index(libObjPtr, index);
1638     }
1639
1640     static bt_stream_class *streamClassById(bt_trace_class * const libObjPtr,
1641                                             const std::uint64_t id) noexcept
1642     {
1643         return bt_trace_class_borrow_stream_class_by_id(libObjPtr, id);
1644     }
1645
1646     static bt_value *userAttributes(bt_trace_class * const libObjPtr) noexcept
1647     {
1648         return bt_trace_class_borrow_user_attributes(libObjPtr);
1649     }
1650 };
1651
1652 /* Functions specific to constant stream classes */
1653 template <>
1654 struct CommonTraceClassSpec<const bt_trace_class> final
1655 {
1656     static const bt_stream_class *streamClassByIndex(const bt_trace_class * const libObjPtr,
1657                                                      const std::uint64_t index) noexcept
1658     {
1659         return bt_trace_class_borrow_stream_class_by_index_const(libObjPtr, index);
1660     }
1661
1662     static const bt_stream_class *streamClassById(const bt_trace_class * const libObjPtr,
1663                                                   const std::uint64_t id) noexcept
1664     {
1665         return bt_trace_class_borrow_stream_class_by_id_const(libObjPtr, id);
1666     }
1667
1668     static const bt_value *userAttributes(const bt_trace_class * const libObjPtr) noexcept
1669     {
1670         return bt_trace_class_borrow_user_attributes_const(libObjPtr);
1671     }
1672 };
1673
1674 } /* namespace internal */
1675
1676 template <typename LibObjT>
1677 class CommonTraceClass final : public BorrowedObject<LibObjT>
1678 {
1679 private:
1680     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1681
1682     using _Spec = internal::CommonTraceClassSpec<LibObjT>;
1683
1684     using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
1685                                            CommonStreamClass<const bt_stream_class>>;
1686
1687 public:
1688     using typename BorrowedObject<LibObjT>::LibObjPtr;
1689     using Shared = SharedObject<CommonTraceClass, LibObjT, internal::TraceClassRefFuncs>;
1690     using UserAttributes = internal::DepUserAttrs<LibObjT>;
1691
1692     explicit CommonTraceClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
1693     {
1694     }
1695
1696     template <typename OtherLibObjT>
1697     CommonTraceClass(const CommonTraceClass<OtherLibObjT> traceClass) noexcept :
1698         _ThisBorrowedObject {traceClass}
1699     {
1700     }
1701
1702     template <typename OtherLibObjT>
1703     CommonTraceClass operator=(const CommonTraceClass<OtherLibObjT> traceClass) noexcept
1704     {
1705         _ThisBorrowedObject::operator=(traceClass);
1706         return *this;
1707     }
1708
1709     CommonTraceClass<const bt_trace_class> asConst() const noexcept
1710     {
1711         return CommonTraceClass<const bt_trace_class> {*this};
1712     }
1713
1714     Trace::Shared instantiate() const
1715     {
1716         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1717
1718         const auto libObjPtr = bt_trace_create(this->libObjPtr());
1719
1720         internal::validateCreatedObjPtr(libObjPtr);
1721         return Trace::Shared::createWithoutRef(libObjPtr);
1722     }
1723
1724     StreamClass::Shared createStreamClass() const
1725     {
1726         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1727
1728         const auto libObjPtr = bt_stream_class_create(this->libObjPtr());
1729
1730         internal::validateCreatedObjPtr(libObjPtr);
1731         return StreamClass::Shared::createWithoutRef(libObjPtr);
1732     }
1733
1734     StreamClass::Shared createStreamClass(const std::uint64_t id) const
1735     {
1736         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1737
1738         const auto libObjPtr = bt_stream_class_create_with_id(this->libObjPtr(), id);
1739
1740         internal::validateCreatedObjPtr(libObjPtr);
1741         return StreamClass::Shared::createWithoutRef(libObjPtr);
1742     }
1743
1744     FieldClass::Shared createBoolFieldClass() const
1745     {
1746         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1747
1748         const auto libObjPtr = bt_field_class_bool_create(this->libObjPtr());
1749
1750         internal::validateCreatedObjPtr(libObjPtr);
1751         return FieldClass::Shared::createWithoutRef(libObjPtr);
1752     }
1753
1754     BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length) const
1755     {
1756         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1757
1758         const auto libObjPtr = bt_field_class_bit_array_create(this->libObjPtr(), length);
1759
1760         internal::validateCreatedObjPtr(libObjPtr);
1761         return BitArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1762     }
1763
1764     IntegerFieldClass::Shared createUnsignedIntegerFieldClass() const
1765     {
1766         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1767
1768         const auto libObjPtr = bt_field_class_integer_unsigned_create(this->libObjPtr());
1769
1770         internal::validateCreatedObjPtr(libObjPtr);
1771         return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1772     }
1773
1774     IntegerFieldClass::Shared createSignedIntegerFieldClass() const
1775     {
1776         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1777
1778         const auto libObjPtr = bt_field_class_integer_signed_create(this->libObjPtr());
1779
1780         internal::validateCreatedObjPtr(libObjPtr);
1781         return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1782     }
1783
1784     UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass() const
1785     {
1786         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1787
1788         const auto libObjPtr = bt_field_class_enumeration_unsigned_create(this->libObjPtr());
1789
1790         internal::validateCreatedObjPtr(libObjPtr);
1791         return UnsignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1792     }
1793
1794     SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass() const
1795     {
1796         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1797
1798         const auto libObjPtr = bt_field_class_enumeration_signed_create(this->libObjPtr());
1799
1800         internal::validateCreatedObjPtr(libObjPtr);
1801         return SignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1802     }
1803
1804     FieldClass::Shared createSinglePrecisionRealFieldClass() const
1805     {
1806         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1807
1808         const auto libObjPtr = bt_field_class_real_single_precision_create(this->libObjPtr());
1809
1810         internal::validateCreatedObjPtr(libObjPtr);
1811         return FieldClass::Shared::createWithoutRef(libObjPtr);
1812     }
1813
1814     FieldClass::Shared createDoublePrecisionRealFieldClass() const
1815     {
1816         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1817
1818         const auto libObjPtr = bt_field_class_real_double_precision_create(this->libObjPtr());
1819
1820         internal::validateCreatedObjPtr(libObjPtr);
1821         return FieldClass::Shared::createWithoutRef(libObjPtr);
1822     }
1823
1824     FieldClass::Shared createStringFieldClass() const
1825     {
1826         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1827
1828         const auto libObjPtr = bt_field_class_string_create(this->libObjPtr());
1829
1830         internal::validateCreatedObjPtr(libObjPtr);
1831         return FieldClass::Shared::createWithoutRef(libObjPtr);
1832     }
1833
1834     StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass elementFieldClass,
1835                                                               const std::uint64_t length) const
1836     {
1837         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1838
1839         const auto libObjPtr = bt_field_class_array_static_create(
1840             this->libObjPtr(), elementFieldClass.libObjPtr(), length);
1841
1842         internal::validateCreatedObjPtr(libObjPtr);
1843         return StaticArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1844     }
1845
1846     ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass) const
1847     {
1848         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1849
1850         const auto libObjPtr = bt_field_class_array_dynamic_create(
1851             this->libObjPtr(), elementFieldClass.libObjPtr(), nullptr);
1852
1853         internal::validateCreatedObjPtr(libObjPtr);
1854         return ArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1855     }
1856
1857     DynamicArrayWithLengthFieldClass::Shared
1858     createDynamicArrayFieldClass(const FieldClass elementFieldClass,
1859                                  const IntegerFieldClass lengthFieldClass) const
1860     {
1861         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1862
1863         const auto libObjPtr = bt_field_class_array_dynamic_create(
1864             this->libObjPtr(), elementFieldClass.libObjPtr(), lengthFieldClass.libObjPtr());
1865
1866         internal::validateCreatedObjPtr(libObjPtr);
1867         return DynamicArrayWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
1868     }
1869
1870     StructureFieldClass::Shared createStructureFieldClass() const
1871     {
1872         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1873
1874         const auto libObjPtr = bt_field_class_structure_create(this->libObjPtr());
1875
1876         internal::validateCreatedObjPtr(libObjPtr);
1877         return StructureFieldClass::Shared::createWithoutRef(libObjPtr);
1878     }
1879
1880     OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass) const
1881     {
1882         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1883
1884         const auto libObjPtr = bt_field_class_option_without_selector_create(
1885             this->libObjPtr(), optionalFieldClass.libObjPtr());
1886
1887         internal::validateCreatedObjPtr(libObjPtr);
1888         return OptionFieldClass::Shared::createWithoutRef(libObjPtr);
1889     }
1890
1891     OptionWithBoolSelectorFieldClass::Shared
1892     createOptionWithBoolSelectorFieldClass(const FieldClass optionalFieldClass,
1893                                            const FieldClass selectorFieldClass) const
1894     {
1895         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1896
1897         const auto libObjPtr = bt_field_class_option_with_selector_field_bool_create(
1898             this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr());
1899
1900         internal::validateCreatedObjPtr(libObjPtr);
1901         return OptionWithBoolSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1902     }
1903
1904     OptionWithUnsignedIntegerSelectorFieldClass::Shared
1905     createOptionWithUnsignedIntegerSelectorFieldClass(
1906         const FieldClass optionalFieldClass, const IntegerFieldClass selectorFieldClass,
1907         const ConstUnsignedIntegerRangeSet ranges) const
1908     {
1909         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1910
1911         const auto libObjPtr = bt_field_class_option_with_selector_field_integer_unsigned_create(
1912             this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1913             ranges.libObjPtr());
1914
1915         internal::validateCreatedObjPtr(libObjPtr);
1916         return OptionWithUnsignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1917     }
1918
1919     OptionWithSignedIntegerSelectorFieldClass::Shared
1920     createOptionWithSignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
1921                                                     const IntegerFieldClass selectorFieldClass,
1922                                                     const ConstSignedIntegerRangeSet ranges) const
1923     {
1924         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1925
1926         const auto libObjPtr = bt_field_class_option_with_selector_field_integer_signed_create(
1927             this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1928             ranges.libObjPtr());
1929
1930         internal::validateCreatedObjPtr(libObjPtr);
1931         return OptionWithSignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1932     }
1933
1934     VariantWithoutSelectorFieldClass::Shared createVariantFieldClass() const
1935     {
1936         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1937
1938         const auto libObjPtr = bt_field_class_variant_create(this->libObjPtr(), nullptr);
1939
1940         internal::validateCreatedObjPtr(libObjPtr);
1941         return VariantWithoutSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1942     }
1943
1944     VariantWithUnsignedIntegerSelectorFieldClass::Shared
1945     createVariantWithUnsignedIntegerSelectorFieldClass(
1946         const IntegerFieldClass selectorFieldClass) const
1947     {
1948         return this->_createVariantWithIntegerSelectorFieldClass<
1949             VariantWithUnsignedIntegerSelectorFieldClass>(selectorFieldClass);
1950     }
1951
1952     VariantWithSignedIntegerSelectorFieldClass::Shared
1953     createVariantWithSignedIntegerSelectorFieldClass(
1954         const IntegerFieldClass selectorFieldClass) const
1955     {
1956         return this->_createVariantWithIntegerSelectorFieldClass<
1957             VariantWithSignedIntegerSelectorFieldClass>(selectorFieldClass);
1958     }
1959
1960     void assignsAutomaticStreamClassId(const bool val) const noexcept
1961     {
1962         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1963
1964         bt_trace_class_set_assigns_automatic_stream_class_id(this->libObjPtr(),
1965                                                              static_cast<bt_bool>(val));
1966     }
1967
1968     bool assignsAutomaticStreamClassId() const noexcept
1969     {
1970         return static_cast<bool>(
1971             bt_trace_class_assigns_automatic_stream_class_id(this->libObjPtr()));
1972     }
1973
1974     std::uint64_t length() const noexcept
1975     {
1976         return bt_trace_class_get_stream_class_count(this->libObjPtr());
1977     }
1978
1979     _StreamClass operator[](const std::uint64_t index) const noexcept
1980     {
1981         return _StreamClass {_Spec::streamClassByIndex(this->libObjPtr(), index)};
1982     }
1983
1984     bt2s::optional<_StreamClass> streamClassById(const std::uint64_t id) const noexcept
1985     {
1986         const auto libObjPtr = _Spec::streamClassById(this->libObjPtr(), id);
1987
1988         if (libObjPtr) {
1989             return _StreamClass {libObjPtr};
1990         }
1991
1992         return bt2s::nullopt;
1993     }
1994
1995     template <typename LibValT>
1996     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1997     {
1998         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1999
2000         bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
2001     }
2002
2003     UserAttributes userAttributes() const noexcept
2004     {
2005         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
2006     }
2007
2008     Shared shared() const noexcept
2009     {
2010         return Shared::createWithRef(*this);
2011     }
2012
2013 private:
2014     template <typename ObjT>
2015     typename ObjT::Shared
2016     _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass) const
2017     {
2018         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
2019
2020         const auto libObjPtr =
2021             bt_field_class_variant_create(this->libObjPtr(), selectorFieldClass.libObjPtr());
2022
2023         internal::validateCreatedObjPtr(libObjPtr);
2024         return ObjT::Shared::createWithoutRef(libObjPtr);
2025     }
2026 };
2027
2028 using TraceClass = CommonTraceClass<bt_trace_class>;
2029 using ConstTraceClass = CommonTraceClass<const bt_trace_class>;
2030
2031 namespace internal {
2032
2033 struct TraceClassTypeDescr
2034 {
2035     using Const = ConstTraceClass;
2036     using NonConst = TraceClass;
2037 };
2038
2039 template <>
2040 struct TypeDescr<TraceClass> : public TraceClassTypeDescr
2041 {
2042 };
2043
2044 template <>
2045 struct TypeDescr<ConstTraceClass> : public TraceClassTypeDescr
2046 {
2047 };
2048
2049 } /* namespace internal */
2050
2051 template <typename LibObjT>
2052 typename CommonStreamClass<LibObjT>::_TraceClass
2053 CommonStreamClass<LibObjT>::traceClass() const noexcept
2054 {
2055     return _TraceClass {_Spec::traceClass(this->libObjPtr())};
2056 }
2057
2058 template <typename LibObjT>
2059 typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() const noexcept
2060 {
2061     return Class {_Spec::cls(this->libObjPtr())};
2062 }
2063
2064 } /* namespace bt2 */
2065
2066 #endif /* BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP */