[babeltrace.git] / bindings / python / bt2 / bt2 / message.py

# The MIT License (MIT)
#
# Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

from bt2 import native_bt, object, utils
import bt2.clock_snapshot
import bt2.packet
import bt2.stream
import bt2.event
import bt2


def _create_from_ptr(ptr):
    msg_type = native_bt.message_get_type(ptr)

    if msg_type not in _MESSAGE_TYPE_TO_CLS:
        raise bt2.Error('unknown message type: {}'.format(msg_type))

    return _MESSAGE_TYPE_TO_CLS[msg_type]._create_from_ptr(ptr)


class _Message(object._SharedObject):
    _get_ref = staticmethod(native_bt.message_get_ref)
    _put_ref = staticmethod(native_bt.message_put_ref)


class _MessageWithDefaultClockSnapshot:
    def _get_default_clock_snapshot(self, borrow_clock_snapshot_ptr):
        if not self._has_default_clock_class:
            raise bt2.NoDefaultClockClass('cannot get default clock snapshot, stream class has no default clock class')

        snapshot_ptr = borrow_clock_snapshot_ptr(self._ptr)

        return bt2.clock_snapshot._ClockSnapshot._create_from_ptr_and_get_ref(
            snapshot_ptr, self._ptr, self._get_ref, self._put_ref)


class _EventMessage(_Message, _MessageWithDefaultClockSnapshot):
    _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_event_borrow_default_clock_snapshot_const)

    @property
    def _has_default_clock_class(self):
        return self.event.packet.stream.stream_class.default_clock_class is not None

    @property
    def default_clock_snapshot(self):
        return self._get_default_clock_snapshot(self._borrow_default_clock_snapshot_ptr)

    @property
    def event(self):
        event_ptr = native_bt.message_event_borrow_event(self._ptr)
        assert event_ptr is not None
        return bt2.event._Event._create_from_ptr_and_get_ref(
            event_ptr, self._ptr, self._get_ref, self._put_ref)


class _PacketMessage(_Message, _MessageWithDefaultClockSnapshot):
    @property
    def _has_default_clock_class(self):
        return self.packet.stream.stream_class.default_clock_class is not None

    @property
    def default_clock_snapshot(self):
        return self._get_default_clock_snapshot(self._borrow_default_clock_snapshot_ptr)

    @property
    def packet(self):
        packet_ptr = self._borrow_packet_ptr(self._ptr)
        assert packet_ptr is not None
        return bt2.packet._Packet._create_from_ptr_and_get_ref(packet_ptr)


class _PacketBeginningMessage(_PacketMessage):
    _borrow_packet_ptr = staticmethod(native_bt.message_packet_beginning_borrow_packet)
    _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_packet_beginning_borrow_default_clock_snapshot_const)


class _PacketEndMessage(_PacketMessage):
    _borrow_packet_ptr = staticmethod(native_bt.message_packet_end_borrow_packet)
    _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_packet_end_borrow_default_clock_snapshot_const)


class _StreamMessage(_Message):
    @property
    def stream(self):
        stream_ptr = self._borrow_stream_ptr(self._ptr)
        assert stream_ptr
        return bt2.stream._Stream._create_from_ptr_and_get_ref(stream_ptr)


class _StreamBeginningMessage(_StreamMessage):
    _borrow_stream_ptr = staticmethod(native_bt.message_stream_beginning_borrow_stream)


class _StreamEndMessage(_StreamMessage):
    _borrow_stream_ptr = staticmethod(native_bt.message_stream_end_borrow_stream)


