cpp-common/bt2: remove unnecessary mentions of `bt2::`

[babeltrace.git] / src / cpp-common / bt2 / self-message-iterator.hpp

diff --git a/src/cpp-common/bt2/self-message-iterator.hpp b/src/cpp-common/bt2/self-message-iterator.hpp
index 5d296eea42ede724ef950336654dce164522f225..609514543aa286d47c51b7d794ae2057523c1390 100644 (file)
--- a/src/cpp-common/bt2/self-message-iterator.hpp
+++ b/src/cpp-common/bt2/self-message-iterator.hpp
@@ -9,7 +9,6 @@
 
 #include <babeltrace2/babeltrace.h>
 
-#include "common/assert.h"
 #include "common/common.h"
 
 #include "borrowed-object.hpp"
@@ -21,7 +20,7 @@ namespace bt2 {
 class SelfMessageIterator final : public BorrowedObject<bt_self_message_iterator>
 {
 public:
-    explicit SelfMessageIterator(const _LibObjPtr libObjPtr) noexcept :
+    explicit SelfMessageIterator(const LibObjPtr libObjPtr) noexcept :
         _ThisBorrowedObject {libObjPtr}
     {
     }
@@ -34,7 +33,6 @@ public:
 
         switch (status) {
         case BT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_OK:
-            BT_ASSERT(libMsgIterPtr);
             return MessageIterator::Shared::createWithoutRef(libMsgIterPtr);
         case BT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_MEMORY_ERROR:
             throw MemoryError {};
@@ -67,9 +65,208 @@ public:
     }
 
     template <typename T>
-    void data(T& obj) const noexcept
+    SelfMessageIterator data(T& obj) const noexcept
     {
-        bt_self_message_iterator_set_data(this->libObjPtr(), static_cast<void *>(&obj));
+        bt_self_message_iterator_set_data(this->libObjPtr(),
+                                          const_cast<void *>(static_cast<const void *>(&obj)));
+        return *this;
+    }
+
+    StreamBeginningMessage::Shared createStreamBeginningMessage(const ConstStream stream) const
+    {
+        const auto libObjPtr =
+            bt_message_stream_beginning_create(this->libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return StreamBeginningMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    StreamEndMessage::Shared createStreamEndMessage(const ConstStream stream) const
+    {
+        const auto libObjPtr = bt_message_stream_end_create(this->libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return StreamEndMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
+                                            const ConstStream stream) const
+    {
+        const auto libObjPtr =
+            bt_message_event_create(this->libObjPtr(), eventCls.libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return EventMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
+                                            const ConstStream stream,
+                                            const std::uint64_t clockSnapshotValue) const
+    {
+        const auto libObjPtr = bt_message_event_create_with_default_clock_snapshot(
+            this->libObjPtr(), eventCls.libObjPtr(), stream.libObjPtr(), clockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return EventMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
+                                            const ConstPacket packet) const
+    {
+        const auto libObjPtr = bt_message_event_create_with_packet(
+            this->libObjPtr(), eventCls.libObjPtr(), packet.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return EventMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
+                                            const ConstPacket packet,
+                                            const std::uint64_t clockSnapshotValue) const
+    {
+        const auto libObjPtr = bt_message_event_create_with_packet_and_default_clock_snapshot(
+            this->libObjPtr(), eventCls.libObjPtr(), packet.libObjPtr(), clockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return EventMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    PacketBeginningMessage::Shared createPacketBeginningMessage(const ConstPacket packet) const
+    {
+        const auto libObjPtr =
+            bt_message_packet_beginning_create(this->libObjPtr(), packet.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    PacketBeginningMessage::Shared
+    createPacketBeginningMessage(const ConstPacket packet,
+                                 const std::uint64_t clockSnapshotValue) const
+    {
+        const auto libObjPtr = bt_message_packet_beginning_create_with_default_clock_snapshot(
+            this->libObjPtr(), packet.libObjPtr(), clockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    PacketEndMessage::Shared createPacketEndMessage(const ConstPacket packet) const
+    {
+        const auto libObjPtr = bt_message_packet_end_create(this->libObjPtr(), packet.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return PacketEndMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    PacketEndMessage::Shared createPacketEndMessage(const ConstPacket packet,
+                                                    const std::uint64_t clockSnapshotValue) const
+    {
+        const auto libObjPtr = bt_message_packet_end_create_with_default_clock_snapshot(
+            this->libObjPtr(), packet.libObjPtr(), clockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return PacketEndMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    DiscardedEventsMessage::Shared createDiscardedEventsMessage(const ConstStream stream)
+    {
+        const auto libObjPtr =
+            bt_message_discarded_events_create(this->libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    DiscardedEventsMessage::Shared
+    createDiscardedEventsMessage(const ConstStream stream,
+                                 const std::uint64_t beginningClockSnapshotValue,
+                                 const std::uint64_t endClockSnapshotValue) const
+    {
+        const auto libObjPtr = bt_message_discarded_events_create_with_default_clock_snapshots(
+            this->libObjPtr(), stream.libObjPtr(), beginningClockSnapshotValue,
+            endClockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    DiscardedPacketsMessage::Shared createDiscardedPacketsMessage(const ConstStream stream) const
+    {
+        const auto libObjPtr =
+            bt_message_discarded_packets_create(this->libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    DiscardedPacketsMessage::Shared
+    createDiscardedPacketsMessage(const ConstStream stream,
+                                  const std::uint64_t beginningClockSnapshotValue,
+                                  const std::uint64_t endClockSnapshotValue) const
+    {
+        const auto libObjPtr = bt_message_discarded_packets_create_with_default_clock_snapshots(
+            this->libObjPtr(), stream.libObjPtr(), beginningClockSnapshotValue,
+            endClockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    MessageIteratorInactivityMessage::Shared
+    createMessageIteratorInactivityMessage(const ConstClockClass clockClass,
+                                           const std::uint64_t clockSnapshotValue) const
+    {
+        const auto libObjPtr = bt_message_message_iterator_inactivity_create(
+            this->libObjPtr(), clockClass.libObjPtr(), clockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return MessageIteratorInactivityMessage::Shared::createWithoutRef(libObjPtr);
     }
 };