src/bindings/python/bt2/bt2/message.py

   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     @staticmethod
  45     def _check_has_default_clock_class(clock_class):
  46         if clock_class is None:
  47             raise bt2.NonexistentClockSnapshot('cannot get default clock snapshot: stream class has no default clock class')
  48
  49
  50 class _MessageWithDefaultClockSnapshot:
  51     def _get_default_clock_snapshot(self, borrow_clock_snapshot_ptr):
  52         snapshot_ptr = borrow_clock_snapshot_ptr(self._ptr)
  53
  54         return bt2.clock_snapshot._ClockSnapshot._create_from_ptr_and_get_ref(
  55             snapshot_ptr, self._ptr, self._get_ref, self._put_ref)
  56
  57
  58 class _EventMessage(_Message, _MessageWithDefaultClockSnapshot):
  59     _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_event_borrow_default_clock_snapshot_const)
  60
  61     @property
  62     def default_clock_snapshot(self):
  63         self._check_has_default_clock_class(self.event.packet.stream.cls.default_clock_class)
  64         return self._get_default_clock_snapshot(self._borrow_default_clock_snapshot_ptr)
  65
  66     @property
  67     def event(self):
  68         event_ptr = native_bt.message_event_borrow_event(self._ptr)
  69         assert event_ptr is not None
  70         return bt2.event._Event._create_from_ptr_and_get_ref(
  71             event_ptr, self._ptr, self._get_ref, self._put_ref)
  72
  73
  74 class _PacketMessage(_Message, _MessageWithDefaultClockSnapshot):
  75     @property
  76     def default_clock_snapshot(self):
  77         self._check_has_default_clock_class(self.packet.stream.cls.default_clock_class)
  78         return self._get_default_clock_snapshot(self._borrow_default_clock_snapshot_ptr)
  79
  80     @property
  81     def packet(self):
  82         packet_ptr = self._borrow_packet_ptr(self._ptr)
  83         assert packet_ptr is not None
  84         return bt2.packet._Packet._create_from_ptr_and_get_ref(packet_ptr)
  85
  86
  87 class _PacketBeginningMessage(_PacketMessage):
  88     _borrow_packet_ptr = staticmethod(native_bt.message_packet_beginning_borrow_packet)
  89     _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_packet_beginning_borrow_default_clock_snapshot_const)
  90
  91
  92 class _PacketEndMessage(_PacketMessage):
  93     _borrow_packet_ptr = staticmethod(native_bt.message_packet_end_borrow_packet)
  94     _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_packet_end_borrow_default_clock_snapshot_const)
  95
  96
  97 class _StreamMessage(_Message):
  98     @property
  99     def stream(self):
 100         stream_ptr = self._borrow_stream_ptr(self._ptr)
 101         assert stream_ptr
 102         return bt2.stream._Stream._create_from_ptr_and_get_ref(stream_ptr)
 103
 104
 105 class _StreamBeginningMessage(_StreamMessage):
 106     _borrow_stream_ptr = staticmethod(native_bt.message_stream_beginning_borrow_stream)
 107
 108
 109 class _StreamEndMessage(_StreamMessage):
 110     _borrow_stream_ptr = staticmethod(native_bt.message_stream_end_borrow_stream)
 111
 112
 113 # Specific type to pass an unknown clock snapshot when creating a stream
 114 # beginning/end message.
 115 class _StreamActivityMessageUnknownClockSnapshot:
 116     pass
 117
 118
 119 # Specific type to pass an infinite clock snapshot when creating a
 120 # stream beginning/end message.
 121 class _StreamActivityMessageInfiniteClockSnapshot:
 122     pass
 123
 124
 125 class _StreamActivityMessage(_Message):
 126     @property
 127     def default_clock_snapshot(self):
 128         status, snapshot_ptr = self._borrow_default_clock_snapshot_ptr(self._ptr)
 129
 130         if status == native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_KNOWN:
 131             cs_type = bt2.clock_snapshot._ClockSnapshot
 132             assert snapshot_ptr is not None
 133             return cs_type._create_from_ptr_and_get_ref(snapshot_ptr, self._ptr,
 134                                                         self._get_ref, self._put_ref)
 135         elif status == native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_UNKNOWN:
 136             return bt2.clock_snapshot._UnknownClockSnapshot()
 137         elif status == native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_INFINITE:
 138             return bt2.clock_snapshot._InfiniteClockSnapshot()
 139         else:
 140             raise bt2.Error('cannot borrow default clock snapshot from message')
 141
 142     def _default_clock_snapshot(self, value):
 143         if type(value) is _StreamActivityMessageUnknownClockSnapshot:
 144             self._set_default_clock_snapshot_state(self._ptr, native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_UNKNOWN)
 145         elif type(value) is _StreamActivityMessageInfiniteClockSnapshot:
 146             self._set_default_clock_snapshot_state(self._ptr, native_bt.MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_INFINITE)
 147         else:
 148             assert utils._is_uint64(value)
 149             self._set_default_clock_snapshot(self._ptr, value)
 150
 151     _default_clock_snapshot = property(fset=_default_clock_snapshot)
 152
 153     @property
 154     def stream(self):
 155         stream_ptr = self._borrow_stream_ptr(self._ptr)
 156         assert stream_ptr
 157         return bt2.stream._Stream._create_from_ptr_and_get_ref(stream_ptr)
 158
 159
 160 class _StreamActivityBeginningMessage(_StreamActivityMessage):
 161     _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_beginning_borrow_default_clock_snapshot_const)
 162     _set_default_clock_snapshot = staticmethod(native_bt.message_stream_activity_beginning_set_default_clock_snapshot)
 163     _set_default_clock_snapshot_state = staticmethod(native_bt.message_stream_activity_beginning_set_default_clock_snapshot_state)
 164     _borrow_stream_ptr = staticmethod(native_bt.message_stream_activity_beginning_borrow_stream)
 165
 166
 167 class _StreamActivityEndMessage(_StreamActivityMessage):
 168     _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_stream_activity_end_borrow_default_clock_snapshot_const)
 169     _set_default_clock_snapshot = staticmethod(native_bt.message_stream_activity_end_set_default_clock_snapshot)
 170     _set_default_clock_snapshot_state = staticmethod(native_bt.message_stream_activity_end_set_default_clock_snapshot_state)
 171     _borrow_stream_ptr = staticmethod(native_bt.message_stream_activity_end_borrow_stream)
 172
 173
 174 class _MessageIteratorInactivityMessage(_Message, _MessageWithDefaultClockSnapshot):
 175     _borrow_default_clock_snapshot_ptr = staticmethod(native_bt.message_message_iterator_inactivity_borrow_default_clock_snapshot_const)
 176
 177     @property
 178     def default_clock_snapshot(self):
 179         # This kind of message always has a default clock class: no
 180         # need to call self._check_has_default_clock_class() here.
 181         return self._get_default_clock_snapshot(self._borrow_default_clock_snapshot_ptr)
 182
 183
 184 class _DiscardedMessage(_Message, _MessageWithDefaultClockSnapshot):
 185     @property
 186     def stream(self):
 187         stream_ptr = self._borrow_stream_ptr(self._ptr)
 188         assert stream_ptr
 189         return bt2.stream._Stream._create_from_ptr_and_get_ref(stream_ptr)
 190
 191     @property
 192     def count(self):
 193         avail, count = self._get_count(self._ptr)
 194         if avail is native_bt.PROPERTY_AVAILABILITY_AVAILABLE:
 195             return count
 196
 197     def _set_count(self, count):
 198         utils._check_uint64(count)
 199         self._set_count(self._ptr, count)
 200
 201     _count = property(fset=_set_count)
 202
 203     def _check_has_default_clock_snapshots(self):
 204         if not self._has_default_clock_snapshots:
 205             raise bt2.NonexistentClockSnapshot('cannot get default clock snapshot: such a message has no clock snapshots for this stream class')
 206
 207     @property
 208     def beginning_default_clock_snapshot(self):
 209         self._check_has_default_clock_snapshots()
 210         return self._get_default_clock_snapshot(self._borrow_beginning_clock_snapshot_ptr)
 211
 212     @property
 213     def end_default_clock_snapshot(self):
 214         self._check_has_default_clock_snapshots()
 215         return self._get_default_clock_snapshot(self._borrow_end_clock_snapshot_ptr)
 216
 217
 218 class _DiscardedEventsMessage(_DiscardedMessage):
 219     _borrow_stream_ptr = staticmethod(native_bt.message_discarded_events_borrow_stream_const)
 220     _get_count = staticmethod(native_bt.message_discarded_events_get_count)
 221     _set_count = staticmethod(native_bt.message_discarded_events_set_count)
 222     _borrow_beginning_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_events_borrow_beginning_default_clock_snapshot_const)
 223     _borrow_end_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_events_borrow_end_default_clock_snapshot_const)
 224
 225     @property
 226     def _has_default_clock_snapshots(self):
 227         return self.stream.cls.discarded_events_have_default_clock_snapshots
 228
 229
 230 class _DiscardedPacketsMessage(_DiscardedMessage):
 231     _borrow_stream_ptr = staticmethod(native_bt.message_discarded_packets_borrow_stream_const)
 232     _get_count = staticmethod(native_bt.message_discarded_packets_get_count)
 233     _set_count = staticmethod(native_bt.message_discarded_packets_set_count)
 234     _borrow_beginning_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_packets_borrow_beginning_default_clock_snapshot_const)
 235     _borrow_end_clock_snapshot_ptr = staticmethod(native_bt.message_discarded_packets_borrow_end_default_clock_snapshot_const)
 236
 237     @property
 238     def _has_default_clock_snapshots(self):
 239         return self.stream.cls.discarded_packets_have_default_clock_snapshots
 240
 241
 242 _MESSAGE_TYPE_TO_CLS = {
 243     native_bt.MESSAGE_TYPE_EVENT: _EventMessage,
 244     native_bt.MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY: _MessageIteratorInactivityMessage,
 245     native_bt.MESSAGE_TYPE_STREAM_BEGINNING: _StreamBeginningMessage,
 246     native_bt.MESSAGE_TYPE_STREAM_END: _StreamEndMessage,
 247     native_bt.MESSAGE_TYPE_PACKET_BEGINNING: _PacketBeginningMessage,
 248     native_bt.MESSAGE_TYPE_PACKET_END: _PacketEndMessage,
 249     native_bt.MESSAGE_TYPE_STREAM_ACTIVITY_BEGINNING: _StreamActivityBeginningMessage,
 250     native_bt.MESSAGE_TYPE_STREAM_ACTIVITY_END: _StreamActivityEndMessage,
 251     native_bt.MESSAGE_TYPE_DISCARDED_EVENTS: _DiscardedEventsMessage,
 252     native_bt.MESSAGE_TYPE_DISCARDED_PACKETS: _DiscardedPacketsMessage,
 253 }