class _StreamActivityMessage(_Message):
    @property
    def default_clock_snapshot(self):
        if self.stream.stream_class.default_clock_class is None:
            raise bt2.NoDefaultClockClass('cannot get default clock snapshot, stream class has no default clock class')

        status, snapshot_ptr = self._borrow_default_clock_snapshot_ptr(self._ptr)

        if status == native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_KNOWN:
            snapshot_type = bt2.clock_snapshot._ClockSnapshot
        elif status == native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_UNKNOWN:
            snapshot_type = bt2.clock_snapshot._UnknownClockSnapshot
        elif status == native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_INFINITE:
            snapshot_type = bt2.clock_snapshot._InfiniteClockSnapshot
        else:
            raise bt2.Error('cannot borrow default clock snapshot from message')

        assert snapshot_ptr is not None

        return snapshot_type._create_from_ptr_and_get_ref(
            snapshot_ptr, self._ptr, self._get_ref, self._put_ref)

    def _default_clock_snapshot(self, value):
        self._set_default_clock_snapshot_ptr(self._ptr, value)

    _default_clock_snapshot = property(fset=_default_clock_snapshot)

    @property
    def stream(self):
        stream_ptr = self._borrow_stream_ptr(self._ptr)
        assert stream_ptr
        return bt2.stream._Stream._create_from_ptr_and_get_ref(stream_ptr)


class _StreamActivityBeginningMessage(_StreamActivityMessage):
    _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_beginning_borrow_default_clock_snapshot_const)
    _set_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_beginning_set_default_clock_snapshot)
    _borrow_stream_ptr = staticmethod(native_bt.message_stream_activity_beginning_borrow_stream)


class _StreamActivityEndMessage(_StreamActivityMessage):
    _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_end_borrow_default_clock_snapshot_const)
    _set_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_end_set_default_clock_snapshot)
    _borrow_stream_ptr = staticmethod(native_bt.message_stream_activity_end_borrow_stream)


class _MessageIteratorInactivityMessage(_Message, _MessageWithDefaultClockSnapshot):
    # This kind of message always has a default clock class.
    _has_default_clock_class = True
    _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_message_iterator_inactivity_borrow_default_clock_snapshot_const)

    @property
    def default_clock_snapshot(self):
        return self._get_default_clock_snapshot(self._borrow_default_clock_snapshot_ptr)


class _DiscardedMessage(_Message, _MessageWithDefaultClockSnapshot):
    @property
    def stream(self):
        stream_ptr = self._borrow_stream_ptr(self._ptr)
        assert stream_ptr
        return bt2.stream._Stream._create_from_ptr_and_get_ref(stream_ptr)

    @property
    def _has_default_clock_class(self):
        return self.default_clock_class is not None

    @property
    def default_clock_class(self):
        cc_ptr = self._borrow_clock_class_ptr(self._ptr)
        if cc_ptr is not None:
            return bt2.clock_class._ClockClass._create_from_ptr_and_get_ref(cc_ptr)

    @property
    def count(self):
        avail, count = self._get_count(self._ptr)
        if avail is native_bt.PROPERTY_AVAILABILITY_AVAILABLE:
            return count

    def _set_count(self, count):
        utils._check_uint64(count)
        self._set_count(self._ptr, count)

    _count = property(fset=_set_count)

    @property
    def beginning_default_clock_snapshot(self):
        return self._get_default_clock_snapshot(self._borrow_beginning_clock_snapshot_ptr)

    @property
    def end_default_clock_snapshot(self):
        return self._get_default_clock_snapshot(self._borrow_end_clock_snapshot_ptr)


class _DiscardedEventsMessage(_DiscardedMessage):
    _borrow_stream_ptr = staticmethod(native_bt.message_discarded_events_borrow_stream_const)
    _get_count = staticmethod(native_bt.message_discarded_events_get_count)
    _set_count = staticmethod(native_bt.message_discarded_events_set_count)
    _borrow_clock_class_ptr = staticmethod(native_bt.message_discarded_events_borrow_stream_class_default_clock_class_const)
    _borrow_beginning_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_events_borrow_default_beginning_clock_snapshot_const)
    _borrow_end_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_events_borrow_default_end_clock_snapshot_const)


class _DiscardedPacketsMessage(_DiscardedMessage):
    _borrow_stream_ptr = staticmethod(native_bt.message_discarded_packets_borrow_stream_const)
    _get_count = staticmethod(native_bt.message_discarded_packets_get_count)
    _set_count = staticmethod(native_bt.message_discarded_packets_set_count)
    _borrow_clock_class_ptr = staticmethod(native_bt.message_discarded_packets_borrow_stream_class_default_clock_class_const)
    _borrow_beginning_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_packets_borrow_default_beginning_clock_snapshot_const)
    _borrow_end_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_packets_borrow_default_end_clock_snapshot_const)


