lib: make packets and packet messages optional, disabled by default

[babeltrace.git] / src / bindings / python / bt2 / bt2 / message_iterator.py

diff --git a/src/bindings/python/bt2/bt2/message_iterator.py b/src/bindings/python/bt2/bt2/message_iterator.py
index 379e9ab9c62284a5bad4eb5d1034a705aa84e4a7..eb22dfb4edec32c4afd14612d744cb618248319d 100644 (file)
--- a/src/bindings/python/bt2/bt2/message_iterator.py
+++ b/src/bindings/python/bt2/bt2/message_iterator.py
@@ -165,23 +165,37 @@ class _UserMessageIterator(_MessageIterator):
     def _bt_seek_beginning_from_native(self):
         self._seek_beginning()
 
-    def _create_event_message(self, event_class, packet, default_clock_snapshot=None):
+    def _create_event_message(self, event_class, parent=None,
+                              default_clock_snapshot=None):
         utils._check_type(event_class, bt2.event_class._EventClass)
-        utils._check_type(packet, bt2.packet._Packet)
+
+        if event_class.stream_class.supports_packets:
+            utils._check_type(parent, bt2.packet._Packet)
+        else:
+            utils._check_type(parent, bt2.stream._Stream)
 
         if default_clock_snapshot is not None:
             if event_class.stream_class.default_clock_class is None:
                 raise ValueError('event messages in this stream must not have a default clock snapshot')
 
             utils._check_uint64(default_clock_snapshot)
-            ptr = native_bt.message_event_create_with_default_clock_snapshot(
-                self._bt_ptr, event_class._ptr, packet._ptr, default_clock_snapshot)
+
+            if event_class.stream_class.supports_packets:
+                ptr = native_bt.message_event_create_with_packet_and_default_clock_snapshot(
+                    self._bt_ptr, event_class._ptr, parent._ptr, default_clock_snapshot)
+            else:
+                ptr = native_bt.message_event_create_with_default_clock_snapshot(
+                    self._bt_ptr, event_class._ptr, parent._ptr, default_clock_snapshot)
         else:
             if event_class.stream_class.default_clock_class is not None:
                 raise ValueError('event messages in this stream must have a default clock snapshot')
 
-            ptr = native_bt.message_event_create(
-                self._bt_ptr, event_class._ptr, packet._ptr)
+            if event_class.stream_class.supports_packets:
+                ptr = native_bt.message_event_create_with_packet(
+                    self._bt_ptr, event_class._ptr, parent._ptr)
+            else:
+                ptr = native_bt.message_event_create(
+                    self._bt_ptr, event_class._ptr, parent._ptr)
 
         if ptr is None:
             raise bt2.CreationError('cannot create event message object')
@@ -198,71 +212,33 @@ class _UserMessageIterator(_MessageIterator):
 
         return bt2.message._MessageIteratorInactivityMessage(ptr)
 
-    _unknown_clock_snapshot = bt2.message._StreamActivityMessageUnknownClockSnapshot()
-    _infinite_clock_snapshot = bt2.message._StreamActivityMessageInfiniteClockSnapshot()
-
-    @staticmethod
-    def _bt_validate_stream_activity_message_default_clock_snapshot(stream, default_cs):
-        isinst_infinite = isinstance(default_cs, bt2.message._StreamActivityMessageInfiniteClockSnapshot)
-        isinst_unknown = isinstance(default_cs, bt2.message._StreamActivityMessageUnknownClockSnapshot)
-
-        if utils._is_uint64(default_cs):
-            pass
-        elif isinst_infinite or isinst_unknown:
-            if default_cs is not _UserMessageIterator._unknown_clock_snapshot and default_cs is not _UserMessageIterator._infinite_clock_snapshot:
-                raise ValueError('unexpected value for default clock snapshot')
-        else:
-            raise TypeError("unexpected type '{}' for default clock snapshot".format(default_cs.__class__.__name__))
-
-        if stream.cls.default_clock_class is None:
-            if utils._is_uint64(default_cs):
-                raise ValueError('stream activity messages in this stream cannot have a known default clock snapshot')
-
-    def _create_stream_beginning_message(self, stream):
+    def _create_stream_beginning_message(self, stream, default_clock_snapshot=None):
         utils._check_type(stream, bt2.stream._Stream)
 
         ptr = native_bt.message_stream_beginning_create(self._bt_ptr, stream._ptr)
         if ptr is None:
             raise bt2.CreationError('cannot create stream beginning message object')
 
-        return bt2.message._StreamBeginningMessage(ptr)
+        msg = bt2.message._StreamBeginningMessage(ptr)
 
-    def _create_stream_activity_beginning_message(self, stream,
-                                                  default_clock_snapshot=_unknown_clock_snapshot):
-        utils._check_type(stream, bt2.stream._Stream)
-        self._bt_validate_stream_activity_message_default_clock_snapshot(stream, default_clock_snapshot)
-        ptr = native_bt.message_stream_activity_beginning_create(self._bt_ptr, stream._ptr)
-
-        if ptr is None:
-            raise bt2.CreationError(
-                'cannot create stream activity beginning message object')
-
-        msg = bt2.message._StreamActivityBeginningMessage(ptr)
-        msg._default_clock_snapshot = default_clock_snapshot
-        return msg
-
-    def _create_stream_activity_end_message(self, stream,
-                                            default_clock_snapshot=_unknown_clock_snapshot):
-        utils._check_type(stream, bt2.stream._Stream)
-        self._bt_validate_stream_activity_message_default_clock_snapshot(stream, default_clock_snapshot)
-        ptr = native_bt.message_stream_activity_end_create(self._bt_ptr, stream._ptr)
-
-        if ptr is None:
-            raise bt2.CreationError(
-                'cannot create stream activity end message object')
+        if default_clock_snapshot is not None:
+            msg._default_clock_snapshot = default_clock_snapshot
 
-        msg = bt2.message._StreamActivityEndMessage(ptr)
-        msg._default_clock_snapshot = default_clock_snapshot
         return msg
 
-    def _create_stream_end_message(self, stream):
+    def _create_stream_end_message(self, stream, default_clock_snapshot=None):
         utils._check_type(stream, bt2.stream._Stream)
 
         ptr = native_bt.message_stream_end_create(self._bt_ptr, stream._ptr)
         if ptr is None:
             raise bt2.CreationError('cannot create stream end message object')
 
-        return bt2.message._StreamEndMessage(ptr)
+        msg = bt2.message._StreamEndMessage(ptr)
+
+        if default_clock_snapshot is not None:
+            msg._default_clock_snapshot = default_clock_snapshot
+
+        return msg
 
     def _create_packet_beginning_message(self, packet, default_clock_snapshot=None):
         utils._check_type(packet, bt2.packet._Packet)