bindings/python/bt2/bt2/message_iterator.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.message
  25 import collections.abc
  26 import bt2.component
  27 import bt2
  28
  29
  30 class _MessageIterator(collections.abc.Iterator):
  31     def _handle_status(self, status, gen_error_msg):
  32         if status == native_bt.MESSAGE_ITERATOR_STATUS_AGAIN:
  33             raise bt2.TryAgain
  34         elif status == native_bt.MESSAGE_ITERATOR_STATUS_END:
  35             raise bt2.Stop
  36         elif status < 0:
  37             raise bt2.Error(gen_error_msg)
  38
  39     def __next__(self):
  40         raise NotImplementedError
  41
  42
  43 class _GenericMessageIterator(object._SharedObject, _MessageIterator):
  44     def __init__(self, ptr):
  45             self._current_msgs = []
  46             self._at = 0
  47             super().__init__(ptr)
  48
  49     def __next__(self):
  50         if len(self._current_msgs) == self._at:
  51             status, msgs = self._get_msg_range(self._ptr)
  52             self._handle_status(status,
  53                                 'unexpected error: cannot advance the message iterator')
  54             self._current_msgs = msgs
  55             self._at = 0
  56
  57         msg_ptr = self._current_msgs[self._at]
  58         self._at += 1
  59
  60         return bt2.message._create_from_ptr(msg_ptr)
  61
  62
  63 class _UserComponentInputPortMessageIterator(_GenericMessageIterator):
  64     _get_msg_range = staticmethod(native_bt.py3_self_component_port_input_get_msg_range)
  65
  66     @property
  67     def component(self):
  68         comp_ptr = native_bt.private_connection_message_iterator_get_component(self._ptr)
  69         assert(comp_ptr)
  70         return bt2.component._create_generic_component_from_ptr(comp_ptr)
  71
  72
  73 class _OutputPortMessageIterator(_GenericMessageIterator):
  74     _get_msg_range = staticmethod(native_bt.py3_port_output_get_msg_range)
  75     _get_ref = staticmethod(native_bt.port_output_message_iterator_get_ref)
  76     _put_ref = staticmethod(native_bt.port_output_message_iterator_put_ref)
  77
  78
  79 class _UserMessageIterator(_MessageIterator):
  80     def __new__(cls, ptr):
  81         # User iterator objects are always created by the native side,
  82         # that is, never instantiated directly by Python code.
  83         #
  84         # The native code calls this, then manually calls
  85         # self.__init__() without the `ptr` argument. The user has
  86         # access to self.component during this call, thanks to this
  87         # self._ptr argument being set.
  88         #
  89         # self._ptr is NOT owned by this object here, so there's nothing
  90         # to do in __del__().
  91         self = super().__new__(cls)
  92         self._ptr = ptr
  93         return self
  94
  95     def __init__(self):
  96         pass
  97
  98     @property
  99     def _component(self):
 100         return native_bt.py3_get_user_component_from_user_msg_iter(self._ptr)
 101
 102     @property
 103     def addr(self):
 104         return int(self._ptr)
 105
 106     def _finalize(self):
 107         pass
 108
 109     def __next__(self):
 110         raise bt2.Stop
 111
 112     def _next_from_native(self):
 113         # this can raise anything: it's catched by the native part
 114         try:
 115             msg = next(self)
 116         except StopIteration:
 117             raise bt2.Stop
 118         except:
 119             raise
 120
 121         utils._check_type(msg, bt2.message._Message)
 122
 123         # Release the reference to the native part.
 124         ptr = msg._release()
 125         return int(ptr)
 126
 127     # Validate that the presence or lack of presence of a
 128     # `default_clock_snapshot` value is valid in the context of `stream_class`.
 129     @staticmethod
 130     def _validate_default_clock_snapshot(stream_class, default_clock_snapshot):
 131         stream_class_has_default_clock_class = stream_class.default_clock_class is not None
 132
 133         if stream_class_has_default_clock_class and default_clock_snapshot is None:
 134             raise bt2.Error(
 135                 'stream class has a default clock class, default_clock_snapshot should not be None')
 136
 137         if not stream_class_has_default_clock_class and default_clock_snapshot is not None:
 138             raise bt2.Error(
 139                 'stream class has no default clock class, default_clock_snapshot should be None')
 140
 141     def _create_event_message(self, event_class, packet, default_clock_snapshot=None):
 142         utils._check_type(event_class, bt2.event_class.EventClass)
 143         utils._check_type(packet, bt2.packet._Packet)
 144         self._validate_default_clock_snapshot(packet.stream.stream_class, default_clock_snapshot)
 145
 146         if default_clock_snapshot is not None:
 147             utils._check_uint64(default_clock_snapshot)
 148             ptr = native_bt.message_event_create_with_default_clock_snapshot(
 149                 self._ptr, event_class._ptr, packet._ptr, default_clock_snapshot)
 150         else:
 151             ptr = native_bt.message_event_create(
 152                 self._ptr, event_class._ptr, packet._ptr)
 153
 154         if ptr is None:
 155             raise bt2.CreationError('cannot create event message object')
 156
 157         return bt2.message._EventMessage(ptr)
 158
 159     def _create_stream_beginning_message(self, stream):
 160         utils._check_type(stream, bt2.stream._Stream)
 161
 162         ptr = native_bt.message_stream_beginning_create(self._ptr, stream._ptr)
 163         if ptr is None:
 164             raise bt2.CreationError('cannot create stream beginning message object')
 165
 166         return bt2.message._StreamBeginningMessage(ptr)
 167
 168     def _create_stream_end_message(self, stream):
 169         utils._check_type(stream, bt2.stream._Stream)
 170
 171         ptr = native_bt.message_stream_end_create(self._ptr, stream._ptr)
 172         if ptr is None:
 173             raise bt2.CreationError('cannot create stream end message object')
 174
 175         return bt2.message._StreamEndMessage(ptr)
 176
 177     def _create_packet_beginning_message(self, packet, default_clock_snapshot=None):
 178         utils._check_type(packet, bt2.packet._Packet)
 179
 180         if packet.stream.stream_class.packets_have_default_beginning_clock_snapshot:
 181             if default_clock_snapshot is None:
 182                 raise bt2.CreationError("packet beginning messages in this stream must have a default clock snapshots")
 183
 184             utils._check_uint64(default_clock_snapshot)
 185             ptr = native_bt.message_packet_beginning_create_with_default_clock_snapshot(
 186                 self._ptr, packet._ptr, default_clock_snapshot)
 187         else:
 188             if default_clock_snapshot is not None:
 189                 raise bt2.CreationError("packet beginning messages in this stream must not have a default clock snapshots")
 190
 191             ptr = native_bt.message_packet_beginning_create(self._ptr, packet._ptr)
 192
 193         if ptr is None:
 194             raise bt2.CreationError('cannot create packet beginning message object')
 195
 196         return bt2.message._PacketBeginningMessage(ptr)
 197
 198     def _create_packet_end_message(self, packet, default_clock_snapshot=None):
 199         utils._check_type(packet, bt2.packet._Packet)
 200         self._validate_default_clock_snapshot(packet.stream.stream_class, default_clock_snapshot)
 201
 202         if default_clock_snapshot is not None:
 203             utils._check_uint64(default_clock_snapshot)
 204             ptr = native_bt.message_packet_end_create_with_default_clock_snapshot(
 205                 self._ptr, packet._ptr, default_clock_snapshot)
 206         else:
 207             ptr = native_bt.message_packet_end_create(self._ptr, packet._ptr)
 208
 209         if ptr is None:
 210             raise bt2.CreationError('cannot create packet end message object')
 211
 212         return bt2.message._PacketEndMessage(ptr)