_MESSAGE_TYPE_TO_CLS = {
    native_bt.MESSAGE_TYPE_EVENT: _EventMessage,
    native_bt.MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY: _MessageIteratorInactivityMessage,
    native_bt.MESSAGE_TYPE_STREAM_BEGINNING: _StreamBeginningMessage,
    native_bt.MESSAGE_TYPE_STREAM_END: _StreamEndMessage,
    native_bt.MESSAGE_TYPE_PACKET_BEGINNING: _PacketBeginningMessage,
    native_bt.MESSAGE_TYPE_PACKET_END: _PacketEndMessage,
    native_bt.MESSAGE_TYPE_STREAM_ACTIVITY_BEGINNING: _StreamActivityBeginningMessage,
    native_bt.MESSAGE_TYPE_STREAM_ACTIVITY_END: _StreamActivityEndMessage,
    native_bt.MESSAGE_TYPE_DISCARDED_EVENTS: _DiscardedEventsMessage,
    native_bt.MESSAGE_TYPE_DISCARDED_PACKETS: _DiscardedPacketsMessage,
}
Commit	Line	Data
	1	# The MIT License (MIT)
	2	#
	3	# Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
	4	#
	5	# Permission is hereby granted, free of charge, to any person obtaining a copy
	6	# of this software and associated documentation files (the "Software"), to deal
	7	# in the Software without restriction, including without limitation the rights
	8	# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	9	# copies of the Software, and to permit persons to whom the Software is
	10	# furnished to do so, subject to the following conditions:
	11	#
	12	# The above copyright notice and this permission notice shall be included in
	13	# all copies or substantial portions of the Software.
	14	#
	15	# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	18	# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	21	# THE SOFTWARE.
	22
	23	from bt2 import native_bt, object, utils
	24	import bt2.clock_snapshot
	25	import bt2.packet
	26	import bt2.stream
	27	import bt2.event
	28	import bt2
	29
	30
	31	def _create_from_ptr(ptr):
	32	msg_type = native_bt.message_get_type(ptr)
	33
	34	if msg_type not in _MESSAGE_TYPE_TO_CLS:
	35	raise bt2.Error('unknown message type: {}'.format(msg_type))
	36
	37	return _MESSAGE_TYPE_TO_CLS[msg_type]._create_from_ptr(ptr)
	38
	39
	40	class _Message(object._SharedObject):
	41	_get_ref = staticmethod(native_bt.message_get_ref)
	42	_put_ref = staticmethod(native_bt.message_put_ref)
	43
	44
	45	class _MessageWithDefaultClockSnapshot:
	46	def _get_default_clock_snapshot(self, borrow_clock_snapshot_ptr):
	47	if not self._has_default_clock_class:
	48	raise bt2.NoDefaultClockClass('cannot get default clock snapshot, stream class has no default clock class')
	49
	50	snapshot_ptr = borrow_clock_snapshot_ptr(self._ptr)
	51
	52	return bt2.clock_snapshot._ClockSnapshot._create_from_ptr_and_get_ref(
	53	snapshot_ptr, self._ptr, self._get_ref, self._put_ref)
	54
	55
	56	class _EventMessage(_Message, _MessageWithDefaultClockSnapshot):
	57	_borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_event_borrow_default_clock_snapshot_const)
	58
	59	@property
	60	def _has_default_clock_class(self):
	61	return self.event.packet.stream.stream_class.default_clock_class is not None
	62
	63	@property
	64	def default_clock_snapshot(self):
	65	return self._get_default_clock_snapshot(self._borrow_default_clock_snapshot_ptr)
	66
	67	@property
	68	def event(self):
	69	event_ptr = native_bt.message_event_borrow_event(self._ptr)
	70	assert event_ptr is not None
	71	return bt2.event._Event._create_from_ptr_and_get_ref(
	72	event_ptr, self._ptr, self._get_ref, self._put_ref)
	73
	74
	75	class _PacketMessage(_Message, _MessageWithDefaultClockSnapshot):
	76	@property
	77	def _has_default_clock_class(self):
	78	return self.packet.stream.stream_class.default_clock_class is not None
	79
	80	@property
	81	def default_clock_snapshot(self):
	82	return self._get_default_clock_snapshot(self._borrow_default_clock_snapshot_ptr)
	83
	84	@property
	85	def packet(self):
	86	packet_ptr = self._borrow_packet_ptr(self._ptr)
	87	assert packet_ptr is not None
	88	return bt2.packet._Packet._create_from_ptr_and_get_ref(packet_ptr)
	89
	90
	91	class _PacketBeginningMessage(_PacketMessage):
	92	_borrow_packet_ptr = staticmethod(native_bt.message_packet_beginning_borrow_packet)
	93	_borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_packet_beginning_borrow_default_clock_snapshot_const)
	94
	95
	96	class _PacketEndMessage(_PacketMessage):
	97	_borrow_packet_ptr = staticmethod(native_bt.message_packet_end_borrow_packet)
	98	_borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_packet_end_borrow_default_clock_snapshot_const)
	99
	100
	101	class _StreamMessage(_Message):
	102	@property
	103	def stream(self):
	104	stream_ptr = self._borrow_stream_ptr(self._ptr)
	105	assert stream_ptr
	106	return bt2.stream._Stream._create_from_ptr_and_get_ref(stream_ptr)
	107
	108
	109	class _StreamBeginningMessage(_StreamMessage):
	110	_borrow_stream_ptr = staticmethod(native_bt.message_stream_beginning_borrow_stream)
	111
	112
	113	class _StreamEndMessage(_StreamMessage):
	114	_borrow_stream_ptr = staticmethod(native_bt.message_stream_end_borrow_stream)
	115
	116
	117	class _StreamActivityMessage(_Message):
	118	@property
	119	def default_clock_snapshot(self):
	120	if self.stream.stream_class.default_clock_class is None:
	121	raise bt2.NoDefaultClockClass('cannot get default clock snapshot, stream class has no default clock class')
	122
	123	status, snapshot_ptr = self._borrow_default_clock_snapshot_ptr(self._ptr)
	124
	125	if status == native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_KNOWN:
	126	snapshot_type = bt2.clock_snapshot._ClockSnapshot
	127	elif status == native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_UNKNOWN:
	128	snapshot_type = bt2.clock_snapshot._UnknownClockSnapshot
	129	elif status == native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_INFINITE:
	130	snapshot_type = bt2.clock_snapshot._InfiniteClockSnapshot
	131	else:
	132	raise bt2.Error('cannot borrow default clock snapshot from message')
	133
	134	assert snapshot_ptr is not None
	135
	136	return snapshot_type._create_from_ptr_and_get_ref(
	137	snapshot_ptr, self._ptr, self._get_ref, self._put_ref)
	138
	139	def _default_clock_snapshot(self, value):
	140	self._set_default_clock_snapshot_ptr(self._ptr, value)
	141
	142	_default_clock_snapshot = property(fset=_default_clock_snapshot)
	143
	144	@property
	145	def stream(self):
	146	stream_ptr = self._borrow_stream_ptr(self._ptr)
	147	assert stream_ptr
	148	return bt2.stream._Stream._create_from_ptr_and_get_ref(stream_ptr)
	149
	150
	151	class _StreamActivityBeginningMessage(_StreamActivityMessage):
	152	_borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_beginning_borrow_default_clock_snapshot_const)
	153	_set_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_beginning_set_default_clock_snapshot)
	154	_borrow_stream_ptr = staticmethod(native_bt.message_stream_activity_beginning_borrow_stream)
	155
	156
	157	class _StreamActivityEndMessage(_StreamActivityMessage):
	158	_borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_end_borrow_default_clock_snapshot_const)
	159	_set_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_end_set_default_clock_snapshot)
	160	_borrow_stream_ptr = staticmethod(native_bt.message_stream_activity_end_borrow_stream)
	161
	162
	163	class _MessageIteratorInactivityMessage(_Message, _MessageWithDefaultClockSnapshot):
	164	# This kind of message always has a default clock class.
	165	_has_default_clock_class = True
	166	_borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_message_iterator_inactivity_borrow_default_clock_snapshot_const)
	167
	168	@property
	169	def default_clock_snapshot(self):
	170	return self._get_default_clock_snapshot(self._borrow_default_clock_snapshot_ptr)
	171
	172
	173	class _DiscardedMessage(_Message, _MessageWithDefaultClockSnapshot):
	174	@property
	175	def stream(self):
	176	stream_ptr = self._borrow_stream_ptr(self._ptr)
	177	assert stream_ptr
	178	return bt2.stream._Stream._create_from_ptr_and_get_ref(stream_ptr)
	179
	180	@property
	181	def _has_default_clock_class(self):
	182	return self.default_clock_class is not None
	183
	184	@property
	185	def default_clock_class(self):
	186	cc_ptr = self._borrow_clock_class_ptr(self._ptr)
	187	if cc_ptr is not None:
	188	return bt2.clock_class._ClockClass._create_from_ptr_and_get_ref(cc_ptr)
	189
	190	@property
	191	def count(self):
	192	avail, count = self._get_count(self._ptr)
	193	if avail is native_bt.PROPERTY_AVAILABILITY_AVAILABLE:
	194	return count
	195
	196	def _set_count(self, count):
	197	utils._check_uint64(count)
	198	self._set_count(self._ptr, count)
	199
	200	_count = property(fset=_set_count)
	201
	202	@property
	203	def beginning_default_clock_snapshot(self):
	204	return self._get_default_clock_snapshot(self._borrow_beginning_clock_snapshot_ptr)
	205
	206	@property
	207	def end_default_clock_snapshot(self):
	208	return self._get_default_clock_snapshot(self._borrow_end_clock_snapshot_ptr)
	209
	210
	211	class _DiscardedEventsMessage(_DiscardedMessage):
	212	_borrow_stream_ptr = staticmethod(native_bt.message_discarded_events_borrow_stream_const)
	213	_get_count = staticmethod(native_bt.message_discarded_events_get_count)
	214	_set_count = staticmethod(native_bt.message_discarded_events_set_count)
	215	_borrow_clock_class_ptr = staticmethod(native_bt.message_discarded_events_borrow_stream_class_default_clock_class_const)
	216	_borrow_beginning_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_events_borrow_default_beginning_clock_snapshot_const)
	217	_borrow_end_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_events_borrow_default_end_clock_snapshot_const)
	218
	219
	220	class _DiscardedPacketsMessage(_DiscardedMessage):
	221	_borrow_stream_ptr = staticmethod(native_bt.message_discarded_packets_borrow_stream_const)
	222	_get_count = staticmethod(native_bt.message_discarded_packets_get_count)
	223	_set_count = staticmethod(native_bt.message_discarded_packets_set_count)
	224	_borrow_clock_class_ptr = staticmethod(native_bt.message_discarded_packets_borrow_stream_class_default_clock_class_const)
	225	_borrow_beginning_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_packets_borrow_default_beginning_clock_snapshot_const)
	226	_borrow_end_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_packets_borrow_default_end_clock_snapshot_const)
	227
	228
	229	_MESSAGE_TYPE_TO_CLS = {
	230	native_bt.MESSAGE_TYPE_EVENT: _EventMessage,
	231	native_bt.MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY: _MessageIteratorInactivityMessage,
	232	native_bt.MESSAGE_TYPE_STREAM_BEGINNING: _StreamBeginningMessage,
	233	native_bt.MESSAGE_TYPE_STREAM_END: _StreamEndMessage,
	234	native_bt.MESSAGE_TYPE_PACKET_BEGINNING: _PacketBeginningMessage,
	235	native_bt.MESSAGE_TYPE_PACKET_END: _PacketEndMessage,
	236	native_bt.MESSAGE_TYPE_STREAM_ACTIVITY_BEGINNING: _StreamActivityBeginningMessage,
	237	native_bt.MESSAGE_TYPE_STREAM_ACTIVITY_END: _StreamActivityEndMessage,
	238	native_bt.MESSAGE_TYPE_DISCARDED_EVENTS: _DiscardedEventsMessage,
	239	native_bt.MESSAGE_TYPE_DISCARDED_PACKETS: _DiscardedPacketsMessage,
	240	}