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