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/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 typename BorrowedObject<LibObjT>::_LibObjPtr;
 134     using _Spec = internal::CommonEventSpec<LibObjT>;
 135     using _Packet = internal::DepPacket<LibObjT>;
 136     using _Stream = internal::DepStream<LibObjT>;
 137     using _StructureField = internal::DepStructField<LibObjT>;
 138
 139 public:
 140     using Class = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
 141                                     CommonEventClass<const bt_event_class>>;
 142
 143     explicit CommonEvent(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 144     {
 145     }
 146
 147     template <typename OtherLibObjT>
 148     CommonEvent(const CommonEvent<OtherLibObjT> event) noexcept : _ThisBorrowedObject {event}
 149     {
 150     }
 151
 152     template <typename OtherLibObjT>
 153     CommonEvent<LibObjT> operator=(const CommonEvent<OtherLibObjT> event) noexcept
 154     {
 155         _ThisBorrowedObject::operator=(event);
 156         return *this;
 157     }
 158
 159     CommonEvent<const bt_event> asConst() const noexcept
 160     {
 161         return CommonEvent<const bt_event> {*this};
 162     }
 163
 164     Class cls() const noexcept;
 165     _Stream stream() const noexcept;
 166     nonstd::optional<_Packet> packet() const noexcept;
 167
 168     nonstd::optional<_StructureField> payloadField() const noexcept
 169     {
 170         const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
 171
 172         if (libObjPtr) {
 173             return _StructureField {libObjPtr};
 174         }
 175
 176         return nonstd::nullopt;
 177     }
 178
 179     nonstd::optional<_StructureField> specificContextField() const noexcept
 180     {
 181         const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
 182
 183         if (libObjPtr) {
 184             return _StructureField {libObjPtr};
 185         }
 186
 187         return nonstd::nullopt;
 188     }
 189
 190     nonstd::optional<_StructureField> commonContextField() const noexcept
 191     {
 192         const auto libObjPtr = _Spec::commonContextField(this->libObjPtr());
 193
 194         if (libObjPtr) {
 195             return _StructureField {libObjPtr};
 196         }
 197
 198         return nonstd::nullopt;
 199     }
 200 };
 201
 202 using Event = CommonEvent<bt_event>;
 203 using ConstEvent = CommonEvent<const bt_event>;
 204
 205 namespace internal {
 206
 207 struct EventTypeDescr
 208 {
 209     using Const = ConstEvent;
 210     using NonConst = Event;
 211 };
 212
 213 template <>
 214 struct TypeDescr<Event> : public EventTypeDescr
 215 {
 216 };
 217
 218 template <>
 219 struct TypeDescr<ConstEvent> : public EventTypeDescr
 220 {
 221 };
 222
 223 struct PacketRefFuncs final
 224 {
 225     static void get(const bt_packet * const libObjPtr) noexcept
 226     {
 227         bt_packet_get_ref(libObjPtr);
 228     }
 229
 230     static void put(const bt_packet * const libObjPtr) noexcept
 231     {
 232         bt_packet_put_ref(libObjPtr);
 233     }
 234 };
 235
 236 template <typename LibObjT>
 237 struct CommonPacketSpec;
 238
 239 /* Functions specific to mutable packets */
 240 template <>
 241 struct CommonPacketSpec<bt_packet> final
 242 {
 243     static bt_stream *stream(bt_packet * const libObjPtr) noexcept
 244     {
 245         return bt_packet_borrow_stream(libObjPtr);
 246     }
 247
 248     static bt_field *contextField(bt_packet * const libObjPtr) noexcept
 249     {
 250         return bt_packet_borrow_context_field(libObjPtr);
 251     }
 252 };
 253
 254 /* Functions specific to constant packets */
 255 template <>
 256 struct CommonPacketSpec<const bt_packet> final
 257 {
 258     static const bt_stream *stream(const bt_packet * const libObjPtr) noexcept
 259     {
 260         return bt_packet_borrow_stream_const(libObjPtr);
 261     }
 262
 263     static const bt_field *contextField(const bt_packet * const libObjPtr) noexcept
 264     {
 265         return bt_packet_borrow_context_field_const(libObjPtr);
 266     }
 267 };
 268
 269 } /* namespace internal */
 270
 271 template <typename LibObjT>
 272 class CommonPacket final : public BorrowedObject<LibObjT>
 273 {
 274 private:
 275     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 276     using typename BorrowedObject<LibObjT>::_LibObjPtr;
 277     using _Spec = internal::CommonPacketSpec<LibObjT>;
 278     using _Stream = internal::DepStream<LibObjT>;
 279     using _StructureField = internal::DepStructField<LibObjT>;
 280
 281 public:
 282     using Shared = SharedObject<CommonPacket, LibObjT, internal::PacketRefFuncs>;
 283
 284     explicit CommonPacket(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 285     {
 286     }
 287
 288     template <typename OtherLibObjT>
 289     CommonPacket(const CommonPacket<OtherLibObjT> packet) noexcept : _ThisBorrowedObject {packet}
 290     {
 291     }
 292
 293     template <typename OtherLibObjT>
 294     CommonPacket operator=(const CommonPacket<OtherLibObjT> packet) noexcept
 295     {
 296         _ThisBorrowedObject::operator=(packet);
 297         return *this;
 298     }
 299
 300     CommonPacket<const bt_packet> asConst() const noexcept
 301     {
 302         return CommonPacket<const bt_packet> {*this};
 303     }
 304
 305     _Stream stream() const noexcept;
 306
 307     nonstd::optional<_StructureField> contextField() const noexcept
 308     {
 309         const auto libObjPtr = _Spec::contextField(this->libObjPtr());
 310
 311         if (libObjPtr) {
 312             return _StructureField {libObjPtr};
 313         }
 314
 315         return nonstd::nullopt;
 316     }
 317
 318     Shared shared() const noexcept
 319     {
 320         return Shared::createWithRef(*this);
 321     }
 322 };
 323
 324 using Packet = CommonPacket<bt_packet>;
 325 using ConstPacket = CommonPacket<const bt_packet>;
 326
 327 namespace internal {
 328
 329 struct PacketTypeDescr
 330 {
 331     using Const = ConstPacket;
 332     using NonConst = Packet;
 333 };
 334
 335 template <>
 336 struct TypeDescr<Packet> : public PacketTypeDescr
 337 {
 338 };
 339
 340 template <>
 341 struct TypeDescr<ConstPacket> : public PacketTypeDescr
 342 {
 343 };
 344
 345 } /* namespace internal */
 346
 347 template <typename LibObjT>
 348 nonstd::optional<typename CommonEvent<LibObjT>::_Packet>
 349 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 nonstd::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 typename BorrowedObject<LibObjT>::_LibObjPtr;
 426     using _Spec = internal::CommonStreamSpec<LibObjT>;
 427     using _Trace = internal::DepType<LibObjT, CommonTrace<bt_trace>, CommonTrace<const bt_trace>>;
 428
 429 public:
 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 typename BorrowedObject<LibObjT>::_LibObjPtr;
 628     using _Spec = internal::CommonTraceSpec<LibObjT>;
 629     using _Stream = internal::DepStream<LibObjT>;
 630
 631 public:
 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     nonstd::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 nonstd::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     nonstd::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 nonstd::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     nonstd::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 nonstd::nullopt;
 792     }
 793
 794     nonstd::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 typename BorrowedObject<LibObjT>::_LibObjPtr;
 927     using _Spec = internal::CommonEventClassSpec<LibObjT>;
 928     using _StructureFieldClass = internal::DepStructFc<LibObjT>;
 929
 930     using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
 931                                            CommonStreamClass<const bt_stream_class>>;
 932
 933 public:
 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     nonstd::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 nonstd::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     nonstd::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 nonstd::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     nonstd::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 nonstd::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 typename BorrowedObject<LibObjT>::_LibObjPtr;
