src/cpp-common/bt2/message.hpp

   1 /*
   2  * Copyright (c) 2021 Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * SPDX-License-Identifier: MIT
   5  */
   6
   7 #ifndef BABELTRACE_CPP_COMMON_BT2_MESSAGE_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_MESSAGE_HPP
   9
  10 #include <cstdint>
  11 #include <type_traits>
  12
  13 #include <babeltrace2/babeltrace.h>
  14
  15 #include "common/assert.h"
  16 #include "cpp-common/bt2/clock-snapshot.hpp"
  17 #include "cpp-common/bt2/trace-ir.hpp"
  18 #include "cpp-common/bt2s/optional.hpp"
  19
  20 #include "borrowed-object.hpp"
  21 #include "internal/utils.hpp"
  22 #include "shared-object.hpp"
  23
  24 namespace bt2 {
  25 namespace internal {
  26
  27 struct MessageRefFuncs final
  28 {
  29     static void get(const bt_message * const libObjPtr) noexcept
  30     {
  31         bt_message_get_ref(libObjPtr);
  32     }
  33
  34     static void put(const bt_message * const libObjPtr) noexcept
  35     {
  36         bt_message_put_ref(libObjPtr);
  37     }
  38 };
  39
  40 } /* namespace internal */
  41
  42 template <typename ObjT, typename LibObjT>
  43 using SharedMessage = SharedObject<ObjT, LibObjT, internal::MessageRefFuncs>;
  44
  45 template <typename LibObjT>
  46 class CommonStreamBeginningMessage;
  47
  48 template <typename LibObjT>
  49 class CommonStreamEndMessage;
  50
  51 template <typename LibObjT>
  52 class CommonEventMessage;
  53
  54 template <typename LibObjT>
  55 class CommonPacketBeginningMessage;
  56
  57 template <typename LibObjT>
  58 class CommonPacketEndMessage;
  59
  60 template <typename LibObjT>
  61 class CommonDiscardedEventsMessage;
  62
  63 template <typename LibObjT>
  64 class CommonDiscardedPacketsMessage;
  65
  66 template <typename LibObjT>
  67 class CommonMessageIteratorInactivityMessage;
  68
  69 enum class MessageType
  70 {
  71     STREAM_BEGINNING = BT_MESSAGE_TYPE_STREAM_BEGINNING,
  72     STREAM_END = BT_MESSAGE_TYPE_STREAM_END,
  73     EVENT = BT_MESSAGE_TYPE_EVENT,
  74     PACKET_BEGINNING = BT_MESSAGE_TYPE_PACKET_BEGINNING,
  75     PACKET_END = BT_MESSAGE_TYPE_PACKET_END,
  76     DISCARDED_EVENTS = BT_MESSAGE_TYPE_DISCARDED_EVENTS,
  77     DISCARDED_PACKETS = BT_MESSAGE_TYPE_DISCARDED_PACKETS,
  78     MESSAGE_ITERATOR_INACTIVITY = BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY,
  79 };
  80
  81 template <typename LibObjT>
  82 class CommonMessage : public BorrowedObject<LibObjT>
  83 {
  84 private:
  85     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
  86
  87 protected:
  88     using _ThisCommonMessage = CommonMessage<LibObjT>;
  89
  90 public:
  91     using typename BorrowedObject<LibObjT>::LibObjPtr;
  92     using Shared = SharedMessage<CommonMessage<LibObjT>, LibObjT>;
  93
  94     explicit CommonMessage(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
  95     {
  96     }
  97
  98     template <typename OtherLibObjT>
  99     CommonMessage(const CommonMessage<OtherLibObjT> val) noexcept : _ThisBorrowedObject {val}
 100     {
 101     }
 102
 103     template <typename OtherLibObjT>
 104     _ThisCommonMessage operator=(const CommonMessage<OtherLibObjT> val) noexcept
 105     {
 106         _ThisBorrowedObject::operator=(val);
 107         return *this;
 108     }
 109
 110     CommonMessage<const bt_message> asConst() const noexcept
 111     {
 112         return CommonMessage<const bt_message> {*this};
 113     }
 114
 115     MessageType type() const noexcept
 116     {
 117         return static_cast<MessageType>(bt_message_get_type(this->libObjPtr()));
 118     }
 119
 120     bool isStreamBeginning() const noexcept
 121     {
 122         return this->type() == MessageType::STREAM_BEGINNING;
 123     }
 124
 125     bool isStreamEnd() const noexcept
 126     {
 127         return this->type() == MessageType::STREAM_END;
 128     }
 129
 130     bool isEvent() const noexcept
 131     {
 132         return this->type() == MessageType::EVENT;
 133     }
 134
 135     bool isPacketBeginning() const noexcept
 136     {
 137         return this->type() == MessageType::PACKET_BEGINNING;
 138     }
 139
 140     bool isPacketEnd() const noexcept
 141     {
 142         return this->type() == MessageType::PACKET_END;
 143     }
 144
 145     bool isDiscardedEvents() const noexcept
 146     {
 147         return this->type() == MessageType::DISCARDED_EVENTS;
 148     }
 149
 150     bool isDiscardedPackets() const noexcept
 151     {
 152         return this->type() == MessageType::DISCARDED_PACKETS;
 153     }
 154
 155     bool isMessageIteratorInactivity() const noexcept
 156     {
 157         return this->type() == MessageType::MESSAGE_ITERATOR_INACTIVITY;
 158     }
 159
 160     Shared shared() const noexcept
 161     {
 162         return Shared::createWithRef(*this);
 163     }
 164
 165     template <typename MessageT>
 166     MessageT as() const noexcept
 167     {
 168         return MessageT {this->libObjPtr()};
 169     }
 170
 171     CommonStreamBeginningMessage<LibObjT> asStreamBeginning() const noexcept;
 172     CommonStreamEndMessage<LibObjT> asStreamEnd() const noexcept;
 173     CommonEventMessage<LibObjT> asEvent() const noexcept;
 174     CommonPacketBeginningMessage<LibObjT> asPacketBeginning() const noexcept;
 175     CommonPacketEndMessage<LibObjT> asPacketEnd() const noexcept;
 176     CommonDiscardedEventsMessage<LibObjT> asDiscardedEvents() const noexcept;
 177     CommonDiscardedPacketsMessage<LibObjT> asDiscardedPackets() const noexcept;
 178     CommonMessageIteratorInactivityMessage<LibObjT> asMessageIteratorInactivity() const noexcept;
 179 };
 180
 181 using Message = CommonMessage<bt_message>;
 182 using ConstMessage = CommonMessage<const bt_message>;
 183
 184 namespace internal {
 185
 186 struct MessageTypeDescr
 187 {
 188     using Const = ConstMessage;
 189     using NonConst = Message;
 190 };
 191
 192 template <>
 193 struct TypeDescr<Message> : public MessageTypeDescr
 194 {
 195 };
 196
 197 template <>
 198 struct TypeDescr<ConstMessage> : public MessageTypeDescr
 199 {
 200 };
 201
 202 template <typename LibObjT>
 203 struct CommonStreamBeginningMessageSpec;
 204
 205 /* Functions specific to mutable stream beginning messages */
 206 template <>
 207 struct CommonStreamBeginningMessageSpec<bt_message> final
 208 {
 209     static bt_stream *stream(bt_message * const libObjPtr) noexcept
 210     {
 211         return bt_message_stream_beginning_borrow_stream(libObjPtr);
 212     }
 213 };
 214
 215 /* Functions specific to constant stream beginning messages */
 216 template <>
 217 struct CommonStreamBeginningMessageSpec<const bt_message> final
 218 {
 219     static const bt_stream *stream(const bt_message * const libObjPtr) noexcept
 220     {
 221         return bt_message_stream_beginning_borrow_stream_const(libObjPtr);
 222     }
 223 };
 224
 225 } /* namespace internal */
 226
 227 template <typename LibObjT>
 228 class CommonStreamBeginningMessage final : public CommonMessage<LibObjT>
 229 {
 230 private:
 231     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 232     using _Stream = internal::DepStream<LibObjT>;
 233
 234 public:
 235     using typename CommonMessage<LibObjT>::LibObjPtr;
 236     using Shared = SharedMessage<CommonStreamBeginningMessage<LibObjT>, LibObjT>;
 237
 238     explicit CommonStreamBeginningMessage(const LibObjPtr libObjPtr) noexcept :
 239         _ThisCommonMessage {libObjPtr}
 240     {
 241         BT_ASSERT_DBG(this->isStreamBeginning());
 242     }
 243
 244     template <typename OtherLibObjT>
 245     CommonStreamBeginningMessage(const CommonStreamBeginningMessage<OtherLibObjT> val) noexcept :
 246         _ThisCommonMessage {val}
 247     {
 248     }
 249
 250     template <typename OtherLibObjT>
 251     CommonStreamBeginningMessage<LibObjT>
 252     operator=(const CommonStreamBeginningMessage<OtherLibObjT> val) noexcept
 253     {
 254         _ThisCommonMessage::operator=(val);
 255         return *this;
 256     }
 257
 258     CommonStreamBeginningMessage<const bt_message> asConst() const noexcept
 259     {
 260         return CommonStreamBeginningMessage<const bt_message> {*this};
 261     }
 262
 263     _Stream stream() const noexcept
 264     {
 265         return _Stream {
 266             internal::CommonStreamBeginningMessageSpec<LibObjT>::stream(this->libObjPtr())};
 267     }
 268
 269     void defaultClockSnapshot(const std::uint64_t val) const noexcept
 270     {
 271         static_assert(!std::is_const<LibObjT>::value,
 272                       "Not available with `bt2::ConstStreamBeginningMessage`.");
 273
 274         bt_message_stream_beginning_set_default_clock_snapshot(this->libObjPtr(), val);
 275     }
 276
 277     bt2s::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
 278     {
 279         const bt_clock_snapshot *libObjPtr;
 280         const auto state = bt_message_stream_beginning_borrow_default_clock_snapshot_const(
 281             this->libObjPtr(), &libObjPtr);
 282
 283         if (state == BT_MESSAGE_STREAM_CLOCK_SNAPSHOT_STATE_KNOWN) {
 284             return ConstClockSnapshot {libObjPtr};
 285         }
 286
 287         return bt2s::nullopt;
 288     }
 289
 290     Shared shared() const noexcept
 291     {
 292         return Shared::createWithRef(*this);
 293     }
 294 };
 295
 296 using StreamBeginningMessage = CommonStreamBeginningMessage<bt_message>;
 297 using ConstStreamBeginningMessage = CommonStreamBeginningMessage<const bt_message>;
 298
 299 namespace internal {
 300
 301 struct StreamBeginningMessageTypeDescr
 302 {
 303     using Const = ConstStreamBeginningMessage;
 304     using NonConst = StreamBeginningMessage;
 305 };
 306
 307 template <>
 308 struct TypeDescr<StreamBeginningMessage> : public StreamBeginningMessageTypeDescr
 309 {
 310 };
 311
 312 template <>
 313 struct TypeDescr<ConstStreamBeginningMessage> : public StreamBeginningMessageTypeDescr
 314 {
 315 };
 316
 317 template <typename LibObjT>
 318 struct CommonStreamEndMessageSpec;
 319
 320 /* Functions specific to mutable stream end messages */
 321 template <>
 322 struct CommonStreamEndMessageSpec<bt_message> final
 323 {
 324     static bt_stream *stream(bt_message * const libObjPtr) noexcept
 325     {
 326         return bt_message_stream_end_borrow_stream(libObjPtr);
 327     }
 328 };
 329
 330 /* Functions specific to constant stream end messages */
 331 template <>
 332 struct CommonStreamEndMessageSpec<const bt_message> final
 333 {
 334     static const bt_stream *stream(const bt_message * const libObjPtr) noexcept
 335     {
 336         return bt_message_stream_end_borrow_stream_const(libObjPtr);
 337     }
 338 };
 339
 340 } /* namespace internal */
 341
 342 template <typename LibObjT>
 343 class CommonStreamEndMessage final : public CommonMessage<LibObjT>
 344 {
 345 private:
 346     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 347     using _Stream = internal::DepStream<LibObjT>;
 348
 349 public:
 350     using typename CommonMessage<LibObjT>::LibObjPtr;
 351     using Shared = SharedMessage<CommonStreamEndMessage<LibObjT>, LibObjT>;
 352
 353     explicit CommonStreamEndMessage(const LibObjPtr libObjPtr) noexcept :
 354         _ThisCommonMessage {libObjPtr}
 355     {
 356         BT_ASSERT_DBG(this->isStreamEnd());
 357     }
 358
 359     template <typename OtherLibObjT>
 360     CommonStreamEndMessage(const CommonStreamEndMessage<OtherLibObjT> val) noexcept :
 361         _ThisCommonMessage {val}
 362     {
 363     }
 364
 365     template <typename OtherLibObjT>
 366     CommonStreamEndMessage<LibObjT>
 367     operator=(const CommonStreamEndMessage<OtherLibObjT> val) noexcept
 368     {
 369         _ThisCommonMessage::operator=(val);
 370         return *this;
 371     }
 372
 373     CommonStreamEndMessage<const bt_message> asConst() const noexcept
 374     {
 375         return CommonStreamEndMessage<const bt_message> {*this};
 376     }
 377
 378     _Stream stream() const noexcept
 379     {
 380         return _Stream {internal::CommonStreamEndMessageSpec<LibObjT>::stream(this->libObjPtr())};
 381     }
 382
 383     void defaultClockSnapshot(const std::uint64_t val) const noexcept
 384     {
 385         static_assert(!std::is_const<LibObjT>::value,
 386                       "Not available with `bt2::ConstStreamEndMessage`.");
 387
 388         bt_message_stream_end_set_default_clock_snapshot(this->libObjPtr(), val);
 389     }
 390
 391     bt2s::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
 392     {
 393         const bt_clock_snapshot *libObjPtr;
 394         const auto state = bt_message_stream_end_borrow_default_clock_snapshot_const(
 395             this->libObjPtr(), &libObjPtr);
 396
 397         if (state == BT_MESSAGE_STREAM_CLOCK_SNAPSHOT_STATE_KNOWN) {
 398             return ConstClockSnapshot {libObjPtr};
 399         }
 400
 401         return bt2s::nullopt;
 402     }
 403
 404     Shared shared() const noexcept
 405     {
 406         return Shared::createWithRef(*this);
 407     }
 408 };
 409
 410 using StreamEndMessage = CommonStreamEndMessage<bt_message>;
 411 using ConstStreamEndMessage = CommonStreamEndMessage<const bt_message>;
 412
 413 namespace internal {
 414
 415 struct StreamEndMessageTypeDescr
 416 {
 417     using Const = ConstStreamEndMessage;
 418     using NonConst = StreamEndMessage;
 419 };
 420
 421 template <>
 422 struct TypeDescr<StreamEndMessage> : public StreamEndMessageTypeDescr
 423 {
 424 };
 425
 426 template <>
 427 struct TypeDescr<ConstStreamEndMessage> : public StreamEndMessageTypeDescr
 428 {
 429 };
 430
 431 template <typename LibObjT>
 432 struct CommonPacketBeginningMessageSpec;
 433
 434 /* Functions specific to mutable packet beginning messages */
 435 template <>
 436 struct CommonPacketBeginningMessageSpec<bt_message> final
 437 {
 438     static bt_packet *packet(bt_message * const libObjPtr) noexcept
 439     {
 440         return bt_message_packet_beginning_borrow_packet(libObjPtr);
 441     }
 442 };
 443
 444 /* Functions specific to constant packet beginning messages */
 445 template <>
 446 struct CommonPacketBeginningMessageSpec<const bt_message> final
 447 {
 448     static const bt_packet *packet(const bt_message * const libObjPtr) noexcept
 449     {
 450         return bt_message_packet_beginning_borrow_packet_const(libObjPtr);
 451     }
 452 };
 453
 454 } /* namespace internal */
 455
 456 template <typename LibObjT>
 457 class CommonPacketBeginningMessage final : public CommonMessage<LibObjT>
 458 {
 459 private:
 460     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 461     using _Packet = internal::DepPacket<LibObjT>;
 462
 463 public:
 464     using typename CommonMessage<LibObjT>::LibObjPtr;
 465     using Shared = SharedMessage<CommonPacketBeginningMessage<LibObjT>, LibObjT>;
 466
 467     explicit CommonPacketBeginningMessage(const LibObjPtr libObjPtr) noexcept :
 468         _ThisCommonMessage {libObjPtr}
 469     {
 470         BT_ASSERT_DBG(this->isPacketBeginning());
 471     }
 472
 473     template <typename OtherLibObjT>
 474     CommonPacketBeginningMessage(const CommonPacketBeginningMessage<OtherLibObjT> val) noexcept :
 475         _ThisCommonMessage {val}
 476     {
 477     }
 478
 479     template <typename OtherLibObjT>
 480     CommonPacketBeginningMessage<LibObjT>
 481     operator=(const CommonPacketBeginningMessage<OtherLibObjT> val) noexcept
 482     {
 483         _ThisCommonMessage::operator=(val);
 484         return *this;
 485     }
 486
 487     CommonPacketBeginningMessage<const bt_message> asConst() const noexcept
 488     {
 489         return CommonPacketBeginningMessage<const bt_message> {*this};
 490     }
 491
 492     _Packet packet() const noexcept
 493     {
 494         return _Packet {
 495             internal::CommonPacketBeginningMessageSpec<LibObjT>::packet(this->libObjPtr())};
 496     }
 497
 498     void defaultClockSnapshot(const std::uint64_t val) const noexcept
 499     {
 500         static_assert(!std::is_const<LibObjT>::value,
 501                       "Not available with `bt2::ConstPacketBeginningMessage`.");
 502
 503         bt_message_packet_beginning_set_default_clock_snapshot(this->libObjPtr(), val);
 504     }
 505
 506     ConstClockSnapshot defaultClockSnapshot() const noexcept
 507     {
 508         const auto libObjPtr =
 509             bt_message_packet_beginning_borrow_default_clock_snapshot_const(this->libObjPtr());
 510
 511         return ConstClockSnapshot {libObjPtr};
 512     }
 513
 514     Shared shared() const noexcept
 515     {
 516         return Shared::createWithRef(*this);
 517     }
 518 };
 519
 520 using PacketBeginningMessage = CommonPacketBeginningMessage<bt_message>;
 521 using ConstPacketBeginningMessage = CommonPacketBeginningMessage<const bt_message>;
 522
 523 namespace internal {
 524
 525 struct PacketBeginningMessageTypeDescr
 526 {
 527     using Const = ConstPacketBeginningMessage;
 528     using NonConst = PacketBeginningMessage;
 529 };
 530
 531 template <>
 532 struct TypeDescr<PacketBeginningMessage> : public PacketBeginningMessageTypeDescr
 533 {
 534 };
 535
 536 template <>
 537 struct TypeDescr<ConstPacketBeginningMessage> : public PacketBeginningMessageTypeDescr
 538 {
 539 };
 540
 541 template <typename LibObjT>
 542 struct CommonPacketEndMessageSpec;
 543
 544 /* Functions specific to mutable packet end messages */
 545 template <>
 546 struct CommonPacketEndMessageSpec<bt_message> final
 547 {
 548     static bt_packet *packet(bt_message * const libObjPtr) noexcept
 549     {
 550         return bt_message_packet_end_borrow_packet(libObjPtr);
 551     }
 552 };
 553
 554 /* Functions specific to constant packet end messages */
 555 template <>
 556 struct CommonPacketEndMessageSpec<const bt_message> final
 557 {
 558     static const bt_packet *packet(const bt_message * const libObjPtr) noexcept
 559     {
 560         return bt_message_packet_end_borrow_packet_const(libObjPtr);
 561     }
 562 };
 563
 564 } /* namespace internal */
 565
 566 template <typename LibObjT>
 567 class CommonPacketEndMessage final : public CommonMessage<LibObjT>
 568 {
 569 private:
 570     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 571     using _Packet = internal::DepPacket<LibObjT>;
 572
 573 public:
 574     using typename CommonMessage<LibObjT>::LibObjPtr;
 575     using Shared = SharedMessage<CommonPacketEndMessage<LibObjT>, LibObjT>;
 576
 577     explicit CommonPacketEndMessage(const LibObjPtr libObjPtr) noexcept :
 578         _ThisCommonMessage {libObjPtr}
 579     {
 580         BT_ASSERT_DBG(this->isPacketEnd());
 581     }
 582
 583     template <typename OtherLibObjT>
 584     CommonPacketEndMessage(const CommonPacketEndMessage<OtherLibObjT> val) noexcept :
 585         _ThisCommonMessage {val}
 586     {
 587     }
 588
 589     template <typename OtherLibObjT>
 590     CommonPacketEndMessage<LibObjT>
 591     operator=(const CommonPacketEndMessage<OtherLibObjT> val) noexcept
 592     {
 593         _ThisCommonMessage::operator=(val);
 594         return *this;
 595     }
 596
 597     CommonPacketEndMessage<const bt_message> asConst() const noexcept
 598     {
 599         return CommonPacketEndMessage<const bt_message> {*this};
 600     }
 601
 602     _Packet packet() const noexcept
 603     {
 604         return _Packet {internal::CommonPacketEndMessageSpec<LibObjT>::packet(this->libObjPtr())};
 605     }
 606
 607     void defaultClockSnapshot(const std::uint64_t val) const noexcept
 608     {
 609         static_assert(!std::is_const<LibObjT>::value,
 610                       "Not available with `bt2::ConstPacketEndMessage`.");
 611
 612         bt_message_packet_end_set_default_clock_snapshot(this->libObjPtr(), val);
 613     }
 614
 615     ConstClockSnapshot defaultClockSnapshot() const noexcept
 616     {
 617         const auto libObjPtr =
 618             bt_message_packet_end_borrow_default_clock_snapshot_const(this->libObjPtr());
 619
 620         return ConstClockSnapshot {libObjPtr};
 621     }
 622
 623     Shared shared() const noexcept
 624     {
 625         return Shared::createWithRef(*this);
 626     }
 627 };
 628
 629 using PacketEndMessage = CommonPacketEndMessage<bt_message>;
 630 using ConstPacketEndMessage = CommonPacketEndMessage<const bt_message>;
 631
 632 namespace internal {
 633
 634 struct PacketEndMessageTypeDescr
 635 {
 636     using Const = ConstPacketEndMessage;
 637     using NonConst = PacketEndMessage;
 638 };
 639
 640 template <>
 641 struct TypeDescr<PacketEndMessage> : public PacketEndMessageTypeDescr
 642 {
 643 };
 644
 645 template <>
 646 struct TypeDescr<ConstPacketEndMessage> : public PacketEndMessageTypeDescr
 647 {
 648 };
 649
 650 template <typename LibObjT>
 651 struct CommonEventMessageSpec;
 652
 653 /* Functions specific to mutable event messages */
 654 template <>
 655 struct CommonEventMessageSpec<bt_message> final
 656 {
 657     static bt_event *event(bt_message * const libObjPtr) noexcept
 658     {
 659         return bt_message_event_borrow_event(libObjPtr);
 660     }
 661 };
 662
 663 /* Functions specific to constant event messages */
 664 template <>
 665 struct CommonEventMessageSpec<const bt_message> final
 666 {
 667     static const bt_event *event(const bt_message * const libObjPtr) noexcept
 668     {
 669         return bt_message_event_borrow_event_const(libObjPtr);
 670     }
 671 };
 672
 673 } /* namespace internal */
 674
 675 template <typename LibObjT>
 676 class CommonEventMessage final : public CommonMessage<LibObjT>
 677 {
 678 private:
 679     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 680     using _Event = internal::DepType<LibObjT, CommonEvent<bt_event>, CommonEvent<const bt_event>>;
 681
 682 public:
 683     using typename CommonMessage<LibObjT>::LibObjPtr;
 684     using Shared = SharedMessage<CommonEventMessage<LibObjT>, LibObjT>;
 685
 686     explicit CommonEventMessage(const LibObjPtr libObjPtr) noexcept : _ThisCommonMessage {libObjPtr}
 687     {
 688         BT_ASSERT_DBG(this->isEvent());
 689     }
 690
 691     template <typename OtherLibObjT>
 692     CommonEventMessage(const CommonEventMessage<OtherLibObjT> val) noexcept :
 693         _ThisCommonMessage {val}
 694     {
 695     }
 696
 697     template <typename OtherLibObjT>
 698     CommonEventMessage<LibObjT> operator=(const CommonEventMessage<OtherLibObjT> val) noexcept
 699     {
 700         _ThisCommonMessage::operator=(val);
 701         return *this;
 702     }
 703
 704     CommonEventMessage<const bt_message> asConst() const noexcept
 705     {
 706         return CommonEventMessage<const bt_message> {*this};
 707     }
 708
 709     _Event event() const noexcept
 710     {
 711         return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->libObjPtr())};
 712     }
 713
 714     bt2s::optional<ConstClockClass> streamClassDefaultClockClass() const noexcept
 715     {
 716         if (const auto libClkClsPtr =
 717                 bt_message_event_borrow_stream_class_default_clock_class_const(this->libObjPtr())) {
 718             return ConstClockClass {libClkClsPtr};
 719         }
 720
 721         return bt2s::nullopt;
 722     }
 723
 724     ConstClockSnapshot defaultClockSnapshot() const noexcept
 725     {
 726         const auto libObjPtr =
 727             bt_message_event_borrow_default_clock_snapshot_const(this->libObjPtr());
 728
 729         return ConstClockSnapshot {libObjPtr};
 730     }
 731
 732     Shared shared() const noexcept
 733     {
 734         return Shared::createWithRef(*this);
 735     }
 736 };
 737
 738 using EventMessage = CommonEventMessage<bt_message>;
 739 using ConstEventMessage = CommonEventMessage<const bt_message>;
 740
 741 namespace internal {
 742
 743 struct EventMessageTypeDescr
 744 {
 745     using Const = ConstEventMessage;
 746     using NonConst = EventMessage;
 747 };
 748
 749 template <>
 750 struct TypeDescr<EventMessage> : public EventMessageTypeDescr
 751 {
 752 };
 753
 754 template <>
 755 struct TypeDescr<ConstEventMessage> : public EventMessageTypeDescr
 756 {
 757 };
 758
 759 template <typename LibObjT>
 760 struct CommonDiscardedEventsMessageSpec;
 761
 762 /* Functions specific to mutable discarded events messages */
 763 template <>
 764 struct CommonDiscardedEventsMessageSpec<bt_message> final
 765 {
 766     static bt_stream *stream(bt_message * const libObjPtr) noexcept
 767     {
 768         return bt_message_discarded_events_borrow_stream(libObjPtr);
 769     }
 770 };
 771
 772 /* Functions specific to constant discarded events messages */
 773 template <>
 774 struct CommonDiscardedEventsMessageSpec<const bt_message> final
 775 {
 776     static const bt_stream *stream(const bt_message * const libObjPtr) noexcept
 777     {
 778         return bt_message_discarded_events_borrow_stream_const(libObjPtr);
 779     }
 780 };
 781
 782 } /* namespace internal */
 783
 784 template <typename LibObjT>
 785 class CommonDiscardedEventsMessage final : public CommonMessage<LibObjT>
 786 {
 787 private:
 788     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 789     using _Stream = internal::DepStream<LibObjT>;
 790
 791 public:
 792     using typename CommonMessage<LibObjT>::LibObjPtr;
 793     using Shared = SharedMessage<CommonDiscardedEventsMessage<LibObjT>, LibObjT>;
 794
 795     explicit CommonDiscardedEventsMessage(const LibObjPtr libObjPtr) noexcept :
 796         _ThisCommonMessage {libObjPtr}
 797     {
 798         BT_ASSERT_DBG(this->isDiscardedEvents());
 799     }
 800
 801     template <typename OtherLibObjT>
 802     CommonDiscardedEventsMessage(const CommonDiscardedEventsMessage<OtherLibObjT> val) noexcept :
 803         _ThisCommonMessage {val}
 804     {
 805     }
 806
 807     template <typename OtherLibObjT>
 808     CommonDiscardedEventsMessage<LibObjT>
 809     operator=(const CommonDiscardedEventsMessage<OtherLibObjT> val) noexcept
 810     {
 811         _ThisCommonMessage::operator=(val);
 812         return *this;
 813     }
 814
 815     CommonDiscardedEventsMessage<const bt_message> asConst() const noexcept
 816     {
 817         return CommonDiscardedEventsMessage<const bt_message> {*this};
 818     }
 819
 820     _Stream stream() const noexcept
 821     {
 822         return _Stream {
 823             internal::CommonDiscardedEventsMessageSpec<LibObjT>::stream(this->libObjPtr())};
 824     }
 825
 826     ConstClockSnapshot beginningDefaultClockSnapshot() const noexcept
 827     {
 828         const auto libObjPtr =
 829             bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
 830                 this->libObjPtr());
 831
 832         return ConstClockSnapshot {libObjPtr};
 833     }
 834
 835     ConstClockSnapshot endDefaultClockSnapshot() const noexcept
 836     {
 837         const auto libObjPtr =
 838             bt_message_discarded_events_borrow_end_default_clock_snapshot_const(this->libObjPtr());
 839
 840         return ConstClockSnapshot {libObjPtr};
 841     }
 842
 843     void count(const std::uint64_t count) const noexcept
 844     {
 845         static_assert(!std::is_const<LibObjT>::value,
 846                       "Not available with `bt2::ConstDiscardedEventsMessage`.");
 847
 848         bt_message_discarded_events_set_count(this->libObjPtr(), count);
 849     }
 850
 851     bt2s::optional<std::uint64_t> count() const noexcept
 852     {
 853         std::uint64_t count;
 854         const auto avail = bt_message_discarded_events_get_count(this->libObjPtr(), &count);
 855
 856         if (avail) {
 857             return count;
 858         }
 859
 860         return bt2s::nullopt;
 861     }
 862
 863     Shared shared() const noexcept
 864     {
 865         return Shared::createWithRef(*this);
 866     }
 867 };
 868
 869 using DiscardedEventsMessage = CommonDiscardedEventsMessage<bt_message>;
 870 using ConstDiscardedEventsMessage = CommonDiscardedEventsMessage<const bt_message>;
 871
 872 namespace internal {
 873
 874 struct DiscardedEventsMessageTypeDescr
 875 {
 876     using Const = ConstDiscardedEventsMessage;
 877     using NonConst = DiscardedEventsMessage;
 878 };
 879
 880 template <>
 881 struct TypeDescr<DiscardedEventsMessage> : public DiscardedEventsMessageTypeDescr
 882 {
 883 };
 884
 885 template <>
 886 struct TypeDescr<ConstDiscardedEventsMessage> : public DiscardedEventsMessageTypeDescr
 887 {
 888 };
 889
 890 template <typename LibObjT>
 891 struct CommonDiscardedPacketsMessageSpec;
 892
 893 /* Functions specific to mutable discarded packets messages */
 894 template <>
 895 struct CommonDiscardedPacketsMessageSpec<bt_message> final
 896 {
 897     static bt_stream *stream(bt_message * const libObjPtr) noexcept
 898     {
 899         return bt_message_discarded_packets_borrow_stream(libObjPtr);
 900     }
 901 };
 902
 903 /* Functions specific to constant discarded packets messages */
 904 template <>
 905 struct CommonDiscardedPacketsMessageSpec<const bt_message> final
 906 {
 907     static const bt_stream *stream(const bt_message * const libObjPtr) noexcept
 908     {
 909         return bt_message_discarded_packets_borrow_stream_const(libObjPtr);
 910     }
 911 };
 912
 913 } /* namespace internal */
 914
 915 template <typename LibObjT>
 916 class CommonDiscardedPacketsMessage final : public CommonMessage<LibObjT>
 917 {
 918 private:
 919     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 920     using _Stream = internal::DepStream<LibObjT>;
 921
 922 public:
 923     using typename CommonMessage<LibObjT>::LibObjPtr;
 924     using Shared = SharedMessage<CommonDiscardedPacketsMessage<LibObjT>, LibObjT>;
 925
 926     explicit CommonDiscardedPacketsMessage(const LibObjPtr libObjPtr) noexcept :
 927         _ThisCommonMessage {libObjPtr}
 928     {
 929         BT_ASSERT_DBG(this->isDiscardedPackets());
 930     }
 931
 932     template <typename OtherLibObjT>
 933     CommonDiscardedPacketsMessage(const CommonDiscardedPacketsMessage<OtherLibObjT> val) noexcept :
 934         _ThisCommonMessage {val}
 935     {
 936     }
 937
 938     template <typename OtherLibObjT>
 939     CommonDiscardedPacketsMessage<LibObjT>
 940     operator=(const CommonDiscardedPacketsMessage<OtherLibObjT> val) noexcept
 941     {
 942         _ThisCommonMessage::operator=(val);
 943         return *this;
 944     }
 945
 946     CommonDiscardedPacketsMessage<const bt_message> asConst() const noexcept
 947     {
 948         return CommonDiscardedPacketsMessage<const bt_message> {*this};
 949     }
 950
 951     _Stream stream() const noexcept
 952     {
 953         return _Stream {
 954             internal::CommonDiscardedPacketsMessageSpec<LibObjT>::stream(this->libObjPtr())};
 955     }
 956
 957     ConstClockSnapshot beginningDefaultClockSnapshot() const noexcept
 958     {
 959         const auto libObjPtr =
 960             bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
 961                 this->libObjPtr());
 962
 963         return ConstClockSnapshot {libObjPtr};
 964     }
 965
 966     ConstClockSnapshot endDefaultClockSnapshot() const noexcept
 967     {
 968         const auto libObjPtr =
 969             bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(this->libObjPtr());
 970
 971         return ConstClockSnapshot {libObjPtr};
 972     }
 973
 974     void count(const std::uint64_t count) const noexcept
 975     {
 976         static_assert(!std::is_const<LibObjT>::value,
 977                       "Not available with `bt2::ConstDiscardedPacketsMessage`.");
 978
 979         bt_message_discarded_packets_set_count(this->libObjPtr(), count);
 980     }
 981
 982     bt2s::optional<std::uint64_t> count() const noexcept
 983     {
 984         std::uint64_t count;
 985         const auto avail = bt_message_discarded_packets_get_count(this->libObjPtr(), &count);
 986
 987         if (avail) {
 988             return count;
 989         }
 990
 991         return bt2s::nullopt;
 992     }
 993
 994     Shared shared() const noexcept
 995     {
 996         return Shared::createWithRef(*this);
 997     }
 998 };
 999
