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

/*
 * Copyright (c) 2023 Philippe Proulx <pproulx@efficios.com>
 *
 * SPDX-License-Identifier: MIT
 */

#ifndef BABELTRACE_CPP_COMMON_BT2_SELF_MESSAGE_ITERATOR_HPP
#define BABELTRACE_CPP_COMMON_BT2_SELF_MESSAGE_ITERATOR_HPP

#include <babeltrace2/babeltrace.h>

#include "common/common.h"

#include "borrowed-object.hpp"
#include "message-iterator.hpp"
#include "self-component-port.hpp"

namespace bt2 {

class SelfMessageIterator final : public BorrowedObject<bt_self_message_iterator>
{
public:
    explicit SelfMessageIterator(const LibObjPtr libObjPtr) noexcept :
        _ThisBorrowedObject {libObjPtr}
    {
    }

    MessageIterator::Shared createMessageIterator(const SelfComponentInputPort port) const
    {
        bt_message_iterator *libMsgIterPtr = nullptr;
        const auto status = bt_message_iterator_create_from_message_iterator(
            this->libObjPtr(), port.libObjPtr(), &libMsgIterPtr);

        switch (status) {
        case BT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_OK:
            return MessageIterator::Shared::createWithoutRef(libMsgIterPtr);
        case BT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_MEMORY_ERROR:
            throw MemoryError {};
        case BT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_ERROR:
            throw Error {};
        default:
            bt_common_abort();
        }
    }

    SelfComponent component() const noexcept
    {
        return SelfComponent {bt_self_message_iterator_borrow_component(this->libObjPtr())};
    }

    SelfComponentOutputPort port() const noexcept
    {
        return SelfComponentOutputPort {bt_self_message_iterator_borrow_port(this->libObjPtr())};
    }

    bool isInterrupted() const noexcept
    {
        return static_cast<bool>(bt_self_message_iterator_is_interrupted(this->libObjPtr()));
    }

    template <typename T>
    T& data() const noexcept
    {
        return *static_cast<T *>(bt_self_message_iterator_get_data(this->libObjPtr()));
    }

    template <typename T>
    SelfMessageIterator data(T& obj) const noexcept
    {
        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);
    }
};

} /* namespace bt2 */