1253     using _Spec = internal::CommonStreamClassSpec<LibObjT>;
1254     using _StructureFieldClass = internal::DepStructFc<LibObjT>;
1255
1256     using _TraceClass = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
1257                                           CommonTraceClass<const bt_trace_class>>;
1258
1259     using _EventClass = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
1260                                           CommonEventClass<const bt_event_class>>;
1261
1262     using _ClockClass = internal::DepType<LibObjT, ClockClass, ConstClockClass>;
1263
1264 public:
1265     using Shared = SharedObject<CommonStreamClass, LibObjT, internal::StreamClassRefFuncs>;
1266     using UserAttributes = internal::DepUserAttrs<LibObjT>;
1267
1268     explicit CommonStreamClass(const _LibObjPtr libObjPtr) noexcept :
1269         _ThisBorrowedObject {libObjPtr}
1270     {
1271     }
1272
1273     template <typename OtherLibObjT>
1274     CommonStreamClass(const CommonStreamClass<OtherLibObjT> streamClass) noexcept :
1275         _ThisBorrowedObject {streamClass}
1276     {
1277     }
1278
1279     template <typename OtherLibObjT>
1280     CommonStreamClass operator=(const CommonStreamClass<OtherLibObjT> streamClass) noexcept
1281     {
1282         _ThisBorrowedObject::operator=(streamClass);
1283         return *this;
1284     }
1285
1286     CommonStreamClass<const bt_stream_class> asConst() const noexcept
1287     {
1288         return CommonStreamClass<const bt_stream_class> {*this};
1289     }
1290
1291     Stream::Shared instantiate(const Trace trace) const
1292     {
1293         static_assert(!std::is_const<LibObjT>::value,
1294                       "Not available with `bt2::ConstStreamClass`.");
1295
1296         const auto libObjPtr = bt_stream_create(this->libObjPtr(), trace.libObjPtr());
1297
1298         internal::validateCreatedObjPtr(libObjPtr);
1299         return Stream::Shared::createWithoutRef(libObjPtr);
1300     }
1301
1302     Stream::Shared instantiate(const Trace trace, const std::uint64_t id) const
1303     {
1304         static_assert(!std::is_const<LibObjT>::value,
1305                       "Not available with `bt2::ConstStreamClass`.");
1306
1307         const auto libObjPtr = bt_stream_create_with_id(this->libObjPtr(), trace.libObjPtr(), id);
1308
1309         internal::validateCreatedObjPtr(libObjPtr);
1310         return Stream::Shared::createWithoutRef(libObjPtr);
1311     }
1312
1313     EventClass::Shared createEventClass() const
1314     {
1315         static_assert(!std::is_const<LibObjT>::value,
1316                       "Not available with `bt2::ConstStreamClass`.");
1317
1318         const auto libObjPtr = bt_event_class_create(this->libObjPtr());
1319
1320         internal::validateCreatedObjPtr(libObjPtr);
1321         return EventClass::Shared::createWithoutRef(libObjPtr);
1322     }
1323
1324     EventClass::Shared createEventClass(const std::uint64_t id) const
1325     {
1326         static_assert(!std::is_const<LibObjT>::value,
1327                       "Not available with `bt2::ConstStreamClass`.");
1328
1329         const auto libObjPtr = bt_event_class_create_with_id(this->libObjPtr(), id);
1330
1331         internal::validateCreatedObjPtr(libObjPtr);
1332         return EventClass::Shared::createWithoutRef(libObjPtr);
1333     }
1334
1335     _TraceClass traceClass() const noexcept;
1336
1337     std::uint64_t id() const noexcept
1338     {
1339         return bt_stream_class_get_id(this->libObjPtr());
1340     }
1341
1342     void name(const char * const name) const
1343     {
1344         static_assert(!std::is_const<LibObjT>::value,
1345                       "Not available with `bt2::ConstStreamClass`.");
1346
1347         const auto status = bt_stream_class_set_name(this->libObjPtr(), name);
1348
1349         if (status == BT_STREAM_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
1350             throw MemoryError {};
1351         }
1352     }
1353
1354     void name(const std::string& name) const
1355     {
1356         this->name(name.data());
1357     }
1358
1359     const char *name() const noexcept
1360     {
1361         return bt_stream_class_get_name(this->libObjPtr());
1362     }
1363
1364     void assignsAutomaticEventClassId(const bool val) const noexcept
1365     {
1366         static_assert(!std::is_const<LibObjT>::value,
1367                       "Not available with `bt2::ConstStreamClass`.");
1368
1369         bt_stream_class_set_assigns_automatic_event_class_id(this->libObjPtr(),
1370                                                              static_cast<bt_bool>(val));
1371     }
1372
1373     bool assignsAutomaticEventClassId() const noexcept
1374     {
1375         return static_cast<bool>(
1376             bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
1377     }
1378
1379     void assignsAutomaticStreamId(const bool val) const noexcept
1380     {
1381         static_assert(!std::is_const<LibObjT>::value,
1382                       "Not available with `bt2::ConstStreamClass`.");
1383
1384         bt_stream_class_set_assigns_automatic_stream_id(this->libObjPtr(),
1385                                                         static_cast<bt_bool>(val));
1386     }
1387
1388     bool assignsAutomaticStreamId() const noexcept
1389     {
1390         return static_cast<bool>(bt_stream_class_assigns_automatic_stream_id(this->libObjPtr()));
1391     }
1392
1393     void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
1394                          const bool withEndDefaultClkSnapshot) const noexcept
1395     {
1396         static_assert(!std::is_const<LibObjT>::value,
1397                       "Not available with `bt2::ConstStreamClass`.");
1398
1399         bt_stream_class_set_supports_packets(this->libObjPtr(),
1400                                              static_cast<bt_bool>(supportsPackets),
1401                                              static_cast<bt_bool>(withBeginningDefaultClkSnapshot),
1402                                              static_cast<bt_bool>(withEndDefaultClkSnapshot));
1403     }
1404
1405     bool supportsPackets() const noexcept
1406     {
1407         return static_cast<bool>(bt_stream_class_supports_packets(this->libObjPtr()));
1408     }
1409
1410     bool packetsHaveBeginningClockSnapshot() const noexcept
1411     {
1412         return static_cast<bool>(
1413             bt_stream_class_packets_have_beginning_default_clock_snapshot(this->libObjPtr()));
1414     }
1415
1416     bool packetsHaveEndClockSnapshot() const noexcept
1417     {
1418         return static_cast<bool>(
1419             bt_stream_class_packets_have_end_default_clock_snapshot(this->libObjPtr()));
1420     }
1421
1422     void supportsDiscardedEvents(const bool supportsDiscardedEvents,
1423                                  const bool withDefaultClkSnapshots) const noexcept
1424     {
1425         static_assert(!std::is_const<LibObjT>::value,
1426                       "Not available with `bt2::ConstStreamClass`.");
1427
1428         bt_stream_class_set_supports_discarded_events(
1429             this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedEvents),
1430             static_cast<bt_bool>(withDefaultClkSnapshots));
1431     }
1432
1433     bool supportsDiscardedEvents() const noexcept
1434     {
1435         return static_cast<bool>(bt_stream_class_supports_discarded_events(this->libObjPtr()));
1436     }
1437
1438     bool discardedEventsHaveDefaultClockSnapshots() const noexcept
1439     {
1440         return static_cast<bool>(
1441             bt_stream_class_discarded_events_have_default_clock_snapshots(this->libObjPtr()));
1442     }
1443
1444     void supportsDiscardedPackets(const bool supportsDiscardedPackets,
1445                                   const bool withDefaultClkSnapshots) const noexcept
1446     {
1447         static_assert(!std::is_const<LibObjT>::value,
1448                       "Not available with `bt2::ConstStreamClass`.");
1449
1450         bt_stream_class_set_supports_discarded_packets(
1451             this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedPackets),
1452             static_cast<bt_bool>(withDefaultClkSnapshots));
1453     }
1454
1455     bool supportsDiscardedPackets() const noexcept
1456     {
1457         return static_cast<bool>(bt_stream_class_supports_discarded_packets(this->libObjPtr()));
1458     }
1459
1460     bool discardedPacketsHaveDefaultClockSnapshots() const noexcept
1461     {
1462         return static_cast<bool>(
1463             bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
1464     }
1465
1466     void defaultClockClass(const ClockClass clkCls) const
1467     {
1468         static_assert(!std::is_const<LibObjT>::value,
1469                       "Not available with `bt2::ConstStreamClass`.");
1470
1471         const auto status =
1472             bt_stream_class_set_default_clock_class(this->libObjPtr(), clkCls.libObjPtr());
1473
1474         BT_ASSERT(status == BT_STREAM_CLASS_SET_DEFAULT_CLOCK_CLASS_STATUS_OK);
1475     }
1476
1477     nonstd::optional<_ClockClass> defaultClockClass() const noexcept
1478     {
1479         const auto libObjPtr = _Spec::defaultClockClass(this->libObjPtr());
1480
1481         if (libObjPtr) {
1482             return _ClockClass {libObjPtr};
1483         }
1484
1485         return nonstd::nullopt;
1486     }
1487
1488     std::uint64_t length() const noexcept
1489     {
1490         return bt_stream_class_get_event_class_count(this->libObjPtr());
1491     }
1492
1493     _EventClass operator[](const std::uint64_t index) const noexcept
1494     {
1495         return _EventClass {_Spec::eventClassByIndex(this->libObjPtr(), index)};
1496     }
1497
1498     nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) const noexcept
1499     {
1500         const auto libObjPtr = _Spec::eventClassById(this->libObjPtr(), id);
1501
1502         if (libObjPtr) {
1503             return _EventClass {libObjPtr};
1504         }
1505
1506         return nonstd::nullopt;
1507     }
1508
1509     void packetContextFieldClass(const StructureFieldClass fc) const
1510     {
1511         static_assert(!std::is_const<LibObjT>::value,
1512                       "Not available with `bt2::ConstStreamClass`.");
1513
1514         const auto status =
1515             bt_stream_class_set_packet_context_field_class(this->libObjPtr(), fc.libObjPtr());
1516
1517         if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1518             throw MemoryError {};
1519         }
1520     }
1521
1522     nonstd::optional<_StructureFieldClass> packetContextFieldClass() const noexcept
1523     {
1524         const auto libObjPtr = _Spec::packetContextFieldClass(this->libObjPtr());
1525
1526         if (libObjPtr) {
1527             return _StructureFieldClass {libObjPtr};
1528         }
1529
1530         return nonstd::nullopt;
1531     }
1532
1533     void eventCommonContextFieldClass(const StructureFieldClass fc) const
1534     {
1535         static_assert(!std::is_const<LibObjT>::value,
1536                       "Not available with `bt2::ConstStreamClass`.");
1537
1538         const auto status =
1539             bt_stream_class_set_event_common_context_field_class(this->libObjPtr(), fc.libObjPtr());
1540
1541         if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1542             throw MemoryError {};
1543         }
1544     }
1545
1546     nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() const noexcept
1547     {
1548         const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->libObjPtr());
1549
1550         if (libObjPtr) {
1551             return _StructureFieldClass {libObjPtr};
1552         }
1553
1554         return nonstd::nullopt;
1555     }
1556
1557     template <typename LibValT>
1558     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1559     {
1560         static_assert(!std::is_const<LibObjT>::value,
1561                       "Not available with `bt2::ConstStreamClass`.");
1562
1563         bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1564     }
1565
1566     UserAttributes userAttributes() const noexcept
1567     {
1568         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1569     }
1570
1571     Shared shared() const noexcept
1572     {
1573         return Shared::createWithRef(*this);
1574     }
1575 };
1576
1577 using StreamClass = CommonStreamClass<bt_stream_class>;
1578 using ConstStreamClass = CommonStreamClass<const bt_stream_class>;
1579
1580 namespace internal {
1581
1582 struct StreamClassTypeDescr
1583 {
1584     using Const = ConstStreamClass;
1585     using NonConst = StreamClass;
1586 };
1587
1588 template <>
1589 struct TypeDescr<StreamClass> : public StreamClassTypeDescr
1590 {
1591 };
1592
1593 template <>
1594 struct TypeDescr<ConstStreamClass> : public StreamClassTypeDescr
1595 {
1596 };
1597
1598 } /* namespace internal */
1599
1600 template <typename LibObjT>
1601 typename CommonEventClass<LibObjT>::_StreamClass
1602 CommonEventClass<LibObjT>::streamClass() const noexcept
1603 {
1604     return _StreamClass {_Spec::streamClass(this->libObjPtr())};
1605 }
1606
1607 template <typename LibObjT>
1608 typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() const noexcept
1609 {
1610     return Class {_Spec::cls(this->libObjPtr())};
1611 }
1612
1613 namespace internal {
1614
1615 struct TraceClassRefFuncs final
1616 {
1617     static void get(const bt_trace_class * const libObjPtr) noexcept
1618     {
1619         bt_trace_class_get_ref(libObjPtr);
1620     }
1621
1622     static void put(const bt_trace_class * const libObjPtr) noexcept
1623     {
1624         bt_trace_class_put_ref(libObjPtr);
1625     }
1626 };
1627
1628 template <typename LibObjT>
1629 struct CommonTraceClassSpec;
1630
1631 /* Functions specific to mutable stream classes */
1632 template <>
1633 struct CommonTraceClassSpec<bt_trace_class> final
1634 {
1635     static bt_stream_class *streamClassByIndex(bt_trace_class * const libObjPtr,
1636                                                const std::uint64_t index) noexcept
1637     {
1638         return bt_trace_class_borrow_stream_class_by_index(libObjPtr, index);
1639     }
1640
1641     static bt_stream_class *streamClassById(bt_trace_class * const libObjPtr,
1642                                             const std::uint64_t id) noexcept
1643     {
1644         return bt_trace_class_borrow_stream_class_by_id(libObjPtr, id);
1645     }
1646
1647     static bt_value *userAttributes(bt_trace_class * const libObjPtr) noexcept
1648     {
1649         return bt_trace_class_borrow_user_attributes(libObjPtr);
1650     }
1651 };
1652
1653 /* Functions specific to constant stream classes */
1654 template <>
1655 struct CommonTraceClassSpec<const bt_trace_class> final
1656 {
1657     static const bt_stream_class *streamClassByIndex(const bt_trace_class * const libObjPtr,
1658                                                      const std::uint64_t index) noexcept
1659     {
1660         return bt_trace_class_borrow_stream_class_by_index_const(libObjPtr, index);
1661     }
1662
1663     static const bt_stream_class *streamClassById(const bt_trace_class * const libObjPtr,
1664                                                   const std::uint64_t id) noexcept
1665     {
1666         return bt_trace_class_borrow_stream_class_by_id_const(libObjPtr, id);
1667     }
1668
1669     static const bt_value *userAttributes(const bt_trace_class * const libObjPtr) noexcept
1670     {
1671         return bt_trace_class_borrow_user_attributes_const(libObjPtr);
1672     }
1673 };
1674
1675 } /* namespace internal */
1676
1677 template <typename LibObjT>
1678 class CommonTraceClass final : public BorrowedObject<LibObjT>
1679 {
1680 private:
1681     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1682     using typename BorrowedObject<LibObjT>::_LibObjPtr;
1683     using _Spec = internal::CommonTraceClassSpec<LibObjT>;
1684
1685     using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
1686                                            CommonStreamClass<const bt_stream_class>>;
1687
1688 public:
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     nonstd::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 nonstd::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 */