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

   1 /*
   2  * Copyright (c) 2020-2021 Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * SPDX-License-Identifier: MIT
   5  */
   6
   7 #ifndef BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP
   9
  10 #include <cstdint>
  11 #include <type_traits>
  12
  13 #include <babeltrace2/babeltrace.h>
  14
  15 #include "cpp-common/bt2s/optional.hpp"
  16
  17 #include "borrowed-object.hpp"
  18 #include "clock-class.hpp"
  19 #include "field-class.hpp"
  20 #include "field.hpp"
  21 #include "internal/utils.hpp"
  22 #include "optional-borrowed-object.hpp"
  23 #include "shared-object.hpp"
  24 #include "value.hpp"
  25
  26 namespace bt2 {
  27
  28 template <typename LibObjT>
  29 class CommonEvent;
  30
  31 template <typename LibObjT>
  32 class CommonPacket;
  33
  34 template <typename LibObjT>
  35 class CommonStream;
  36
  37 template <typename LibObjT>
  38 class CommonTrace;
  39
  40 template <typename LibObjT>
  41 class CommonEventClass;
  42
  43 template <typename LibObjT>
  44 class CommonStreamClass;
  45
  46 template <typename LibObjT>
  47 class CommonTraceClass;
  48
  49 namespace internal {
  50
  51 template <typename LibObjT>
  52 struct CommonEventSpec;
  53
  54 /* Functions specific to mutable events */
  55 template <>
  56 struct CommonEventSpec<bt_event> final
  57 {
  58     static bt_event_class *cls(bt_event * const libObjPtr) noexcept
  59     {
  60         return bt_event_borrow_class(libObjPtr);
  61     }
  62
  63     static bt_stream *stream(bt_event * const libObjPtr) noexcept
  64     {
  65         return bt_event_borrow_stream(libObjPtr);
  66     }
  67
  68     static bt_packet *packet(bt_event * const libObjPtr) noexcept
  69     {
  70         return bt_event_borrow_packet(libObjPtr);
  71     }
  72
  73     static bt_field *payloadField(bt_event * const libObjPtr) noexcept
  74     {
  75         return bt_event_borrow_payload_field(libObjPtr);
  76     }
  77
  78     static bt_field *specificContextField(bt_event * const libObjPtr) noexcept
  79     {
  80         return bt_event_borrow_specific_context_field(libObjPtr);
  81     }
  82
  83     static bt_field *commonContextField(bt_event * const libObjPtr) noexcept
  84     {
  85         return bt_event_borrow_common_context_field(libObjPtr);
  86     }
  87 };
  88
  89 /* Functions specific to constant events */
  90 template <>
  91 struct CommonEventSpec<const bt_event> final
  92 {
  93     static const bt_event_class *cls(const bt_event * const libObjPtr) noexcept
  94     {
  95         return bt_event_borrow_class_const(libObjPtr);
  96     }
  97
  98     static const bt_stream *stream(const bt_event * const libObjPtr) noexcept
  99     {
 100         return bt_event_borrow_stream_const(libObjPtr);
 101     }
 102
 103     static const bt_packet *packet(const bt_event * const libObjPtr) noexcept
 104     {
 105         return bt_event_borrow_packet_const(libObjPtr);
 106     }
 107
 108     static const bt_field *payloadField(const bt_event * const libObjPtr) noexcept
 109     {
 110         return bt_event_borrow_payload_field_const(libObjPtr);
 111     }
 112
 113     static const bt_field *specificContextField(const bt_event * const libObjPtr) noexcept
 114     {
 115         return bt_event_borrow_specific_context_field_const(libObjPtr);
 116     }
 117
 118     static const bt_field *commonContextField(const bt_event * const libObjPtr) noexcept
 119     {
 120         return bt_event_borrow_common_context_field_const(libObjPtr);
 121     }
 122 };
 123
 124 template <typename LibObjT>
 125 using DepStructField = DepType<LibObjT, StructureField, ConstStructureField>;
 126
 127 } /* namespace internal */
 128
 129 template <typename LibObjT>
 130 class CommonEvent final : public BorrowedObject<LibObjT>
 131 {
 132 private:
 133     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 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 typename BorrowedObject<LibObjT>::LibObjPtr;
 141
 142     using Class = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
 143                                     CommonEventClass<const bt_event_class>>;
 144
 145     explicit CommonEvent(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 146     {
 147     }
 148
 149     template <typename OtherLibObjT>
 150     CommonEvent(const CommonEvent<OtherLibObjT> event) noexcept : _ThisBorrowedObject {event}
 151     {
 152     }
 153
 154     template <typename OtherLibObjT>
 155     CommonEvent<LibObjT> operator=(const CommonEvent<OtherLibObjT> event) noexcept
 156     {
 157         _ThisBorrowedObject::operator=(event);
 158         return *this;
 159     }
 160
 161     CommonEvent<const bt_event> asConst() const noexcept
 162     {
 163         return CommonEvent<const bt_event> {*this};
 164     }
 165
 166     Class cls() const noexcept;
 167     _Stream stream() const noexcept;
 168     OptionalBorrowedObject<_Packet> packet() const noexcept;
 169
 170     OptionalBorrowedObject<_StructureField> payloadField() const noexcept
 171     {
 172         return _Spec::payloadField(this->libObjPtr());
 173     }
 174
 175     OptionalBorrowedObject<_StructureField> specificContextField() const noexcept
 176     {
 177         return _Spec::specificContextField(this->libObjPtr());
 178     }
 179
 180     OptionalBorrowedObject<_StructureField> commonContextField() const noexcept
 181     {
 182         return _Spec::commonContextField(this->libObjPtr());
 183     }
 184 };
 185
 186 using Event = CommonEvent<bt_event>;
 187 using ConstEvent = CommonEvent<const bt_event>;
 188
 189 namespace internal {
 190
 191 struct EventTypeDescr
 192 {
 193     using Const = ConstEvent;
 194     using NonConst = Event;
 195 };
 196
 197 template <>
 198 struct TypeDescr<Event> : public EventTypeDescr
 199 {
 200 };
 201
 202 template <>
 203 struct TypeDescr<ConstEvent> : public EventTypeDescr
 204 {
 205 };
 206
 207 struct PacketRefFuncs final
 208 {
 209     static void get(const bt_packet * const libObjPtr) noexcept
 210     {
 211         bt_packet_get_ref(libObjPtr);
 212     }
 213
 214     static void put(const bt_packet * const libObjPtr) noexcept
 215     {
 216         bt_packet_put_ref(libObjPtr);
 217     }
 218 };
 219
 220 template <typename LibObjT>
 221 struct CommonPacketSpec;
 222
 223 /* Functions specific to mutable packets */
 224 template <>
 225 struct CommonPacketSpec<bt_packet> final
 226 {
 227     static bt_stream *stream(bt_packet * const libObjPtr) noexcept
 228     {
 229         return bt_packet_borrow_stream(libObjPtr);
 230     }
 231
 232     static bt_field *contextField(bt_packet * const libObjPtr) noexcept
 233     {
 234         return bt_packet_borrow_context_field(libObjPtr);
 235     }
 236 };
 237
 238 /* Functions specific to constant packets */
 239 template <>
 240 struct CommonPacketSpec<const bt_packet> final
 241 {
 242     static const bt_stream *stream(const bt_packet * const libObjPtr) noexcept
 243     {
 244         return bt_packet_borrow_stream_const(libObjPtr);
 245     }
 246
 247     static const bt_field *contextField(const bt_packet * const libObjPtr) noexcept
 248     {
 249         return bt_packet_borrow_context_field_const(libObjPtr);
 250     }
 251 };
 252
 253 } /* namespace internal */
 254
 255 template <typename LibObjT>
 256 class CommonPacket final : public BorrowedObject<LibObjT>
 257 {
 258 private:
 259     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 260     using _Spec = internal::CommonPacketSpec<LibObjT>;
 261     using _Stream = internal::DepStream<LibObjT>;
 262     using _StructureField = internal::DepStructField<LibObjT>;
 263
 264 public:
 265     using typename BorrowedObject<LibObjT>::LibObjPtr;
 266     using Shared = SharedObject<CommonPacket, LibObjT, internal::PacketRefFuncs>;
 267
 268     explicit CommonPacket(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 269     {
 270     }
 271
 272     template <typename OtherLibObjT>
 273     CommonPacket(const CommonPacket<OtherLibObjT> packet) noexcept : _ThisBorrowedObject {packet}
 274     {
 275     }
 276
 277     template <typename OtherLibObjT>
 278     CommonPacket operator=(const CommonPacket<OtherLibObjT> packet) noexcept
 279     {
 280         _ThisBorrowedObject::operator=(packet);
 281         return *this;
 282     }
 283
 284     CommonPacket<const bt_packet> asConst() const noexcept
 285     {
 286         return CommonPacket<const bt_packet> {*this};
 287     }
 288
 289     _Stream stream() const noexcept;
 290
 291     OptionalBorrowedObject<_StructureField> contextField() const noexcept
 292     {
 293         return _Spec::contextField(this->libObjPtr());
 294     }
 295
 296     Shared shared() const noexcept
 297     {
 298         return Shared::createWithRef(*this);
 299     }
 300 };
 301
 302 using Packet = CommonPacket<bt_packet>;
 303 using ConstPacket = CommonPacket<const bt_packet>;
 304
 305 namespace internal {
 306
 307 struct PacketTypeDescr
 308 {
 309     using Const = ConstPacket;
 310     using NonConst = Packet;
 311 };
 312
 313 template <>
 314 struct TypeDescr<Packet> : public PacketTypeDescr
 315 {
 316 };
 317
 318 template <>
 319 struct TypeDescr<ConstPacket> : public PacketTypeDescr
 320 {
 321 };
 322
 323 } /* namespace internal */
 324
 325 template <typename LibObjT>
 326 OptionalBorrowedObject<typename CommonEvent<LibObjT>::_Packet>
 327 CommonEvent<LibObjT>::packet() const noexcept
 328 {
 329     return _Spec::packet(this->libObjPtr());
 330 }
 331
 332 namespace internal {
 333
 334 struct StreamRefFuncs final
 335 {
 336     static void get(const bt_stream * const libObjPtr) noexcept
 337     {
 338         bt_stream_get_ref(libObjPtr);
 339     }
 340
 341     static void put(const bt_stream * const libObjPtr) noexcept
 342     {
 343         bt_stream_put_ref(libObjPtr);
 344     }
 345 };
 346
 347 template <typename LibObjT>
 348 struct CommonStreamSpec;
 349
 350 /* Functions specific to mutable streams */
 351 template <>
 352 struct CommonStreamSpec<bt_stream> final
 353 {
 354     static bt_stream_class *cls(bt_stream * const libObjPtr) noexcept
 355     {
 356         return bt_stream_borrow_class(libObjPtr);
 357     }
 358
 359     static bt_trace *trace(bt_stream * const libObjPtr) noexcept
 360     {
 361         return bt_stream_borrow_trace(libObjPtr);
 362     }
 363
 364     static bt_value *userAttributes(bt_stream * const libObjPtr) noexcept
 365     {
 366         return bt_stream_borrow_user_attributes(libObjPtr);
 367     }
 368 };
 369
 370 /* Functions specific to constant streams */
 371 template <>
 372 struct CommonStreamSpec<const bt_stream> final
 373 {
 374     static const bt_stream_class *cls(const bt_stream * const libObjPtr) noexcept
 375     {
 376         return bt_stream_borrow_class_const(libObjPtr);
 377     }
 378
 379     static const bt_trace *trace(const bt_stream * const libObjPtr) noexcept
 380     {
 381         return bt_stream_borrow_trace_const(libObjPtr);
 382     }
 383
 384     static const bt_value *userAttributes(const bt_stream * const libObjPtr) noexcept
 385     {
 386         return bt_stream_borrow_user_attributes_const(libObjPtr);
 387     }
 388 };
 389
 390 } /* namespace internal */
 391
 392 template <typename LibObjT>
 393 class CommonStream final : public BorrowedObject<LibObjT>
 394 {
 395 private:
 396     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 397     using _Spec = internal::CommonStreamSpec<LibObjT>;
 398     using _Trace = internal::DepType<LibObjT, CommonTrace<bt_trace>, CommonTrace<const bt_trace>>;
 399
 400 public:
 401     using typename BorrowedObject<LibObjT>::LibObjPtr;
 402     using Shared = SharedObject<CommonStream, LibObjT, internal::StreamRefFuncs>;
 403     using UserAttributes = internal::DepUserAttrs<LibObjT>;
 404
 405     using Class = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
 406                                     CommonStreamClass<const bt_stream_class>>;
 407
 408     explicit CommonStream(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 409     {
 410     }
 411
 412     template <typename OtherLibObjT>
 413     CommonStream(const CommonStream<OtherLibObjT> stream) noexcept : _ThisBorrowedObject {stream}
 414     {
 415     }
 416
 417     template <typename OtherLibObjT>
 418     CommonStream operator=(const CommonStream<OtherLibObjT> stream) noexcept
 419     {
 420         _ThisBorrowedObject::operator=(stream);
 421         return *this;
 422     }
 423
 424     CommonStream<const bt_stream> asConst() const noexcept
 425     {
 426         return CommonStream<const bt_stream> {*this};
 427     }
 428
 429     Packet::Shared createPacket() const
 430     {
 431         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
 432
 433         const auto libObjPtr = bt_packet_create(this->libObjPtr());
 434
 435         internal::validateCreatedObjPtr(libObjPtr);
 436         return Packet::Shared::createWithoutRef(libObjPtr);
 437     }
 438
 439     Class cls() const noexcept;
 440     _Trace trace() const noexcept;
 441
 442     std::uint64_t id() const noexcept
 443     {
 444         return bt_stream_get_id(this->libObjPtr());
 445     }
 446
 447     void name(const char * const name) const
 448     {
 449         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
 450
 451         const auto status = bt_stream_set_name(this->libObjPtr(), name);
 452
 453         if (status == BT_STREAM_SET_NAME_STATUS_MEMORY_ERROR) {
 454             throw MemoryError {};
 455         }
 456     }
 457
 458     void name(const std::string& name) const
 459     {
 460         this->name(name.data());
 461     }
 462
 463     const char *name() const noexcept
 464     {
 465         return bt_stream_get_name(this->libObjPtr());
 466     }
 467
 468     template <typename LibValT>
 469     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
 470     {
 471         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstStream`.");
 472
 473         bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
 474     }
 475
 476     UserAttributes userAttributes() const noexcept
 477     {
 478         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
 479     }
 480
 481     Shared shared() const noexcept
 482     {
 483         return Shared::createWithRef(*this);
 484     }
 485 };
 486
 487 using Stream = CommonStream<bt_stream>;
 488 using ConstStream = CommonStream<const bt_stream>;
 489
 490 namespace internal {
 491
 492 struct StreamTypeDescr
 493 {
 494     using Const = ConstStream;
 495     using NonConst = Stream;
 496 };
 497
 498 template <>
 499 struct TypeDescr<Stream> : public StreamTypeDescr
 500 {
 501 };
 502
 503 template <>
 504 struct TypeDescr<ConstStream> : public StreamTypeDescr
 505 {
 506 };
 507
 508 } /* namespace internal */
 509
 510 template <typename LibObjT>
 511 typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() const noexcept
 512 {
 513     return _Stream {_Spec::stream(this->libObjPtr())};
 514 }
 515
 516 template <typename LibObjT>
 517 typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() const noexcept
 518 {
 519     return _Stream {_Spec::stream(this->libObjPtr())};
 520 }
 521
 522 namespace internal {
 523
 524 struct TraceRefFuncs final
 525 {
 526     static void get(const bt_trace * const libObjPtr) noexcept
 527     {
 528         bt_trace_get_ref(libObjPtr);
 529     }
 530
 531     static void put(const bt_trace * const libObjPtr) noexcept
 532     {
 533         bt_trace_put_ref(libObjPtr);
 534     }
 535 };
 536
 537 template <typename LibObjT>
 538 struct CommonTraceSpec;
 539
 540 /* Functions specific to mutable traces */
 541 template <>
 542 struct CommonTraceSpec<bt_trace> final
 543 {
 544     static bt_trace_class *cls(bt_trace * const libObjPtr) noexcept
 545     {
 546         return bt_trace_borrow_class(libObjPtr);
 547     }
 548
 549     static bt_stream *streamByIndex(bt_trace * const libObjPtr, const std::uint64_t index) noexcept
 550     {
 551         return bt_trace_borrow_stream_by_index(libObjPtr, index);
 552     }
 553
 554     static bt_stream *streamById(bt_trace * const libObjPtr, const std::uint64_t id) noexcept
 555     {
 556         return bt_trace_borrow_stream_by_id(libObjPtr, id);
 557     }
 558
 559     static bt_value *userAttributes(bt_trace * const libObjPtr) noexcept
 560     {
 561         return bt_trace_borrow_user_attributes(libObjPtr);
 562     }
 563 };
 564
 565 /* Functions specific to constant traces */
 566 template <>
 567 struct CommonTraceSpec<const bt_trace> final
 568 {
 569     static const bt_trace_class *cls(const bt_trace * const libObjPtr) noexcept
 570     {
 571         return bt_trace_borrow_class_const(libObjPtr);
 572     }
 573
 574     static const bt_stream *streamByIndex(const bt_trace * const libObjPtr,
 575                                           const std::uint64_t index) noexcept
 576     {
 577         return bt_trace_borrow_stream_by_index_const(libObjPtr, index);
 578     }
 579
 580     static const bt_stream *streamById(const bt_trace * const libObjPtr,
 581                                        const std::uint64_t id) noexcept
 582     {
 583         return bt_trace_borrow_stream_by_id_const(libObjPtr, id);
 584     }
 585
 586     static const bt_value *userAttributes(const bt_trace * const libObjPtr) noexcept
 587     {
 588         return bt_trace_borrow_user_attributes_const(libObjPtr);
 589     }
 590 };
 591
 592 } /* namespace internal */
 593
 594 template <typename LibObjT>
 595 class CommonTrace final : public BorrowedObject<LibObjT>
 596 {
 597 private:
 598     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 599     using _Spec = internal::CommonTraceSpec<LibObjT>;
 600     using _Stream = internal::DepStream<LibObjT>;
 601
 602 public:
 603     using typename BorrowedObject<LibObjT>::LibObjPtr;
 604     using Shared = SharedObject<CommonTrace, LibObjT, internal::TraceRefFuncs>;
 605     using UserAttributes = internal::DepUserAttrs<LibObjT>;
 606
 607     using Class = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
 608                                     CommonTraceClass<const bt_trace_class>>;
 609
 610     struct ConstEnvironmentEntry
 611     {
 612         const char *name;
 613         ConstValue value;
 614     };
 615
 616     explicit CommonTrace(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 617     {
 618     }
 619
 620     template <typename OtherLibObjT>
 621     CommonTrace(const CommonTrace<OtherLibObjT> trace) noexcept : _ThisBorrowedObject {trace}
 622     {
 623     }
 624
 625     template <typename OtherLibObjT>
 626     CommonTrace operator=(const CommonTrace<OtherLibObjT> trace) noexcept
 627     {
 628         _ThisBorrowedObject::operator=(trace);
 629         return *this;
 630     }
 631
 632     CommonTrace<const bt_trace> asConst() const noexcept
 633     {
 634         return CommonTrace<const bt_trace> {*this};
 635     }
 636
 637     Class cls() const noexcept;
 638
 639     void name(const char * const name) const
 640     {
 641         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
 642
 643         const auto status = bt_trace_set_name(this->libObjPtr(), name);
 644
 645         if (status == BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR) {
 646             throw MemoryError {};
 647         }
 648     }
 649
 650     void name(const std::string& name) const
 651     {
 652         this->name(name.data());
 653     }
 654
 655     const char *name() const noexcept
 656     {
 657         return bt_trace_get_name(this->libObjPtr());
 658     }
 659
 660     void uuid(const bt2c::UuidView& uuid) const noexcept
 661     {
 662         bt_trace_set_uuid(this->libObjPtr(), uuid.begin());
 663     }
 664
 665     bt2s::optional<bt2c::UuidView> uuid() const noexcept
 666     {
 667         const auto uuid = bt_trace_get_uuid(this->libObjPtr());
 668
 669         if (uuid) {
 670             return bt2c::UuidView {uuid};
 671         }
 672
 673         return bt2s::nullopt;
 674     }
 675
 676     std::uint64_t length() const noexcept
 677     {
 678         return bt_trace_get_stream_count(this->libObjPtr());
 679     }
 680
 681     _Stream operator[](const std::uint64_t index) const noexcept
 682     {
 683         return _Stream {_Spec::streamByIndex(this->libObjPtr(), index)};
 684     }
 685
 686     OptionalBorrowedObject<_Stream> streamById(const std::uint64_t id) const noexcept
 687     {
 688         return _Spec::streamById(this->libObjPtr(), id);
 689     }
 690
 691     void environmentEntry(const char * const name, const std::int64_t val) const
 692     {
 693         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
 694
 695         const auto status = bt_trace_set_environment_entry_integer(this->libObjPtr(), name, val);
 696
 697         if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
 698             throw MemoryError {};
 699         }
 700     }
 701
 702     void environmentEntry(const std::string& name, const std::int64_t val) const
 703     {
 704         this->environmentEntry(name.data(), val);
 705     }
 706
 707     void environmentEntry(const char * const name, const char * const val) const
 708     {
 709         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
 710
 711         const auto status = bt_trace_set_environment_entry_string(this->libObjPtr(), name, val);
 712
 713         if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
 714             throw MemoryError {};
 715         }
 716     }
 717
 718     void environmentEntry(const std::string& name, const char * const val) const
 719     {
 720         this->environmentEntry(name.data(), val);
 721     }
 722
 723     void environmentEntry(const char * const name, const std::string& val) const
 724     {
 725         this->environmentEntry(name, val.data());
 726     }
 727
 728     void environmentEntry(const std::string& name, const std::string& val) const
 729     {
 730         this->environmentEntry(name.data(), val.data());
 731     }
 732
 733     std::uint64_t environmentSize() const noexcept
 734     {
 735         return bt_trace_get_environment_entry_count(this->libObjPtr());
 736     }
 737
 738     ConstEnvironmentEntry environmentEntry(const std::uint64_t index) const noexcept
 739     {
 740         const char *name;
 741         const bt_value *libObjPtr;
 742
 743         bt_trace_borrow_environment_entry_by_index_const(this->libObjPtr(), index, &name,
 744                                                          &libObjPtr);
 745         return ConstEnvironmentEntry {name, ConstValue {libObjPtr}};
 746     }
 747
 748     OptionalBorrowedObject<ConstValue> environmentEntry(const char * const name) const noexcept
 749     {
 750         return bt_trace_borrow_environment_entry_value_by_name_const(this->libObjPtr(), name);
 751     }
 752
 753     OptionalBorrowedObject<ConstValue> environmentEntry(const std::string& name) const noexcept
 754     {
 755         return this->environmentEntry(name.data());
 756     }
 757
 758     template <typename LibValT>
 759     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
 760     {
 761         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTrace`.");
 762
 763         bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
 764     }
 765
 766     UserAttributes userAttributes() const noexcept
 767     {
 768         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
 769     }
 770
 771     Shared shared() const noexcept
 772     {
 773         return Shared::createWithRef(*this);
 774     }
 775 };
 776
 777 using Trace = CommonTrace<bt_trace>;
 778 using ConstTrace = CommonTrace<const bt_trace>;
 779
 780 namespace internal {
 781
 782 struct TraceTypeDescr
 783 {
 784     using Const = ConstTrace;
 785     using NonConst = Trace;
 786 };
 787
 788 template <>
 789 struct TypeDescr<Trace> : public TraceTypeDescr
 790 {
 791 };
 792
 793 template <>
 794 struct TypeDescr<ConstTrace> : public TraceTypeDescr
 795 {
 796 };
 797
 798 } /* namespace internal */
 799
 800 template <typename LibObjT>
 801 typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() const noexcept
 802 {
 803     return _Trace {_Spec::trace(this->libObjPtr())};
 804 }
 805
 806 namespace internal {
 807
 808 struct EventClassRefFuncs final
 809 {
 810     static void get(const bt_event_class * const libObjPtr) noexcept
 811     {
 812         bt_event_class_get_ref(libObjPtr);
 813     }
 814
 815     static void put(const bt_event_class * const libObjPtr) noexcept
 816     {
 817         bt_event_class_put_ref(libObjPtr);
 818     }
 819 };
 820
 821 template <typename LibObjT>
 822 struct CommonEventClassSpec;
 823
 824 /* Functions specific to mutable event classes */
 825 template <>
 826 struct CommonEventClassSpec<bt_event_class> final
 827 {
 828     static bt_stream_class *streamClass(bt_event_class * const libObjPtr) noexcept
 829     {
 830         return bt_event_class_borrow_stream_class(libObjPtr);
 831     }
 832
 833     static bt_field_class *payloadFieldClass(bt_event_class * const libObjPtr) noexcept
 834     {
 835         return bt_event_class_borrow_payload_field_class(libObjPtr);
 836     }
 837
 838     static bt_field_class *specificContextFieldClass(bt_event_class * const libObjPtr) noexcept
 839     {
 840         return bt_event_class_borrow_specific_context_field_class(libObjPtr);
 841     }
 842
 843     static bt_value *userAttributes(bt_event_class * const libObjPtr) noexcept
 844     {
 845         return bt_event_class_borrow_user_attributes(libObjPtr);
 846     }
 847 };
 848
 849 /* Functions specific to constant event classes */
 850 template <>
 851 struct CommonEventClassSpec<const bt_event_class> final
 852 {
 853     static const bt_stream_class *streamClass(const bt_event_class * const libObjPtr) noexcept
 854     {
 855         return bt_event_class_borrow_stream_class_const(libObjPtr);
 856     }
 857
 858     static const bt_field_class *payloadFieldClass(const bt_event_class * const libObjPtr) noexcept
 859     {
 860         return bt_event_class_borrow_payload_field_class_const(libObjPtr);
 861     }
 862
 863     static const bt_field_class *
 864     specificContextFieldClass(const bt_event_class * const libObjPtr) noexcept
 865     {
 866         return bt_event_class_borrow_specific_context_field_class_const(libObjPtr);
 867     }
 868
 869     static const bt_value *userAttributes(const bt_event_class * const libObjPtr) noexcept
 870     {
 871         return bt_event_class_borrow_user_attributes_const(libObjPtr);
 872     }
 873 };
 874
 875 template <typename LibObjT>
 876 using DepStructFc = DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
 877
 878 } /* namespace internal */
 879
 880 template <typename LibObjT>
 881 class CommonEventClass final : public BorrowedObject<LibObjT>
 882 {
 883 private:
 884     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 885     using _Spec = internal::CommonEventClassSpec<LibObjT>;
 886     using _StructureFieldClass = internal::DepStructFc<LibObjT>;
 887
 888     using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
 889                                            CommonStreamClass<const bt_stream_class>>;
 890
 891 public:
 892     using typename BorrowedObject<LibObjT>::LibObjPtr;
 893     using Shared = SharedObject<CommonEventClass, LibObjT, internal::EventClassRefFuncs>;
 894     using UserAttributes = internal::DepUserAttrs<LibObjT>;
 895
 896     enum class LogLevel
 897     {
 898         EMERGENCY = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY,
 899         ALERT = BT_EVENT_CLASS_LOG_LEVEL_ALERT,
 900         CRITICAL = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL,
 901         ERR = BT_EVENT_CLASS_LOG_LEVEL_ERROR,
 902         WARNING = BT_EVENT_CLASS_LOG_LEVEL_WARNING,
 903         NOTICE = BT_EVENT_CLASS_LOG_LEVEL_NOTICE,
 904         INFO = BT_EVENT_CLASS_LOG_LEVEL_INFO,
 905         DEBUG_SYSTEM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM,
 906         DEBUG_PROGRAM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM,
 907         DEBUG_PROC = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS,
 908         DEBUG_MODULE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE,
 909         DEBUG_UNIT = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT,
 910         DEBUG_FUNCTION = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION,
 911         DEBUG_LINE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE,
 912         DEBUG = BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
 913     };
 914
 915     explicit CommonEventClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 916     {
 917     }
 918
 919     template <typename OtherLibObjT>
 920     CommonEventClass(const CommonEventClass<OtherLibObjT> eventClass) noexcept :
 921         _ThisBorrowedObject {eventClass}
 922     {
 923     }
 924
 925     template <typename OtherLibObjT>
 926     CommonEventClass operator=(const CommonEventClass<OtherLibObjT> eventClass) noexcept
 927     {
 928         _ThisBorrowedObject::operator=(eventClass);
 929         return *this;
 930     }
 931
 932     CommonEventClass<const bt_event_class> asConst() const noexcept
 933     {
 934         return CommonEventClass<const bt_event_class> {*this};
 935     }
 936
 937     _StreamClass streamClass() const noexcept;
 938
 939     std::uint64_t id() const noexcept
 940     {
 941         return bt_event_class_get_id(this->libObjPtr());
 942     }
 943
 944     void name(const char * const name) const
 945     {
 946         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
 947
 948         const auto status = bt_event_class_set_name(this->libObjPtr(), name);
 949
 950         if (status == BT_EVENT_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
 951             throw MemoryError {};
 952         }
 953     }
 954
 955     void name(const std::string& name) const
 956     {
 957         this->name(name.data());
 958     }
 959
 960     const char *name() const noexcept
 961     {
 962         return bt_event_class_get_name(this->libObjPtr());
 963     }
 964
 965     void logLevel(const LogLevel logLevel) const noexcept
 966     {
 967         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
 968
 969         bt_event_class_set_log_level(this->libObjPtr(),
 970                                      static_cast<bt_event_class_log_level>(logLevel));
 971     }
 972
 973     bt2s::optional<LogLevel> logLevel() const noexcept
 974     {
 975         bt_event_class_log_level libLogLevel;
 976         const auto avail = bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel);
 977
 978         if (avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
 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     const char *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     const char *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 */