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/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 typename BorrowedObject<LibObjT>::_LibObjPtr;
  89     using _ThisCommonMessage = CommonMessage<LibObjT>;
  90
  91 public:
  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>::_LibObjPtr;
 232     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 233     using _Stream = internal::DepStream<LibObjT>;
 234
 235 public:
 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     nonstd::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 nonstd::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>::_LibObjPtr;
 347     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 348     using _Stream = internal::DepStream<LibObjT>;
 349
 350 public:
 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     nonstd::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 nonstd::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>::_LibObjPtr;
 461     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 462     using _Packet = internal::DepPacket<LibObjT>;
 463
 464 public:
 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>::_LibObjPtr;
 571     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 572     using _Packet = internal::DepPacket<LibObjT>;
 573
 574 public:
 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>::_LibObjPtr;
 680     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 681     using _Event = internal::DepType<LibObjT, CommonEvent<bt_event>, CommonEvent<const bt_event>>;
 682
 683 public:
 684     using Shared = SharedMessage<CommonEventMessage<LibObjT>, LibObjT>;
 685
 686     explicit CommonEventMessage(const _LibObjPtr libObjPtr) noexcept :
 687         _ThisCommonMessage {libObjPtr}
 688     {
 689         BT_ASSERT_DBG(this->isEvent());
 690     }
 691
 692     template <typename OtherLibObjT>
 693     CommonEventMessage(const CommonEventMessage<OtherLibObjT> val) noexcept :
 694         _ThisCommonMessage {val}
 695     {
 696     }
 697
 698     template <typename OtherLibObjT>
 699     CommonEventMessage<LibObjT> operator=(const CommonEventMessage<OtherLibObjT> val) noexcept
 700     {
 701         _ThisCommonMessage::operator=(val);
 702         return *this;
 703     }
 704
 705     CommonEventMessage<const bt_message> asConst() const noexcept
 706     {
 707         return CommonEventMessage<const bt_message> {*this};
 708     }
 709
 710     _Event event() const noexcept
 711     {
 712         return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->libObjPtr())};
 713     }
 714
 715     ConstClockSnapshot defaultClockSnapshot() const noexcept
 716     {
 717         const auto libObjPtr =
 718             bt_message_event_borrow_default_clock_snapshot_const(this->libObjPtr());
 719
 720         return ConstClockSnapshot {libObjPtr};
 721     }
 722
 723     Shared shared() const noexcept
 724     {
 725         return Shared::createWithRef(*this);
 726     }
 727 };
 728
 729 using EventMessage = CommonEventMessage<bt_message>;
 730 using ConstEventMessage = CommonEventMessage<const bt_message>;
 731
 732 namespace internal {
 733
 734 struct EventMessageTypeDescr
 735 {
 736     using Const = ConstEventMessage;
 737     using NonConst = EventMessage;
 738 };
 739
 740 template <>
 741 struct TypeDescr<EventMessage> : public EventMessageTypeDescr
 742 {
 743 };
 744
 745 template <>
 746 struct TypeDescr<ConstEventMessage> : public EventMessageTypeDescr
 747 {
 748 };
 749
 750 template <typename LibObjT>
 751 struct CommonDiscardedEventsMessageSpec;
 752
 753 /* Functions specific to mutable discarded events messages */
 754 template <>
 755 struct CommonDiscardedEventsMessageSpec<bt_message> final
 756 {
 757     static bt_stream *stream(bt_message * const libObjPtr) noexcept
 758     {
 759         return bt_message_discarded_events_borrow_stream(libObjPtr);
 760     }
 761 };
 762
 763 /* Functions specific to constant discarded events messages */
 764 template <>
 765 struct CommonDiscardedEventsMessageSpec<const bt_message> final
 766 {
 767     static const bt_stream *stream(const bt_message * const libObjPtr) noexcept
 768     {
 769         return bt_message_discarded_events_borrow_stream_const(libObjPtr);
 770     }
 771 };
 772
 773 } /* namespace internal */
 774
 775 template <typename LibObjT>
 776 class CommonDiscardedEventsMessage final : public CommonMessage<LibObjT>
 777 {
 778 private:
 779     using typename CommonMessage<LibObjT>::_LibObjPtr;
 780     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 781     using _Stream = internal::DepStream<LibObjT>;
 782
 783 public:
 784     using Shared = SharedMessage<CommonDiscardedEventsMessage<LibObjT>, LibObjT>;
 785
 786     explicit CommonDiscardedEventsMessage(const _LibObjPtr libObjPtr) noexcept :
 787         _ThisCommonMessage {libObjPtr}
 788     {
 789         BT_ASSERT_DBG(this->isDiscardedEvents());
 790     }
 791
 792     template <typename OtherLibObjT>
 793     CommonDiscardedEventsMessage(const CommonDiscardedEventsMessage<OtherLibObjT> val) noexcept :
 794         _ThisCommonMessage {val}
 795     {
 796     }
 797
 798     template <typename OtherLibObjT>
 799     CommonDiscardedEventsMessage<LibObjT>
 800     operator=(const CommonDiscardedEventsMessage<OtherLibObjT> val) noexcept
 801     {
 802         _ThisCommonMessage::operator=(val);
 803         return *this;
 804     }
 805
 806     CommonDiscardedEventsMessage<const bt_message> asConst() const noexcept
 807     {
 808         return CommonDiscardedEventsMessage<const bt_message> {*this};
 809     }
 810
 811     _Stream stream() const noexcept
 812     {
 813         return _Stream {
 814             internal::CommonDiscardedEventsMessageSpec<LibObjT>::stream(this->libObjPtr())};
 815     }
 816
 817     ConstClockSnapshot beginningDefaultClockSnapshot() const noexcept
 818     {
 819         const auto libObjPtr =
 820             bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
 821                 this->libObjPtr());
 822
 823         return ConstClockSnapshot {libObjPtr};
 824     }
 825
 826     ConstClockSnapshot endDefaultClockSnapshot() const noexcept
 827     {
 828         const auto libObjPtr =
 829             bt_message_discarded_events_borrow_end_default_clock_snapshot_const(this->libObjPtr());
 830
 831         return ConstClockSnapshot {libObjPtr};
 832     }
 833
 834     void count(const std::uint64_t count) const noexcept
 835     {
 836         static_assert(!std::is_const<LibObjT>::value,
 837                       "Not available with `bt2::ConstDiscardedEventsMessage`.");
 838
 839         bt_message_discarded_events_set_count(this->libObjPtr(), count);
 840     }
 841
 842     nonstd::optional<std::uint64_t> count() const noexcept
 843     {
 844         std::uint64_t count;
 845         const auto avail = bt_message_discarded_events_get_count(this->libObjPtr(), &count);
 846
 847         if (avail) {
 848             return count;
 849         }
 850
 851         return nonstd::nullopt;
 852     }
 853
 854     Shared shared() const noexcept
 855     {
 856         return Shared::createWithRef(*this);
 857     }
 858 };
 859
 860 using DiscardedEventsMessage = CommonDiscardedEventsMessage<bt_message>;
 861 using ConstDiscardedEventsMessage = CommonDiscardedEventsMessage<const bt_message>;
 862
 863 namespace internal {
 864
 865 struct DiscardedEventsMessageTypeDescr
 866 {
 867     using Const = ConstDiscardedEventsMessage;
 868     using NonConst = DiscardedEventsMessage;
 869 };
 870
 871 template <>
 872 struct TypeDescr<DiscardedEventsMessage> : public DiscardedEventsMessageTypeDescr
 873 {
 874 };
 875
 876 template <>
 877 struct TypeDescr<ConstDiscardedEventsMessage> : public DiscardedEventsMessageTypeDescr
 878 {
 879 };
 880
 881 template <typename LibObjT>
 882 struct CommonDiscardedPacketsMessageSpec;
 883
 884 /* Functions specific to mutable discarded packets messages */
 885 template <>
 886 struct CommonDiscardedPacketsMessageSpec<bt_message> final
 887 {
 888     static bt_stream *stream(bt_message * const libObjPtr) noexcept
 889     {
 890         return bt_message_discarded_packets_borrow_stream(libObjPtr);
 891     }
 892 };
 893
 894 /* Functions specific to constant discarded packets messages */
 895 template <>
 896 struct CommonDiscardedPacketsMessageSpec<const bt_message> final
 897 {
 898     static const bt_stream *stream(const bt_message * const libObjPtr) noexcept
 899     {
 900         return bt_message_discarded_packets_borrow_stream_const(libObjPtr);
 901     }
 902 };
 903
 904 } /* namespace internal */
 905
 906 template <typename LibObjT>
 907 class CommonDiscardedPacketsMessage final : public CommonMessage<LibObjT>
 908 {
 909 private:
 910     using typename CommonMessage<LibObjT>::_LibObjPtr;
 911     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
 912     using _Stream = internal::DepStream<LibObjT>;
 913
 914 public:
 915     using Shared = SharedMessage<CommonDiscardedPacketsMessage<LibObjT>, LibObjT>;
 916
 917     explicit CommonDiscardedPacketsMessage(const _LibObjPtr libObjPtr) noexcept :
 918         _ThisCommonMessage {libObjPtr}
 919     {
 920         BT_ASSERT_DBG(this->isDiscardedPackets());
 921     }
 922
 923     template <typename OtherLibObjT>
 924     CommonDiscardedPacketsMessage(const CommonDiscardedPacketsMessage<OtherLibObjT> val) noexcept :
 925         _ThisCommonMessage {val}
 926     {
 927     }
 928
 929     template <typename OtherLibObjT>
 930     CommonDiscardedPacketsMessage<LibObjT>
 931     operator=(const CommonDiscardedPacketsMessage<OtherLibObjT> val) noexcept
 932     {
 933         _ThisCommonMessage::operator=(val);
 934         return *this;
 935     }
 936
 937     CommonDiscardedPacketsMessage<const bt_message> asConst() const noexcept
 938     {
 939         return CommonDiscardedPacketsMessage<const bt_message> {*this};
 940     }
 941
 942     _Stream stream() const noexcept
 943     {
 944         return _Stream {
 945             internal::CommonDiscardedPacketsMessageSpec<LibObjT>::stream(this->libObjPtr())};
 946     }
 947
 948     ConstClockSnapshot beginningDefaultClockSnapshot() const noexcept
 949     {
 950         const auto libObjPtr =
 951             bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
 952                 this->libObjPtr());
 953
 954         return ConstClockSnapshot {libObjPtr};
 955     }
 956
 957     ConstClockSnapshot endDefaultClockSnapshot() const noexcept
 958     {
 959         const auto libObjPtr =
 960             bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(this->libObjPtr());
 961
 962         return ConstClockSnapshot {libObjPtr};
 963     }
 964
 965     void count(const std::uint64_t count) const noexcept
 966     {
 967         static_assert(!std::is_const<LibObjT>::value,
 968                       "Not available with `bt2::ConstDiscardedPacketsMessage`.");
 969
 970         bt_message_discarded_packets_set_count(this->libObjPtr(), count);
 971     }
 972
 973     nonstd::optional<std::uint64_t> count() const noexcept
 974     {
 975         std::uint64_t count;
 976         const auto avail = bt_message_discarded_packets_get_count(this->libObjPtr(), &count);
 977
 978         if (avail) {
 979             return count;
 980         }
 981
 982         return nonstd::nullopt;
 983     }
 984
 985     Shared shared() const noexcept
 986     {
 987         return Shared::createWithRef(*this);
 988     }
 989 };
 990
 991 using DiscardedPacketsMessage = CommonDiscardedPacketsMessage<bt_message>;
 992 using ConstDiscardedPacketsMessage = CommonDiscardedPacketsMessage<const bt_message>;
 993
 994 namespace internal {
 995
 996 struct DiscardedPacketsMessageTypeDescr
 997 {
 998     using Const = ConstDiscardedPacketsMessage;
 999     using NonConst = DiscardedPacketsMessage;
1000 };
1001
1002 template <>
1003 struct TypeDescr<DiscardedPacketsMessage> : public DiscardedPacketsMessageTypeDescr
1004 {
1005 };
1006
1007 template <>
1008 struct TypeDescr<ConstDiscardedPacketsMessage> : public DiscardedPacketsMessageTypeDescr
1009 {
1010 };
1011
1012 } /* namespace internal */
1013
1014 template <typename LibObjT>
1015 class CommonMessageIteratorInactivityMessage final : public CommonMessage<LibObjT>
1016 {
1017 private:
1018     using typename CommonMessage<LibObjT>::_LibObjPtr;
1019     using typename CommonMessage<LibObjT>::_ThisCommonMessage;
1020
1021 public:
1022     using Shared = SharedMessage<CommonMessageIteratorInactivityMessage<LibObjT>, LibObjT>;
1023
1024     explicit CommonMessageIteratorInactivityMessage(const _LibObjPtr libObjPtr) noexcept :
1025         _ThisCommonMessage {libObjPtr}
1026     {
1027         BT_ASSERT_DBG(this->isMessageIteratorInactivity());
1028     }
1029
1030     template <typename OtherLibObjT>
1031     CommonMessageIteratorInactivityMessage(
1032         const CommonMessageIteratorInactivityMessage<OtherLibObjT> val) noexcept :
1033         _ThisCommonMessage {val}
1034     {
1035     }
1036
1037     template <typename OtherLibObjT>
1038     CommonMessageIteratorInactivityMessage<LibObjT>
1039     operator=(const CommonMessageIteratorInactivityMessage<OtherLibObjT> val) noexcept
1040     {
1041         _ThisCommonMessage::operator=(val);
1042         return *this;
1043     }
1044
1045     CommonMessageIteratorInactivityMessage<const bt_message> asConst() const noexcept
1046     {
1047         return CommonMessageIteratorInactivityMessage<const bt_message> {*this};
1048     }
1049
1050     ConstClockSnapshot clockSnapshot() const noexcept
1051     {
1052         const auto libObjPtr =
1053             bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(this->libObjPtr());
1054
1055         return ConstClockSnapshot {libObjPtr};
1056     }
1057
1058     Shared shared() const noexcept
1059     {
1060         return Shared::createWithRef(*this);
1061     }
1062 };
1063
1064 using MessageIteratorInactivityMessage = CommonMessageIteratorInactivityMessage<bt_message>;
1065 using ConstMessageIteratorInactivityMessage =
1066     CommonMessageIteratorInactivityMessage<const bt_message>;
1067
1068 namespace internal {
1069
1070 struct MessageIteratorInactivityMessageTypeDescr
1071 {
1072     using Const = ConstMessageIteratorInactivityMessage;
1073     using NonConst = MessageIteratorInactivityMessage;
1074 };
1075
1076 template <>
1077 struct TypeDescr<MessageIteratorInactivityMessage> :
1078     public MessageIteratorInactivityMessageTypeDescr
1079 {
1080 };
1081
1082 template <>
1083 struct TypeDescr<ConstMessageIteratorInactivityMessage> :
1084     public MessageIteratorInactivityMessageTypeDescr
1085 {
1086 };
1087
1088 } /* namespace internal */
1089
1090 template <typename LibObjT>
1091 CommonStreamBeginningMessage<LibObjT> CommonMessage<LibObjT>::asStreamBeginning() const noexcept
1092 {
1093     BT_ASSERT_DBG(this->isStreamBeginning());
1094     return CommonStreamBeginningMessage<LibObjT> {this->libObjPtr()};
1095 }
1096
1097 template <typename LibObjT>
1098 CommonStreamEndMessage<LibObjT> CommonMessage<LibObjT>::asStreamEnd() const noexcept
1099 {
1100     BT_ASSERT_DBG(this->isStreamEnd());
1101     return CommonStreamEndMessage<LibObjT> {this->libObjPtr()};
1102 }
1103
1104 template <typename LibObjT>
1105 CommonPacketBeginningMessage<LibObjT> CommonMessage<LibObjT>::asPacketBeginning() const noexcept
1106 {
1107     BT_ASSERT_DBG(this->isPacketBeginning());
1108     return CommonPacketBeginningMessage<LibObjT> {this->libObjPtr()};
1109 }
1110
1111 template <typename LibObjT>
1112 CommonPacketEndMessage<LibObjT> CommonMessage<LibObjT>::asPacketEnd() const noexcept
1113 {
1114     BT_ASSERT_DBG(this->isPacketEnd());
1115     return CommonPacketEndMessage<LibObjT> {this->libObjPtr()};
1116 }
1117
1118 template <typename LibObjT>
1119 CommonEventMessage<LibObjT> CommonMessage<LibObjT>::asEvent() const noexcept
1120 {
1121     BT_ASSERT_DBG(this->isEvent());
1122     return CommonEventMessage<LibObjT> {this->libObjPtr()};
1123 }
1124
1125 template <typename LibObjT>
1126 CommonDiscardedEventsMessage<LibObjT> CommonMessage<LibObjT>::asDiscardedEvents() const noexcept
1127 {
1128     BT_ASSERT_DBG(this->isDiscardedEvents());
1129     return CommonDiscardedEventsMessage<LibObjT> {this->libObjPtr()};
1130 }
1131
1132 template <typename LibObjT>
1133 CommonDiscardedPacketsMessage<LibObjT> CommonMessage<LibObjT>::asDiscardedPackets() const noexcept
1134 {
1135     BT_ASSERT_DBG(this->isDiscardedPackets());
1136     return CommonDiscardedPacketsMessage<LibObjT> {this->libObjPtr()};
1137 }
1138
1139 template <typename LibObjT>
1140 CommonMessageIteratorInactivityMessage<LibObjT>
1141 CommonMessage<LibObjT>::asMessageIteratorInactivity() const noexcept
1142 {
1143     BT_ASSERT_DBG(this->isMessageIteratorInactivity());
1144     return CommonMessageIteratorInactivityMessage<LibObjT> {this->libObjPtr()};
1145 }
1146
1147 } /* namespace bt2 */
1148
1149 #endif /* BABELTRACE_CPP_COMMON_BT2_MESSAGE_HPP */