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
 977         if (bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel)) {
 978             return static_cast<LogLevel>(libLogLevel);
 979         }
 980
 981         return bt2s::nullopt;
 982     }
 983
 984     void emfUri(const char * const emfUri) const
 985     {
 986         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
 987
 988         const auto status = bt_event_class_set_emf_uri(this->libObjPtr(), emfUri);
 989
 990         if (status == BT_EVENT_CLASS_SET_EMF_URI_STATUS_MEMORY_ERROR) {
 991             throw MemoryError {};
 992         }
 993     }
 994
 995     void emfUri(const std::string& emfUri) const
 996     {
 997         this->emfUri(emfUri.data());
 998     }
 999
1000     const char *emfUri() const noexcept
1001     {
1002         return bt_event_class_get_emf_uri(this->libObjPtr());
1003     }
1004
1005     void payloadFieldClass(const StructureFieldClass fc) const
1006     {
1007         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1008
1009         const auto status =
1010             bt_event_class_set_payload_field_class(this->libObjPtr(), fc.libObjPtr());
1011
1012         if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1013             throw MemoryError {};
1014         }
1015     }
1016
1017     OptionalBorrowedObject<_StructureFieldClass> payloadFieldClass() const noexcept
1018     {
1019         return _Spec::payloadFieldClass(this->libObjPtr());
1020     }
1021
1022     void specificContextFieldClass(const StructureFieldClass fc) const
1023     {
1024         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1025
1026         const auto status =
1027             bt_event_class_set_specific_context_field_class(this->libObjPtr(), fc.libObjPtr());
1028
1029         if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1030             throw MemoryError {};
1031         }
1032     }
1033
1034     OptionalBorrowedObject<_StructureFieldClass> specificContextFieldClass() const noexcept
1035     {
1036         return _Spec::specificContextFieldClass(this->libObjPtr());
1037     }
1038
1039     template <typename LibValT>
1040     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1041     {
1042         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstEventClass`.");
1043
1044         bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1045     }
1046
1047     UserAttributes userAttributes() const noexcept
1048     {
1049         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1050     }
1051
1052     Shared shared() const noexcept
1053     {
1054         return Shared::createWithRef(*this);
1055     }
1056 };
1057
1058 using EventClass = CommonEventClass<bt_event_class>;
1059 using ConstEventClass = CommonEventClass<const bt_event_class>;
1060
1061 namespace internal {
1062
1063 struct EventClassTypeDescr
1064 {
1065     using Const = ConstEventClass;
1066     using NonConst = EventClass;
1067 };
1068
1069 template <>
1070 struct TypeDescr<EventClass> : public EventClassTypeDescr
1071 {
1072 };
1073
1074 template <>
1075 struct TypeDescr<ConstEventClass> : public EventClassTypeDescr
1076 {
1077 };
1078
1079 } /* namespace internal */
1080
1081 template <typename LibObjT>
1082 typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() const noexcept
1083 {
1084     return Class {_Spec::cls(this->libObjPtr())};
1085 }
1086
1087 namespace internal {
1088
1089 struct StreamClassRefFuncs final
1090 {
1091     static void get(const bt_stream_class * const libObjPtr) noexcept
1092     {
1093         bt_stream_class_get_ref(libObjPtr);
1094     }
1095
1096     static void put(const bt_stream_class * const libObjPtr) noexcept
1097     {
1098         bt_stream_class_put_ref(libObjPtr);
1099     }
1100 };
1101
1102 template <typename LibObjT>
1103 struct CommonStreamClassSpec;
1104
1105 /* Functions specific to mutable stream classes */
1106 template <>
1107 struct CommonStreamClassSpec<bt_stream_class> final
1108 {
1109     static bt_trace_class *traceClass(bt_stream_class * const libObjPtr) noexcept
1110     {
1111         return bt_stream_class_borrow_trace_class(libObjPtr);
1112     }
1113
1114     static bt_event_class *eventClassByIndex(bt_stream_class * const libObjPtr,
1115                                              const std::uint64_t index) noexcept
1116     {
1117         return bt_stream_class_borrow_event_class_by_index(libObjPtr, index);
1118     }
1119
1120     static bt_event_class *eventClassById(bt_stream_class * const libObjPtr,
1121                                           const std::uint64_t id) noexcept
1122     {
1123         return bt_stream_class_borrow_event_class_by_id(libObjPtr, id);
1124     }
1125
1126     static bt_clock_class *defaultClockClass(bt_stream_class * const libObjPtr) noexcept
1127     {
1128         return bt_stream_class_borrow_default_clock_class(libObjPtr);
1129     }
1130
1131     static bt_field_class *packetContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1132     {
1133         return bt_stream_class_borrow_packet_context_field_class(libObjPtr);
1134     }
1135
1136     static bt_field_class *eventCommonContextFieldClass(bt_stream_class * const libObjPtr) noexcept
1137     {
1138         return bt_stream_class_borrow_event_common_context_field_class(libObjPtr);
1139     }
1140
1141     static bt_value *userAttributes(bt_stream_class * const libObjPtr) noexcept
1142     {
1143         return bt_stream_class_borrow_user_attributes(libObjPtr);
1144     }
1145 };
1146
1147 /* Functions specific to constant stream classes */
1148 template <>
1149 struct CommonStreamClassSpec<const bt_stream_class> final
1150 {
1151     static const bt_trace_class *traceClass(const bt_stream_class * const libObjPtr) noexcept
1152     {
1153         return bt_stream_class_borrow_trace_class_const(libObjPtr);
1154     }
1155
1156     static const bt_event_class *eventClassByIndex(const bt_stream_class * const libObjPtr,
1157                                                    const std::uint64_t index) noexcept
1158     {
1159         return bt_stream_class_borrow_event_class_by_index_const(libObjPtr, index);
1160     }
1161
1162     static const bt_event_class *eventClassById(const bt_stream_class * const libObjPtr,
1163                                                 const std::uint64_t id) noexcept
1164     {
1165         return bt_stream_class_borrow_event_class_by_id_const(libObjPtr, id);
1166     }
1167
1168     static const bt_clock_class *defaultClockClass(const bt_stream_class * const libObjPtr) noexcept
1169     {
1170         return bt_stream_class_borrow_default_clock_class_const(libObjPtr);
1171     }
1172
1173     static const bt_field_class *
1174     packetContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1175     {
1176         return bt_stream_class_borrow_packet_context_field_class_const(libObjPtr);
1177     }
1178
1179     static const bt_field_class *
1180     eventCommonContextFieldClass(const bt_stream_class * const libObjPtr) noexcept
1181     {
1182         return bt_stream_class_borrow_event_common_context_field_class_const(libObjPtr);
1183     }
1184
1185     static const bt_value *userAttributes(const bt_stream_class * const libObjPtr) noexcept
1186     {
1187         return bt_stream_class_borrow_user_attributes_const(libObjPtr);
1188     }
1189 };
1190
1191 } /* namespace internal */
1192
1193 template <typename LibObjT>
1194 class CommonStreamClass final : public BorrowedObject<LibObjT>
1195 {
1196 private:
1197     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1198     using _Spec = internal::CommonStreamClassSpec<LibObjT>;
1199     using _StructureFieldClass = internal::DepStructFc<LibObjT>;
1200
1201     using _TraceClass = internal::DepType<LibObjT, CommonTraceClass<bt_trace_class>,
1202                                           CommonTraceClass<const bt_trace_class>>;
1203
1204     using _EventClass = internal::DepType<LibObjT, CommonEventClass<bt_event_class>,
1205                                           CommonEventClass<const bt_event_class>>;
1206
1207     using _ClockClass = internal::DepType<LibObjT, ClockClass, ConstClockClass>;
1208
1209 public:
1210     using typename BorrowedObject<LibObjT>::LibObjPtr;
1211     using Shared = SharedObject<CommonStreamClass, LibObjT, internal::StreamClassRefFuncs>;
1212     using UserAttributes = internal::DepUserAttrs<LibObjT>;
1213
1214     explicit CommonStreamClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
1215     {
1216     }
1217
1218     template <typename OtherLibObjT>
1219     CommonStreamClass(const CommonStreamClass<OtherLibObjT> streamClass) noexcept :
1220         _ThisBorrowedObject {streamClass}
1221     {
1222     }
1223
1224     template <typename OtherLibObjT>
1225     CommonStreamClass operator=(const CommonStreamClass<OtherLibObjT> streamClass) noexcept
1226     {
1227         _ThisBorrowedObject::operator=(streamClass);
1228         return *this;
1229     }
1230
1231     CommonStreamClass<const bt_stream_class> asConst() const noexcept
1232     {
1233         return CommonStreamClass<const bt_stream_class> {*this};
1234     }
1235
1236     Stream::Shared instantiate(const Trace trace) const
1237     {
1238         static_assert(!std::is_const<LibObjT>::value,
1239                       "Not available with `bt2::ConstStreamClass`.");
1240
1241         const auto libObjPtr = bt_stream_create(this->libObjPtr(), trace.libObjPtr());
1242
1243         internal::validateCreatedObjPtr(libObjPtr);
1244         return Stream::Shared::createWithoutRef(libObjPtr);
1245     }
1246
1247     Stream::Shared instantiate(const Trace trace, const std::uint64_t id) const
1248     {
1249         static_assert(!std::is_const<LibObjT>::value,
1250                       "Not available with `bt2::ConstStreamClass`.");
1251
1252         const auto libObjPtr = bt_stream_create_with_id(this->libObjPtr(), trace.libObjPtr(), id);
1253
1254         internal::validateCreatedObjPtr(libObjPtr);
1255         return Stream::Shared::createWithoutRef(libObjPtr);
1256     }
1257
1258     EventClass::Shared createEventClass() const
1259     {
1260         static_assert(!std::is_const<LibObjT>::value,
1261                       "Not available with `bt2::ConstStreamClass`.");
1262
1263         const auto libObjPtr = bt_event_class_create(this->libObjPtr());
1264
1265         internal::validateCreatedObjPtr(libObjPtr);
1266         return EventClass::Shared::createWithoutRef(libObjPtr);
1267     }
1268
1269     EventClass::Shared createEventClass(const std::uint64_t id) const
1270     {
1271         static_assert(!std::is_const<LibObjT>::value,
1272                       "Not available with `bt2::ConstStreamClass`.");
1273
1274         const auto libObjPtr = bt_event_class_create_with_id(this->libObjPtr(), id);
1275
1276         internal::validateCreatedObjPtr(libObjPtr);
1277         return EventClass::Shared::createWithoutRef(libObjPtr);
1278     }
1279
1280     _TraceClass traceClass() const noexcept;
1281
1282     std::uint64_t id() const noexcept
1283     {
1284         return bt_stream_class_get_id(this->libObjPtr());
1285     }
1286
1287     void name(const char * const name) const
1288     {
1289         static_assert(!std::is_const<LibObjT>::value,
1290                       "Not available with `bt2::ConstStreamClass`.");
1291
1292         const auto status = bt_stream_class_set_name(this->libObjPtr(), name);
1293
1294         if (status == BT_STREAM_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
1295             throw MemoryError {};
1296         }
1297     }
1298
1299     void name(const std::string& name) const
1300     {
1301         this->name(name.data());
1302     }
1303
1304     const char *name() const noexcept
1305     {
1306         return bt_stream_class_get_name(this->libObjPtr());
1307     }
1308
1309     void assignsAutomaticEventClassId(const bool val) const noexcept
1310     {
1311         static_assert(!std::is_const<LibObjT>::value,
1312                       "Not available with `bt2::ConstStreamClass`.");
1313
1314         bt_stream_class_set_assigns_automatic_event_class_id(this->libObjPtr(),
1315                                                              static_cast<bt_bool>(val));
1316     }
1317
1318     bool assignsAutomaticEventClassId() const noexcept
1319     {
1320         return static_cast<bool>(
1321             bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
1322     }
1323
1324     void assignsAutomaticStreamId(const bool val) const noexcept
1325     {
1326         static_assert(!std::is_const<LibObjT>::value,
1327                       "Not available with `bt2::ConstStreamClass`.");
1328
1329         bt_stream_class_set_assigns_automatic_stream_id(this->libObjPtr(),
1330                                                         static_cast<bt_bool>(val));
1331     }
1332
1333     bool assignsAutomaticStreamId() const noexcept
1334     {
1335         return static_cast<bool>(bt_stream_class_assigns_automatic_stream_id(this->libObjPtr()));
1336     }
1337
1338     void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
1339                          const bool withEndDefaultClkSnapshot) const noexcept
1340     {
1341         static_assert(!std::is_const<LibObjT>::value,
1342                       "Not available with `bt2::ConstStreamClass`.");
1343
1344         bt_stream_class_set_supports_packets(this->libObjPtr(),
1345                                              static_cast<bt_bool>(supportsPackets),
1346                                              static_cast<bt_bool>(withBeginningDefaultClkSnapshot),
1347                                              static_cast<bt_bool>(withEndDefaultClkSnapshot));
1348     }
1349
1350     bool supportsPackets() const noexcept
1351     {
1352         return static_cast<bool>(bt_stream_class_supports_packets(this->libObjPtr()));
1353     }
1354
1355     bool packetsHaveBeginningClockSnapshot() const noexcept
1356     {
1357         return static_cast<bool>(
1358             bt_stream_class_packets_have_beginning_default_clock_snapshot(this->libObjPtr()));
1359     }
1360
1361     bool packetsHaveEndClockSnapshot() const noexcept
1362     {
1363         return static_cast<bool>(
1364             bt_stream_class_packets_have_end_default_clock_snapshot(this->libObjPtr()));
1365     }
1366
1367     void supportsDiscardedEvents(const bool supportsDiscardedEvents,
1368                                  const bool withDefaultClkSnapshots) const noexcept
1369     {
1370         static_assert(!std::is_const<LibObjT>::value,
1371                       "Not available with `bt2::ConstStreamClass`.");
1372
1373         bt_stream_class_set_supports_discarded_events(
1374             this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedEvents),
1375             static_cast<bt_bool>(withDefaultClkSnapshots));
1376     }
1377
1378     bool supportsDiscardedEvents() const noexcept
1379     {
1380         return static_cast<bool>(bt_stream_class_supports_discarded_events(this->libObjPtr()));
1381     }
1382
1383     bool discardedEventsHaveDefaultClockSnapshots() const noexcept
1384     {
1385         return static_cast<bool>(
1386             bt_stream_class_discarded_events_have_default_clock_snapshots(this->libObjPtr()));
1387     }
1388
1389     void supportsDiscardedPackets(const bool supportsDiscardedPackets,
1390                                   const bool withDefaultClkSnapshots) const noexcept
1391     {
1392         static_assert(!std::is_const<LibObjT>::value,
1393                       "Not available with `bt2::ConstStreamClass`.");
1394
1395         bt_stream_class_set_supports_discarded_packets(
1396             this->libObjPtr(), static_cast<bt_bool>(supportsDiscardedPackets),
1397             static_cast<bt_bool>(withDefaultClkSnapshots));
1398     }
1399
1400     bool supportsDiscardedPackets() const noexcept
1401     {
1402         return static_cast<bool>(bt_stream_class_supports_discarded_packets(this->libObjPtr()));
1403     }
1404
1405     bool discardedPacketsHaveDefaultClockSnapshots() const noexcept
1406     {
1407         return static_cast<bool>(
1408             bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
1409     }
1410
1411     void defaultClockClass(const ClockClass clkCls) const
1412     {
1413         static_assert(!std::is_const<LibObjT>::value,
1414                       "Not available with `bt2::ConstStreamClass`.");
1415
1416         const auto status =
1417             bt_stream_class_set_default_clock_class(this->libObjPtr(), clkCls.libObjPtr());
1418
1419         BT_ASSERT(status == BT_STREAM_CLASS_SET_DEFAULT_CLOCK_CLASS_STATUS_OK);
1420     }
1421
1422     OptionalBorrowedObject<_ClockClass> defaultClockClass() const noexcept
1423     {
1424         return _Spec::defaultClockClass(this->libObjPtr());
1425     }
1426
1427     std::uint64_t length() const noexcept
1428     {
1429         return bt_stream_class_get_event_class_count(this->libObjPtr());
1430     }
1431
1432     _EventClass operator[](const std::uint64_t index) const noexcept
1433     {
1434         return _EventClass {_Spec::eventClassByIndex(this->libObjPtr(), index)};
1435     }
1436
1437     OptionalBorrowedObject<_EventClass> eventClassById(const std::uint64_t id) const noexcept
1438     {
1439         return _Spec::eventClassById(this->libObjPtr(), id);
1440     }
1441
1442     void packetContextFieldClass(const StructureFieldClass fc) const
1443     {
1444         static_assert(!std::is_const<LibObjT>::value,
1445                       "Not available with `bt2::ConstStreamClass`.");
1446
1447         const auto status =
1448             bt_stream_class_set_packet_context_field_class(this->libObjPtr(), fc.libObjPtr());
1449
1450         if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1451             throw MemoryError {};
1452         }
1453     }
1454
1455     OptionalBorrowedObject<_StructureFieldClass> packetContextFieldClass() const noexcept
1456     {
1457         return _Spec::packetContextFieldClass(this->libObjPtr());
1458     }
1459
1460     void eventCommonContextFieldClass(const StructureFieldClass fc) const
1461     {
1462         static_assert(!std::is_const<LibObjT>::value,
1463                       "Not available with `bt2::ConstStreamClass`.");
1464
1465         const auto status =
1466             bt_stream_class_set_event_common_context_field_class(this->libObjPtr(), fc.libObjPtr());
1467
1468         if (status == BT_STREAM_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
1469             throw MemoryError {};
1470         }
1471     }
1472
1473     OptionalBorrowedObject<_StructureFieldClass> eventCommonContextFieldClass() const noexcept
1474     {
1475         return _Spec::eventCommonContextFieldClass(this->libObjPtr());
1476     }
1477
1478     template <typename LibValT>
1479     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1480     {
1481         static_assert(!std::is_const<LibObjT>::value,
1482                       "Not available with `bt2::ConstStreamClass`.");
1483
1484         bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1485     }
1486
1487     UserAttributes userAttributes() const noexcept
1488     {
1489         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1490     }
1491
1492     Shared shared() const noexcept
1493     {
1494         return Shared::createWithRef(*this);
1495     }
1496 };
1497
1498 using StreamClass = CommonStreamClass<bt_stream_class>;
1499 using ConstStreamClass = CommonStreamClass<const bt_stream_class>;
1500
1501 namespace internal {
1502
1503 struct StreamClassTypeDescr
1504 {
1505     using Const = ConstStreamClass;
1506     using NonConst = StreamClass;
1507 };
1508
1509 template <>
1510 struct TypeDescr<StreamClass> : public StreamClassTypeDescr
1511 {
1512 };
1513
1514 template <>
1515 struct TypeDescr<ConstStreamClass> : public StreamClassTypeDescr
1516 {
1517 };
1518
1519 } /* namespace internal */
1520
1521 template <typename LibObjT>
1522 typename CommonEventClass<LibObjT>::_StreamClass
1523 CommonEventClass<LibObjT>::streamClass() const noexcept
1524 {
1525     return _StreamClass {_Spec::streamClass(this->libObjPtr())};
1526 }
1527
1528 template <typename LibObjT>
1529 typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() const noexcept
1530 {
1531     return Class {_Spec::cls(this->libObjPtr())};
1532 }
1533
1534 namespace internal {
1535
1536 struct TraceClassRefFuncs final
1537 {
1538     static void get(const bt_trace_class * const libObjPtr) noexcept
1539     {
1540         bt_trace_class_get_ref(libObjPtr);
1541     }
1542
1543     static void put(const bt_trace_class * const libObjPtr) noexcept
1544     {
1545         bt_trace_class_put_ref(libObjPtr);
1546     }
1547 };
1548
1549 template <typename LibObjT>
1550 struct CommonTraceClassSpec;
1551
1552 /* Functions specific to mutable stream classes */
1553 template <>
1554 struct CommonTraceClassSpec<bt_trace_class> final
1555 {
1556     static bt_stream_class *streamClassByIndex(bt_trace_class * const libObjPtr,
1557                                                const std::uint64_t index) noexcept
1558     {
1559         return bt_trace_class_borrow_stream_class_by_index(libObjPtr, index);
1560     }
1561
1562     static bt_stream_class *streamClassById(bt_trace_class * const libObjPtr,
1563                                             const std::uint64_t id) noexcept
1564     {
1565         return bt_trace_class_borrow_stream_class_by_id(libObjPtr, id);
1566     }
1567
1568     static bt_value *userAttributes(bt_trace_class * const libObjPtr) noexcept
1569     {
1570         return bt_trace_class_borrow_user_attributes(libObjPtr);
1571     }
1572 };
1573
1574 /* Functions specific to constant stream classes */
1575 template <>
1576 struct CommonTraceClassSpec<const bt_trace_class> final
1577 {
1578     static const bt_stream_class *streamClassByIndex(const bt_trace_class * const libObjPtr,
1579                                                      const std::uint64_t index) noexcept
1580     {
1581         return bt_trace_class_borrow_stream_class_by_index_const(libObjPtr, index);
1582     }
1583
1584     static const bt_stream_class *streamClassById(const bt_trace_class * const libObjPtr,
1585                                                   const std::uint64_t id) noexcept
1586     {
1587         return bt_trace_class_borrow_stream_class_by_id_const(libObjPtr, id);
1588     }
1589
1590     static const bt_value *userAttributes(const bt_trace_class * const libObjPtr) noexcept
1591     {
1592         return bt_trace_class_borrow_user_attributes_const(libObjPtr);
1593     }
1594 };
1595
1596 } /* namespace internal */
1597
1598 template <typename LibObjT>
1599 class CommonTraceClass final : public BorrowedObject<LibObjT>
1600 {
1601 private:
1602     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
1603
1604     using _Spec = internal::CommonTraceClassSpec<LibObjT>;
1605
1606     using _StreamClass = internal::DepType<LibObjT, CommonStreamClass<bt_stream_class>,
1607                                            CommonStreamClass<const bt_stream_class>>;
1608
1609 public:
1610     using typename BorrowedObject<LibObjT>::LibObjPtr;
1611     using Shared = SharedObject<CommonTraceClass, LibObjT, internal::TraceClassRefFuncs>;
1612     using UserAttributes = internal::DepUserAttrs<LibObjT>;
1613
1614     explicit CommonTraceClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
1615     {
1616     }
1617
1618     template <typename OtherLibObjT>
1619     CommonTraceClass(const CommonTraceClass<OtherLibObjT> traceClass) noexcept :
1620         _ThisBorrowedObject {traceClass}
1621     {
1622     }
1623
1624     template <typename OtherLibObjT>
1625     CommonTraceClass operator=(const CommonTraceClass<OtherLibObjT> traceClass) noexcept
1626     {
1627         _ThisBorrowedObject::operator=(traceClass);
1628         return *this;
1629     }
1630
1631     CommonTraceClass<const bt_trace_class> asConst() const noexcept
1632     {
1633         return CommonTraceClass<const bt_trace_class> {*this};
1634     }
1635
1636     Trace::Shared instantiate() const
1637     {
1638         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1639
1640         const auto libObjPtr = bt_trace_create(this->libObjPtr());
1641
1642         internal::validateCreatedObjPtr(libObjPtr);
1643         return Trace::Shared::createWithoutRef(libObjPtr);
1644     }
1645
1646     StreamClass::Shared createStreamClass() const
1647     {
1648         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1649
1650         const auto libObjPtr = bt_stream_class_create(this->libObjPtr());
1651
1652         internal::validateCreatedObjPtr(libObjPtr);
1653         return StreamClass::Shared::createWithoutRef(libObjPtr);
1654     }
1655
1656     StreamClass::Shared createStreamClass(const std::uint64_t id) const
1657     {
1658         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1659
1660         const auto libObjPtr = bt_stream_class_create_with_id(this->libObjPtr(), id);
1661
1662         internal::validateCreatedObjPtr(libObjPtr);
1663         return StreamClass::Shared::createWithoutRef(libObjPtr);
1664     }
1665
1666     FieldClass::Shared createBoolFieldClass() const
1667     {
1668         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1669
1670         const auto libObjPtr = bt_field_class_bool_create(this->libObjPtr());
1671
1672         internal::validateCreatedObjPtr(libObjPtr);
1673         return FieldClass::Shared::createWithoutRef(libObjPtr);
1674     }
1675
1676     BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length) const
1677     {
1678         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1679
1680         const auto libObjPtr = bt_field_class_bit_array_create(this->libObjPtr(), length);
1681
1682         internal::validateCreatedObjPtr(libObjPtr);
1683         return BitArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1684     }
1685
1686     IntegerFieldClass::Shared createUnsignedIntegerFieldClass() const
1687     {
1688         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1689
1690         const auto libObjPtr = bt_field_class_integer_unsigned_create(this->libObjPtr());
1691
1692         internal::validateCreatedObjPtr(libObjPtr);
1693         return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1694     }
1695
1696     IntegerFieldClass::Shared createSignedIntegerFieldClass() const
1697     {
1698         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1699
1700         const auto libObjPtr = bt_field_class_integer_signed_create(this->libObjPtr());
1701
1702         internal::validateCreatedObjPtr(libObjPtr);
1703         return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
1704     }
1705
1706     UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass() const
1707     {
1708         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1709
1710         const auto libObjPtr = bt_field_class_enumeration_unsigned_create(this->libObjPtr());
1711
1712         internal::validateCreatedObjPtr(libObjPtr);
1713         return UnsignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1714     }
1715
1716     SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass() const
1717     {
1718         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1719
1720         const auto libObjPtr = bt_field_class_enumeration_signed_create(this->libObjPtr());
1721
1722         internal::validateCreatedObjPtr(libObjPtr);
1723         return SignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
1724     }
1725
1726     FieldClass::Shared createSinglePrecisionRealFieldClass() const
1727     {
1728         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1729
1730         const auto libObjPtr = bt_field_class_real_single_precision_create(this->libObjPtr());
1731
1732         internal::validateCreatedObjPtr(libObjPtr);
1733         return FieldClass::Shared::createWithoutRef(libObjPtr);
1734     }
1735
1736     FieldClass::Shared createDoublePrecisionRealFieldClass() const
1737     {
1738         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1739
1740         const auto libObjPtr = bt_field_class_real_double_precision_create(this->libObjPtr());
1741
1742         internal::validateCreatedObjPtr(libObjPtr);
1743         return FieldClass::Shared::createWithoutRef(libObjPtr);
1744     }
1745
1746     FieldClass::Shared createStringFieldClass() const
1747     {
1748         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1749
1750         const auto libObjPtr = bt_field_class_string_create(this->libObjPtr());
1751
1752         internal::validateCreatedObjPtr(libObjPtr);
1753         return FieldClass::Shared::createWithoutRef(libObjPtr);
1754     }
1755
1756     StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass elementFieldClass,
1757                                                               const std::uint64_t length) const
1758     {
1759         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1760
1761         const auto libObjPtr = bt_field_class_array_static_create(
1762             this->libObjPtr(), elementFieldClass.libObjPtr(), length);
1763
1764         internal::validateCreatedObjPtr(libObjPtr);
1765         return StaticArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1766     }
1767
1768     ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass) const
1769     {
1770         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1771
1772         const auto libObjPtr = bt_field_class_array_dynamic_create(
1773             this->libObjPtr(), elementFieldClass.libObjPtr(), nullptr);
1774
1775         internal::validateCreatedObjPtr(libObjPtr);
1776         return ArrayFieldClass::Shared::createWithoutRef(libObjPtr);
1777     }
1778
1779     DynamicArrayWithLengthFieldClass::Shared
1780     createDynamicArrayFieldClass(const FieldClass elementFieldClass,
1781                                  const IntegerFieldClass lengthFieldClass) const
1782     {
1783         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1784
1785         const auto libObjPtr = bt_field_class_array_dynamic_create(
1786             this->libObjPtr(), elementFieldClass.libObjPtr(), lengthFieldClass.libObjPtr());
1787
1788         internal::validateCreatedObjPtr(libObjPtr);
1789         return DynamicArrayWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
1790     }
1791
1792     StructureFieldClass::Shared createStructureFieldClass() const
1793     {
1794         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1795
1796         const auto libObjPtr = bt_field_class_structure_create(this->libObjPtr());
1797
1798         internal::validateCreatedObjPtr(libObjPtr);
1799         return StructureFieldClass::Shared::createWithoutRef(libObjPtr);
1800     }
1801
1802     OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass) const
1803     {
1804         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1805
1806         const auto libObjPtr = bt_field_class_option_without_selector_create(
1807             this->libObjPtr(), optionalFieldClass.libObjPtr());
1808
1809         internal::validateCreatedObjPtr(libObjPtr);
1810         return OptionFieldClass::Shared::createWithoutRef(libObjPtr);
1811     }
1812
1813     OptionWithBoolSelectorFieldClass::Shared
1814     createOptionWithBoolSelectorFieldClass(const FieldClass optionalFieldClass,
1815                                            const FieldClass selectorFieldClass) const
1816     {
1817         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1818
1819         const auto libObjPtr = bt_field_class_option_with_selector_field_bool_create(
1820             this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr());
1821
1822         internal::validateCreatedObjPtr(libObjPtr);
1823         return OptionWithBoolSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1824     }
1825
1826     OptionWithUnsignedIntegerSelectorFieldClass::Shared
1827     createOptionWithUnsignedIntegerSelectorFieldClass(
1828         const FieldClass optionalFieldClass, const IntegerFieldClass selectorFieldClass,
1829         const ConstUnsignedIntegerRangeSet ranges) const
1830     {
1831         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1832
1833         const auto libObjPtr = bt_field_class_option_with_selector_field_integer_unsigned_create(
1834             this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1835             ranges.libObjPtr());
1836
1837         internal::validateCreatedObjPtr(libObjPtr);
1838         return OptionWithUnsignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1839     }
1840
1841     OptionWithSignedIntegerSelectorFieldClass::Shared
1842     createOptionWithSignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
1843                                                     const IntegerFieldClass selectorFieldClass,
1844                                                     const ConstSignedIntegerRangeSet ranges) const
1845     {
1846         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1847
1848         const auto libObjPtr = bt_field_class_option_with_selector_field_integer_signed_create(
1849             this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
1850             ranges.libObjPtr());
1851
1852         internal::validateCreatedObjPtr(libObjPtr);
1853         return OptionWithSignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1854     }
1855
1856     VariantWithoutSelectorFieldClass::Shared createVariantFieldClass() const
1857     {
1858         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1859
1860         const auto libObjPtr = bt_field_class_variant_create(this->libObjPtr(), nullptr);
1861
1862         internal::validateCreatedObjPtr(libObjPtr);
1863         return VariantWithoutSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
1864     }
1865
1866     VariantWithUnsignedIntegerSelectorFieldClass::Shared
1867     createVariantWithUnsignedIntegerSelectorFieldClass(
1868         const IntegerFieldClass selectorFieldClass) const
1869     {
1870         return this->_createVariantWithIntegerSelectorFieldClass<
1871             VariantWithUnsignedIntegerSelectorFieldClass>(selectorFieldClass);
1872     }
1873
1874     VariantWithSignedIntegerSelectorFieldClass::Shared
1875     createVariantWithSignedIntegerSelectorFieldClass(
1876         const IntegerFieldClass selectorFieldClass) const
1877     {
1878         return this->_createVariantWithIntegerSelectorFieldClass<
1879             VariantWithSignedIntegerSelectorFieldClass>(selectorFieldClass);
1880     }
1881
1882     void assignsAutomaticStreamClassId(const bool val) const noexcept
1883     {
1884         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1885
1886         bt_trace_class_set_assigns_automatic_stream_class_id(this->libObjPtr(),
1887                                                              static_cast<bt_bool>(val));
1888     }
1889
1890     bool assignsAutomaticStreamClassId() const noexcept
1891     {
1892         return static_cast<bool>(
1893             bt_trace_class_assigns_automatic_stream_class_id(this->libObjPtr()));
1894     }
1895
1896     std::uint64_t length() const noexcept
1897     {
1898         return bt_trace_class_get_stream_class_count(this->libObjPtr());
1899     }
1900
1901     _StreamClass operator[](const std::uint64_t index) const noexcept
1902     {
1903         return _StreamClass {_Spec::streamClassByIndex(this->libObjPtr(), index)};
1904     }
1905
1906     OptionalBorrowedObject<_StreamClass> streamClassById(const std::uint64_t id) const noexcept
1907     {
1908         return _Spec::streamClassById(this->libObjPtr(), id);
1909     }
1910
1911     template <typename LibValT>
1912     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
1913     {
1914         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1915
1916         bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
1917     }
1918
1919     UserAttributes userAttributes() const noexcept
1920     {
1921         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
1922     }
1923
1924     Shared shared() const noexcept
1925     {
1926         return Shared::createWithRef(*this);
1927     }
1928
1929 private:
1930     template <typename ObjT>
1931     typename ObjT::Shared
1932     _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass) const
1933     {
1934         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstTraceClass`.");
1935
1936         const auto libObjPtr =
1937             bt_field_class_variant_create(this->libObjPtr(), selectorFieldClass.libObjPtr());
1938
1939         internal::validateCreatedObjPtr(libObjPtr);
1940         return ObjT::Shared::createWithoutRef(libObjPtr);
1941     }
1942 };
1943
1944 using TraceClass = CommonTraceClass<bt_trace_class>;
1945 using ConstTraceClass = CommonTraceClass<const bt_trace_class>;
1946
1947 namespace internal {
1948
1949 struct TraceClassTypeDescr
1950 {
1951     using Const = ConstTraceClass;
1952     using NonConst = TraceClass;
1953 };
1954
1955 template <>
1956 struct TypeDescr<TraceClass> : public TraceClassTypeDescr
1957 {
1958 };
1959
1960 template <>
1961 struct TypeDescr<ConstTraceClass> : public TraceClassTypeDescr
1962 {
1963 };
1964
1965 } /* namespace internal */
1966
1967 template <typename LibObjT>
1968 typename CommonStreamClass<LibObjT>::_TraceClass
1969 CommonStreamClass<LibObjT>::traceClass() const noexcept
1970 {
1971     return _TraceClass {_Spec::traceClass(this->libObjPtr())};
1972 }
1973
1974 template <typename LibObjT>
1975 typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() const noexcept
1976 {
1977     return Class {_Spec::cls(this->libObjPtr())};
1978 }
1979
1980 } /* namespace bt2 */
1981
1982 #endif /* BABELTRACE_CPP_COMMON_BT2_TRACE_IR_HPP */