tap-driver.sh: flush stdout after each test result
[babeltrace.git] / 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 # This is created when a component wants to iterate on one of its input ports.
64 class _UserComponentInputPortMessageIterator(_GenericMessageIterator):
65 _get_msg_range = staticmethod(native_bt.py3_self_component_port_input_get_msg_range)
66 _get_ref = staticmethod(native_bt.self_component_port_input_message_iterator_get_ref)
67 _put_ref = staticmethod(native_bt.self_component_port_input_message_iterator_put_ref)
68
69
70 # This is created when the user wants to iterate on a component's output port,
71 # from outside the graph.
72 class _OutputPortMessageIterator(_GenericMessageIterator):
73 _get_msg_range = staticmethod(native_bt.py3_port_output_get_msg_range)
74 _get_ref = staticmethod(native_bt.port_output_message_iterator_get_ref)
75 _put_ref = staticmethod(native_bt.port_output_message_iterator_put_ref)
76
77
78 # This is extended by the user to implement component classes in Python. It
79 # is created for a given output port when an input port message iterator is
80 # created on the input port on the other side of the connection. It is also
81 # created when an output port message iterator is created on this output port.
82 #
83 # Its purpose is to feed the messages that should go out through this output
84 # port.
85 class _UserMessageIterator(_MessageIterator):
86 def __new__(cls, ptr):
87 # User iterator objects are always created by the native side,
88 # that is, never instantiated directly by Python code.
89 #
90 # The native code calls this, then manually calls
91 # self.__init__() without the `ptr` argument. The user has
92 # access to self.component during this call, thanks to this
93 # self._ptr argument being set.
94 #
95 # self._ptr is NOT owned by this object here, so there's nothing
96 # to do in __del__().
97 self = super().__new__(cls)
98 self._ptr = ptr
99 return self
100
101 def _init_from_native(self, self_output_port_ptr):
102 self_output_port = bt2.port._create_self_from_ptr_and_get_ref(
103 self_output_port_ptr, native_bt.PORT_TYPE_OUTPUT)
104 self.__init__(self_output_port)
105
106 def __init__(self, output_port):
107 pass
108
109 @property
110 def _component(self):
111 return native_bt.py3_get_user_component_from_user_msg_iter(self._ptr)
112
113 @property
114 def addr(self):
115 return int(self._ptr)
116
117 def _finalize(self):
118 pass
119
120 def __next__(self):
121 raise bt2.Stop
122
123 def _next_from_native(self):
124 # this can raise anything: it's catched by the native part
125 try:
126 msg = next(self)
127 except StopIteration:
128 raise bt2.Stop
129 except:
130 raise
131
132 utils._check_type(msg, bt2.message._Message)
133
134 # Release the reference to the native part.
135 ptr = msg._release()
136 return int(ptr)
137
138 # Validate that the presence or lack of presence of a
139 # `default_clock_snapshot` value is valid in the context of `stream_class`.
140 @staticmethod
141 def _validate_default_clock_snapshot(stream_class, default_clock_snapshot):
142 stream_class_has_default_clock_class = stream_class.default_clock_class is not None
143
144 if stream_class_has_default_clock_class and default_clock_snapshot is None:
145 raise bt2.Error(
146 'stream class has a default clock class, default_clock_snapshot should not be None')
147
148 if not stream_class_has_default_clock_class and default_clock_snapshot is not None:
149 raise bt2.Error(
150 'stream class has no default clock class, default_clock_snapshot should be None')
151
152 def _create_event_message(self, event_class, packet, default_clock_snapshot=None):
153 utils._check_type(event_class, bt2.event_class._EventClass)
154 utils._check_type(packet, bt2.packet._Packet)
155 self._validate_default_clock_snapshot(packet.stream.cls, default_clock_snapshot)
156
157 if default_clock_snapshot is not None:
158 utils._check_uint64(default_clock_snapshot)
159 ptr = native_bt.message_event_create_with_default_clock_snapshot(
160 self._ptr, event_class._ptr, packet._ptr, default_clock_snapshot)
161 else:
162 ptr = native_bt.message_event_create(
163 self._ptr, event_class._ptr, packet._ptr)
164
165 if ptr is None:
166 raise bt2.CreationError('cannot create event message object')
167
168 return bt2.message._EventMessage(ptr)
169
170 def _create_message_iterator_inactivity_message(self, clock_class, clock_snapshot):
171 utils._check_type(clock_class, bt2.clock_class._ClockClass)
172 ptr = native_bt.message_message_iterator_inactivity_create(
173 self._ptr, clock_class._ptr, clock_snapshot)
174
175 if ptr is None:
176 raise bt2.CreationError('cannot create inactivity message object')
177
178 return bt2.message._MessageIteratorInactivityMessage(ptr)
179
180 def _create_stream_beginning_message(self, stream):
181 utils._check_type(stream, bt2.stream._Stream)
182
183 ptr = native_bt.message_stream_beginning_create(self._ptr, stream._ptr)
184 if ptr is None:
185 raise bt2.CreationError('cannot create stream beginning message object')
186
187 return bt2.message._StreamBeginningMessage(ptr)
188
189 def _create_stream_activity_beginning_message(self, stream, default_clock_snapshot=None):
190 utils._check_type(stream, bt2.stream._Stream)
191 self._validate_default_clock_snapshot(stream.cls, default_clock_snapshot)
192
193 ptr = native_bt.message_stream_activity_beginning_create(self._ptr, stream._ptr)
194
195 if ptr is None:
196 raise bt2.CreationError(
197 'cannot create stream activity beginning message object')
198
199 msg = bt2.message._StreamActivityBeginningMessage(ptr)
200
201 if default_clock_snapshot is not None:
202 msg._default_clock_snapshot = default_clock_snapshot
203
204 return msg
205
206 def _create_stream_activity_end_message(self, stream, default_clock_snapshot=None):
207 utils._check_type(stream, bt2.stream._Stream)
208 self._validate_default_clock_snapshot(stream.cls, default_clock_snapshot)
209
210 ptr = native_bt.message_stream_activity_end_create(self._ptr, stream._ptr)
211
212 if ptr is None:
213 raise bt2.CreationError(
214 'cannot create stream activity end message object')
215
216 msg = bt2.message._StreamActivityEndMessage(ptr)
217
218 if default_clock_snapshot is not None:
219 msg._default_clock_snapshot = default_clock_snapshot
220
221 return msg
222
223 def _create_stream_end_message(self, stream):
224 utils._check_type(stream, bt2.stream._Stream)
225
226 ptr = native_bt.message_stream_end_create(self._ptr, stream._ptr)
227 if ptr is None:
228 raise bt2.CreationError('cannot create stream end message object')
229
230 return bt2.message._StreamEndMessage(ptr)
231
232 def _create_packet_beginning_message(self, packet, default_clock_snapshot=None):
233 utils._check_type(packet, bt2.packet._Packet)
234
235 if packet.stream.cls.packets_have_beginning_default_clock_snapshot:
236 if default_clock_snapshot is None:
237 raise ValueError("packet beginning messages in this stream must have a default clock snapshots")
238
239 utils._check_uint64(default_clock_snapshot)
240 ptr = native_bt.message_packet_beginning_create_with_default_clock_snapshot(
241 self._ptr, packet._ptr, default_clock_snapshot)
242 else:
243 if default_clock_snapshot is not None:
244 raise ValueError("packet beginning messages in this stream must not have a default clock snapshots")
245
246 ptr = native_bt.message_packet_beginning_create(self._ptr, packet._ptr)
247
248 if ptr is None:
249 raise bt2.CreationError('cannot create packet beginning message object')
250
251 return bt2.message._PacketBeginningMessage(ptr)
252
253 def _create_packet_end_message(self, packet, default_clock_snapshot=None):
254 utils._check_type(packet, bt2.packet._Packet)
255
256 if packet.stream.cls.packets_have_end_default_clock_snapshot:
257 if default_clock_snapshot is None:
258 raise ValueError("packet end messages in this stream must have a default clock snapshots")
259
260 utils._check_uint64(default_clock_snapshot)
261 ptr = native_bt.message_packet_end_create_with_default_clock_snapshot(
262 self._ptr, packet._ptr, default_clock_snapshot)
263 else:
264 if default_clock_snapshot is not None:
265 raise ValueError("packet end messages in this stream must not have a default clock snapshots")
266
267 ptr = native_bt.message_packet_end_create(self._ptr, packet._ptr)
268
269 if ptr is None:
270 raise bt2.CreationError('cannot create packet end message object')
271
272 return bt2.message._PacketEndMessage(ptr)
273
274 def _create_discarded_events_message(self, stream, count=None,
275 beg_clock_snapshot=None,
276 end_clock_snapshot=None):
277 utils._check_type(stream, bt2.stream._Stream)
278
279 if not stream.cls.supports_discarded_events:
280 raise ValueError('stream class does not support discarded events')
281
282 if stream.cls.discarded_events_have_default_clock_snapshots:
283 if beg_clock_snapshot is None or end_clock_snapshot is None:
284 raise ValueError('discarded events have default clock snapshots for this stream class')
285
286 utils._check_uint64(beg_clock_snapshot)
287 utils._check_uint64(end_clock_snapshot)
288 ptr = native_bt.message_discarded_events_create_with_default_clock_snapshots(
289 self._ptr, stream._ptr, beg_clock_snapshot, end_clock_snapshot)
290 else:
291 if beg_clock_snapshot is not None or end_clock_snapshot is not None:
292 raise ValueError('discarded events have no default clock snapshots for this stream class')
293
294 ptr = native_bt.message_discarded_events_create(
295 self._ptr, stream._ptr)
296
297 if ptr is None:
298 raise bt2.CreationError('cannot discarded events message object')
299
300 msg = bt2.message._DiscardedEventsMessage(ptr)
301
302 if count is not None:
303 msg._count = count
304
305 return msg
306
307 def _create_discarded_packets_message(self, stream, count=None, beg_clock_snapshot=None, end_clock_snapshot=None):
308 utils._check_type(stream, bt2.stream._Stream)
309
310 if not stream.cls.supports_discarded_packets:
311 raise ValueError('stream class does not support discarded packets')
312
313 if stream.cls.discarded_packets_have_default_clock_snapshots:
314 if beg_clock_snapshot is None or end_clock_snapshot is None:
315 raise ValueError('discarded packets have default clock snapshots for this stream class')
316
317 utils._check_uint64(beg_clock_snapshot)
318 utils._check_uint64(end_clock_snapshot)
319 ptr = native_bt.message_discarded_packets_create_with_default_clock_snapshots(
320 self._ptr, stream._ptr, beg_clock_snapshot, end_clock_snapshot)
321 else:
322 if beg_clock_snapshot is not None or end_clock_snapshot is not None:
323 raise ValueError('discarded packets have no default clock snapshots for this stream class')
324
325 ptr = native_bt.message_discarded_packets_create(
326 self._ptr, stream._ptr)
327
328 if ptr is None:
329 raise bt2.CreationError('cannot discarded packets message object')
330
331 msg = bt2.message._DiscardedPacketsMessage(ptr)
332
333 if count is not None:
334 msg._count = count
335
336 return msg
337
This page took 0.042476 seconds and 4 git commands to generate.