#endif /* BABELTRACE_CPP_COMMON_BT2_SELF_MESSAGE_ITERATOR_HPP */
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2023 Philippe Proulx <pproulx@efficios.com>
	3	*
	4	* SPDX-License-Identifier: MIT
	5	*/
	6
	7	#ifndef BABELTRACE_CPP_COMMON_BT2_SELF_MESSAGE_ITERATOR_HPP
	8	#define BABELTRACE_CPP_COMMON_BT2_SELF_MESSAGE_ITERATOR_HPP
	9
	10	#include <babeltrace2/babeltrace.h>
	11
	12	#include "common/common.h"
	13
	14	#include "borrowed-object.hpp"
	15	#include "message-iterator.hpp"
	16	#include "self-component-port.hpp"
	17
	18	namespace bt2 {
	19
	20	class SelfMessageIterator final : public BorrowedObject<bt_self_message_iterator>
	21	{
	22	public:
	23	explicit SelfMessageIterator(const LibObjPtr libObjPtr) noexcept :
	24	_ThisBorrowedObject {libObjPtr}
	25	{
	26	}
	27
	28	MessageIterator::Shared createMessageIterator(const SelfComponentInputPort port) const
	29	{
	30	bt_message_iterator *libMsgIterPtr = nullptr;
	31	const auto status = bt_message_iterator_create_from_message_iterator(
	32	this->libObjPtr(), port.libObjPtr(), &libMsgIterPtr);
	33
	34	switch (status) {
	35	case BT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_OK:
	36	return MessageIterator::Shared::createWithoutRef(libMsgIterPtr);
	37	case BT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_MEMORY_ERROR:
	38	throw MemoryError {};
	39	case BT_MESSAGE_ITERATOR_CREATE_FROM_MESSAGE_ITERATOR_STATUS_ERROR:
	40	throw Error {};
	41	default:
	42	bt_common_abort();
	43	}
	44	}
	45
	46	SelfComponent component() const noexcept
	47	{
	48	return SelfComponent {bt_self_message_iterator_borrow_component(this->libObjPtr())};
	49	}
	50
	51	SelfComponentOutputPort port() const noexcept
	52	{
	53	return SelfComponentOutputPort {bt_self_message_iterator_borrow_port(this->libObjPtr())};
	54	}
	55
	56	bool isInterrupted() const noexcept
	57	{
	58	return static_cast<bool>(bt_self_message_iterator_is_interrupted(this->libObjPtr()));
	59	}
	60
	61	template <typename T>
	62	T& data() const noexcept
	63	{
	64	return static_cast<T >(bt_self_message_iterator_get_data(this->libObjPtr()));
	65	}
	66
	67	template <typename T>
	68	SelfMessageIterator data(T& obj) const noexcept
	69	{
	70	bt_self_message_iterator_set_data(this->libObjPtr(),
	71	const_cast<void >(static_cast<const void >(&obj)));
	72	return *this;
	73	}
	74
	75	StreamBeginningMessage::Shared createStreamBeginningMessage(const ConstStream stream) const
	76	{
	77	const auto libObjPtr =
	78	bt_message_stream_beginning_create(this->libObjPtr(), stream.libObjPtr());
	79
	80	if (!libObjPtr) {
	81	throw MemoryError {};
	82	}
	83
	84	return StreamBeginningMessage::Shared::createWithoutRef(libObjPtr);
	85	}
	86
	87	StreamEndMessage::Shared createStreamEndMessage(const ConstStream stream) const
	88	{
	89	const auto libObjPtr = bt_message_stream_end_create(this->libObjPtr(), stream.libObjPtr());
	90
	91	if (!libObjPtr) {
	92	throw MemoryError {};
	93	}
	94
	95	return StreamEndMessage::Shared::createWithoutRef(libObjPtr);
	96	}
	97
	98	EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
	99	const ConstStream stream) const
	100	{
	101	const auto libObjPtr =
	102	bt_message_event_create(this->libObjPtr(), eventCls.libObjPtr(), stream.libObjPtr());
	103
	104	if (!libObjPtr) {
	105	throw MemoryError {};
	106	}
	107
	108	return EventMessage::Shared::createWithoutRef(libObjPtr);
	109	}
	110
	111	EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
	112	const ConstStream stream,
	113	const std::uint64_t clockSnapshotValue) const
	114	{
	115	const auto libObjPtr = bt_message_event_create_with_default_clock_snapshot(
	116	this->libObjPtr(), eventCls.libObjPtr(), stream.libObjPtr(), clockSnapshotValue);
	117
	118	if (!libObjPtr) {
	119	throw MemoryError {};
	120	}
	121
	122	return EventMessage::Shared::createWithoutRef(libObjPtr);
	123	}
	124
	125	EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
	126	const ConstPacket packet) const
	127	{
	128	const auto libObjPtr = bt_message_event_create_with_packet(
	129	this->libObjPtr(), eventCls.libObjPtr(), packet.libObjPtr());
	130
	131	if (!libObjPtr) {
	132	throw MemoryError {};
	133	}
	134
	135	return EventMessage::Shared::createWithoutRef(libObjPtr);
	136	}
	137
	138	EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
	139	const ConstPacket packet,
	140	const std::uint64_t clockSnapshotValue) const
	141	{
	142	const auto libObjPtr = bt_message_event_create_with_packet_and_default_clock_snapshot(
	143	this->libObjPtr(), eventCls.libObjPtr(), packet.libObjPtr(), clockSnapshotValue);
	144
	145	if (!libObjPtr) {
	146	throw MemoryError {};
	147	}
	148
	149	return EventMessage::Shared::createWithoutRef(libObjPtr);
	150	}
	151
	152	PacketBeginningMessage::Shared createPacketBeginningMessage(const ConstPacket packet) const
	153	{
	154	const auto libObjPtr =
	155	bt_message_packet_beginning_create(this->libObjPtr(), packet.libObjPtr());
	156
	157	if (!libObjPtr) {
	158	throw MemoryError {};
	159	}
	160
	161	return PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
	162	}
	163
	164	PacketBeginningMessage::Shared
	165	createPacketBeginningMessage(const ConstPacket packet,
	166	const std::uint64_t clockSnapshotValue) const
	167	{
	168	const auto libObjPtr = bt_message_packet_beginning_create_with_default_clock_snapshot(
	169	this->libObjPtr(), packet.libObjPtr(), clockSnapshotValue);
	170
	171	if (!libObjPtr) {
	172	throw MemoryError {};
	173	}
	174
	175	return PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
	176	}
	177
	178	PacketEndMessage::Shared createPacketEndMessage(const ConstPacket packet) const
	179	{
	180	const auto libObjPtr = bt_message_packet_end_create(this->libObjPtr(), packet.libObjPtr());
	181
	182	if (!libObjPtr) {
	183	throw MemoryError {};
	184	}
	185
	186	return PacketEndMessage::Shared::createWithoutRef(libObjPtr);
	187	}
	188
	189	PacketEndMessage::Shared createPacketEndMessage(const ConstPacket packet,
	190	const std::uint64_t clockSnapshotValue) const
	191	{
	192	const auto libObjPtr = bt_message_packet_end_create_with_default_clock_snapshot(
	193	this->libObjPtr(), packet.libObjPtr(), clockSnapshotValue);
	194
	195	if (!libObjPtr) {
	196	throw MemoryError {};
	197	}
	198
	199	return PacketEndMessage::Shared::createWithoutRef(libObjPtr);
	200	}
	201
	202	DiscardedEventsMessage::Shared createDiscardedEventsMessage(const ConstStream stream)
	203	{
	204	const auto libObjPtr =
	205	bt_message_discarded_events_create(this->libObjPtr(), stream.libObjPtr());
	206
	207	if (!libObjPtr) {
	208	throw MemoryError {};
	209	}
	210
	211	return DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
	212	}
	213
	214	DiscardedEventsMessage::Shared
	215	createDiscardedEventsMessage(const ConstStream stream,
	216	const std::uint64_t beginningClockSnapshotValue,
	217	const std::uint64_t endClockSnapshotValue) const
	218	{
	219	const auto libObjPtr = bt_message_discarded_events_create_with_default_clock_snapshots(
	220	this->libObjPtr(), stream.libObjPtr(), beginningClockSnapshotValue,
	221	endClockSnapshotValue);
	222
	223	if (!libObjPtr) {
	224	throw MemoryError {};
	225	}
	226
	227	return DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
	228	}
	229
	230	DiscardedPacketsMessage::Shared createDiscardedPacketsMessage(const ConstStream stream) const
	231	{
	232	const auto libObjPtr =
	233	bt_message_discarded_packets_create(this->libObjPtr(), stream.libObjPtr());
	234
	235	if (!libObjPtr) {
	236	throw MemoryError {};
	237	}
	238
	239	return DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
	240	}
	241
	242	DiscardedPacketsMessage::Shared
	243	createDiscardedPacketsMessage(const ConstStream stream,
	244	const std::uint64_t beginningClockSnapshotValue,
	245	const std::uint64_t endClockSnapshotValue) const
	246	{
	247	const auto libObjPtr = bt_message_discarded_packets_create_with_default_clock_snapshots(
	248	this->libObjPtr(), stream.libObjPtr(), beginningClockSnapshotValue,
	249	endClockSnapshotValue);
	250
	251	if (!libObjPtr) {
	252	throw MemoryError {};
	253	}
	254
	255	return DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
	256	}
	257
	258	MessageIteratorInactivityMessage::Shared
	259	createMessageIteratorInactivityMessage(const ConstClockClass clockClass,
	260	const std::uint64_t clockSnapshotValue) const
	261	{
	262	const auto libObjPtr = bt_message_message_iterator_inactivity_create(
	263	this->libObjPtr(), clockClass.libObjPtr(), clockSnapshotValue);
	264
	265	if (!libObjPtr) {
	266	throw MemoryError {};
	267	}
	268
	269	return MessageIteratorInactivityMessage::Shared::createWithoutRef(libObjPtr);
	270	}
	271	};
	272
	273	} /* namespace bt2 */
	274
	275	#endif /* BABELTRACE_CPP_COMMON_BT2_SELF_MESSAGE_ITERATOR_HPP */