1000 using DiscardedPacketsMessage = CommonDiscardedPacketsMessage<bt_message>;
1001 using ConstDiscardedPacketsMessage = CommonDiscardedPacketsMessage<const bt_message>;
1002
1003 namespace internal {
1004
1005 struct DiscardedPacketsMessageTypeDescr
1006 {
1007     using Const = ConstDiscardedPacketsMessage;
1008     using NonConst = DiscardedPacketsMessage;
1009 };
1010
1011 template <>
1012 struct TypeDescr<DiscardedPacketsMessage> : public DiscardedPacketsMessageTypeDescr
1013 {
1014 };
1015
1016 template <>
1017 struct TypeDescr<ConstDiscardedPacketsMessage> : public DiscardedPacketsMessageTypeDescr
1018 {
1019 };
1020
1021 } /* namespace internal */
1022
1023 template <typename LibObjT>
1024 class CommonMessageIteratorInactivityMessage final : public CommonMessage<LibObjT>
1025 {
1026 private:
1027     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
1028
1029 public:
1030     using typename CommonMessage<LibObjT>::LibObjPtr;
1031     using Shared = SharedMessage<CommonMessageIteratorInactivityMessage<LibObjT>, LibObjT>;
1032
1033     explicit CommonMessageIteratorInactivityMessage(const LibObjPtr libObjPtr) noexcept :
1034         _ThisCommonMessage {libObjPtr}
1035     {
1036         BT_ASSERT_DBG(this->isMessageIteratorInactivity());
1037     }
1038
1039     template <typename OtherLibObjT>
1040     CommonMessageIteratorInactivityMessage(
1041         const CommonMessageIteratorInactivityMessage<OtherLibObjT> val) noexcept :
1042         _ThisCommonMessage {val}
1043     {
1044     }
1045
1046     template <typename OtherLibObjT>
1047     CommonMessageIteratorInactivityMessage<LibObjT>
1048     operator=(const CommonMessageIteratorInactivityMessage<OtherLibObjT> val) noexcept
1049     {
1050         _ThisCommonMessage::operator=(val);
1051         return *this;
1052     }
1053
1054     CommonMessageIteratorInactivityMessage<const bt_message> asConst() const noexcept
1055     {
1056         return CommonMessageIteratorInactivityMessage<const bt_message> {*this};
1057     }
1058
1059     ConstClockSnapshot clockSnapshot() const noexcept
1060     {
1061         const auto libObjPtr =
1062             bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(this->libObjPtr());
1063
1064         return ConstClockSnapshot {libObjPtr};
1065     }
1066
1067     Shared shared() const noexcept
1068     {
1069         return Shared::createWithRef(*this);
1070     }
1071 };
1072
1073 using MessageIteratorInactivityMessage = CommonMessageIteratorInactivityMessage<bt_message>;
1074 using ConstMessageIteratorInactivityMessage =
1075     CommonMessageIteratorInactivityMessage<const bt_message>;
1076
1077 namespace internal {
1078
1079 struct MessageIteratorInactivityMessageTypeDescr
1080 {
1081     using Const = ConstMessageIteratorInactivityMessage;
1082     using NonConst = MessageIteratorInactivityMessage;
1083 };
1084
1085 template <>
1086 struct TypeDescr<MessageIteratorInactivityMessage> :
1087     public MessageIteratorInactivityMessageTypeDescr
1088 {
1089 };
1090
1091 template <>
1092 struct TypeDescr<ConstMessageIteratorInactivityMessage> :
1093     public MessageIteratorInactivityMessageTypeDescr
1094 {
1095 };
1096
1097 } /* namespace internal */
1098
1099 template <typename LibObjT>
1100 CommonStreamBeginningMessage<LibObjT> CommonMessage<LibObjT>::asStreamBeginning() const noexcept
1101 {
1102     BT_ASSERT_DBG(this->isStreamBeginning());
1103     return CommonStreamBeginningMessage<LibObjT> {this->libObjPtr()};
1104 }
1105
1106 template <typename LibObjT>
1107 CommonStreamEndMessage<LibObjT> CommonMessage<LibObjT>::asStreamEnd() const noexcept
1108 {
1109     BT_ASSERT_DBG(this->isStreamEnd());
1110     return CommonStreamEndMessage<LibObjT> {this->libObjPtr()};
1111 }
1112
1113 template <typename LibObjT>
1114 CommonPacketBeginningMessage<LibObjT> CommonMessage<LibObjT>::asPacketBeginning() const noexcept
1115 {
1116     BT_ASSERT_DBG(this->isPacketBeginning());
1117     return CommonPacketBeginningMessage<LibObjT> {this->libObjPtr()};
1118 }
1119
1120 template <typename LibObjT>
1121 CommonPacketEndMessage<LibObjT> CommonMessage<LibObjT>::asPacketEnd() const noexcept
1122 {
1123     BT_ASSERT_DBG(this->isPacketEnd());
1124     return CommonPacketEndMessage<LibObjT> {this->libObjPtr()};
1125 }
1126
1127 template <typename LibObjT>
1128 CommonEventMessage<LibObjT> CommonMessage<LibObjT>::asEvent() const noexcept
1129 {
1130     BT_ASSERT_DBG(this->isEvent());
1131     return CommonEventMessage<LibObjT> {this->libObjPtr()};
1132 }
1133
1134 template <typename LibObjT>
1135 CommonDiscardedEventsMessage<LibObjT> CommonMessage<LibObjT>::asDiscardedEvents() const noexcept
1136 {
1137     BT_ASSERT_DBG(this->isDiscardedEvents());
1138     return CommonDiscardedEventsMessage<LibObjT> {this->libObjPtr()};
1139 }
1140
1141 template <typename LibObjT>
1142 CommonDiscardedPacketsMessage<LibObjT> CommonMessage<LibObjT>::asDiscardedPackets() const noexcept
1143 {
1144     BT_ASSERT_DBG(this->isDiscardedPackets());
1145     return CommonDiscardedPacketsMessage<LibObjT> {this->libObjPtr()};
1146 }
1147
1148 template <typename LibObjT>
1149 CommonMessageIteratorInactivityMessage<LibObjT>
1150 CommonMessage<LibObjT>::asMessageIteratorInactivity() const noexcept
1151 {
1152     BT_ASSERT_DBG(this->isMessageIteratorInactivity());
1153     return CommonMessageIteratorInactivityMessage<LibObjT> {this->libObjPtr()};
1154 }
1155
1156 } /* namespace bt2 */
1157
1158 #endif /* BABELTRACE_CPP_COMMON_BT2_MESSAGE_HPP */