cpp-common/bt2: add message creation methods to `SelfMessageIterator`

Add methods on `SelfMessageIterator` to create all possible kinds of
messages.

Change-Id: I44b5be4e0783affef619983530d8af619560569f
Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/11790
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Tested-by: jenkins <jenkins@lttng.org>

diff --git a/src/cpp-common/bt2/self-message-iterator.hpp b/src/cpp-common/bt2/self-message-iterator.hpp
index 4eeabe6033bed413299453b1b6625e3ec73194fe..e333cb1a41587d62990ce0f4807198c0f551cf9c 100644 (file)
--- a/src/cpp-common/bt2/self-message-iterator.hpp
+++ b/src/cpp-common/bt2/self-message-iterator.hpp
@@ -71,6 +71,207 @@ public:
     {
         bt_self_message_iterator_set_data(this->libObjPtr(), static_cast<void *>(&obj));
     }
+
+    bt2::StreamBeginningMessage::Shared
+    createStreamBeginningMessage(const bt2::ConstStream stream) const
+    {
+        const auto libObjPtr =
+            bt_message_stream_beginning_create(this->libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::StreamBeginningMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::StreamEndMessage::Shared createStreamEndMessage(const bt2::ConstStream stream) const
+    {
+        const auto libObjPtr = bt_message_stream_end_create(this->libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::StreamEndMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::EventMessage::Shared createEventMessage(const bt2::ConstEventClass eventCls,
+                                                 const bt2::ConstStream stream) const
+    {
+        const auto libObjPtr =
+            bt_message_event_create(this->libObjPtr(), eventCls.libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::EventMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::EventMessage::Shared createEventMessage(const bt2::ConstEventClass eventCls,
+                                                 const bt2::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 bt2::EventMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::EventMessage::Shared createEventMessage(const bt2::ConstEventClass eventCls,
+                                                 const bt2::ConstPacket packet) const
+    {
+        const auto libObjPtr = bt_message_event_create_with_packet(
+            this->libObjPtr(), eventCls.libObjPtr(), packet.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::EventMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::EventMessage::Shared createEventMessage(const bt2::ConstEventClass eventCls,
+                                                 const bt2::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 bt2::EventMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::PacketBeginningMessage::Shared
+    createPacketBeginningMessage(const bt2::ConstPacket packet) const
+    {
+        const auto libObjPtr =
+            bt_message_packet_beginning_create(this->libObjPtr(), packet.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::PacketBeginningMessage::Shared
+    createPacketBeginningMessage(const bt2::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 bt2::PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::PacketEndMessage::Shared createPacketEndMessage(const bt2::ConstPacket packet) const
+    {
+        const auto libObjPtr = bt_message_packet_end_create(this->libObjPtr(), packet.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::PacketEndMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::PacketEndMessage::Shared
+    createPacketEndMessage(const bt2::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 bt2::PacketEndMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::DiscardedEventsMessage::Shared createDiscardedEventsMessage(const bt2::ConstStream stream)
+    {
+        const auto libObjPtr =
+            bt_message_discarded_events_create(this->libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::DiscardedEventsMessage::Shared
+    createDiscardedEventsMessage(const bt2::ConstStream stream,
+                                 const std::uint64_t beginningClockSnapshotValue,
+                                 const std::uint64_t endClockSnapshotValue)
+    {
+        const auto libObjPtr = bt_message_discarded_events_create_with_default_clock_snapshots(
+            this->libObjPtr(), stream.libObjPtr(), beginningClockSnapshotValue,
+            endClockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::DiscardedPacketsMessage::Shared
+    createDiscardedPacketsMessage(const bt2::ConstStream stream)
+    {
+        const auto libObjPtr =
+            bt_message_discarded_packets_create(this->libObjPtr(), stream.libObjPtr());
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::DiscardedPacketsMessage::Shared
+    createDiscardedPacketsMessage(const bt2::ConstStream stream,
+                                  const std::uint64_t beginningClockSnapshotValue,
+                                  const std::uint64_t endClockSnapshotValue)
+    {
+        const auto libObjPtr = bt_message_discarded_packets_create_with_default_clock_snapshots(
+            this->libObjPtr(), stream.libObjPtr(), beginningClockSnapshotValue,
+            endClockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
+    }
+
+    bt2::MessageIteratorInactivityMessage::Shared
+    createMessageIteratorInactivityMessage(const bt2::ConstClockClass clockClass,
+                                           const std::uint64_t clockSnapshotValue)
+    {
+        const auto libObjPtr = bt_message_message_iterator_inactivity_create(
+            this->libObjPtr(), clockClass.libObjPtr(), clockSnapshotValue);
+
+        if (!libObjPtr) {
+            throw MemoryError {};
+        }
+
+        return bt2::MessageIteratorInactivityMessage::Shared::createWithoutRef(libObjPtr);
+    }
 };
 
 } /* namespace bt2 */