bt2: Mass clock_value -> clock_snapshot rename

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

diff --git a/bindings/python/bt2/bt2/event.py b/bindings/python/bt2/bt2/event.py
index b1b6875dacf80552f9fb212074a229426e40d476..eeb9e47ba3ee20446871c080f3326ec078131492 100644 (file)
--- a/bindings/python/bt2/bt2/event.py
+++ b/bindings/python/bt2/bt2/event.py
@@ -25,7 +25,8 @@ import bt2.clock_class
 import bt2.packet
 import bt2.stream
 import bt2.fields
-import bt2.clock_value
+import bt2.clock_snapshot
+import collections
 import numbers
 import copy
 import abc
@@ -44,6 +45,50 @@ def _create_from_ptr(ptr):
     return event
 
 
+class _EventClockSnapshotsIterator(collections.abc.Iterator):
+    def __init__(self, event_clock_snapshots):
+        self._event_clock_snapshots = event_clock_snapshots
+        self._clock_classes = event_clock_snapshots._event._clock_classes
+        self._at = 0
+
+    def __next__(self):
+        if self._at == len(self._clock_classes):
+            raise StopIteration
+
+        self._at += 1
+        return self._clock_classes[at]
+
+
+class _EventClockSnapshots(collections.abc.Mapping):
+    def __init__(self, event):
+        self._event = event
+
+    def __getitem__(self, clock_class):
+        utils._check_type(clock_class, bt2.ClockClass)
+        clock_snapshot_ptr = native_bt.event_get_clock_snapshot(self._event._ptr,
+                                                          clock_class._ptr)
+
+        if clock_snapshot_ptr is None:
+            return
+
+        clock_snapshot = bt2.clock_snapshot._create_clock_snapshot_from_ptr(clock_snapshot_ptr)
+        return clock_snapshot
+
+    def add(self, clock_snapshot):
+        utils._check_type(clock_snapshot, bt2.clock_snapshot._ClockSnapshot)
+        ret = native_bt.event_set_clock_snapshot(self._ptr,
+                                              clock_snapshot._ptr)
+        utils._handle_ret(ret, "cannot set event object's clock value")
+
+    def __len__(self):
+        count = len(self._event._clock_classes)
+        assert(count >= 0)
+        return count
+
+    def __iter__(self):
+        return _EventClockSnapshotsIterator(self)
+
+
 class _Event(object._Object):
     @property
     def event_class(self):
@@ -119,7 +164,7 @@ class _Event(object._Object):
             stream_event_context_ptr = stream_event_context._ptr
 
         ret = native_bt.event_set_stream_event_context(self._ptr,
-                                                           stream_event_context_ptr)
+                                                       stream_event_context_ptr)
         utils._handle_ret(ret, "cannot set event object's stream event context field")
 
     @property
@@ -162,34 +207,21 @@ class _Event(object._Object):
         ret = native_bt.event_set_event_payload(self._ptr, payload_ptr)
         utils._handle_ret(ret, "cannot set event object's payload field")
 
-    def _get_clock_value_cycles(self, clock_class_ptr):
-        clock_value_ptr = native_bt.event_get_clock_value(self._ptr,
-                                                              clock_class_ptr)
+    def _get_clock_snapshot_cycles(self, clock_class_ptr):
+        clock_snapshot_ptr = native_bt.event_get_clock_snapshot(self._ptr,
+                                                          clock_class_ptr)
 
-        if clock_value_ptr is None:
+        if clock_snapshot_ptr is None:
             return
 
-        ret, cycles = native_bt.clock_value_get_value(clock_value_ptr)
-        native_bt.put(clock_value_ptr)
+        ret, cycles = native_bt.clock_snapshot_get_value(clock_snapshot_ptr)
+        native_bt.put(clock_snapshot_ptr)
         utils._handle_ret(ret, "cannot get clock value object's cycles")
         return cycles
 
-    def clock_value(self, clock_class):
-        utils._check_type(clock_class, bt2.ClockClass)
-        clock_value_ptr = native_bt.event_get_clock_value(self._ptr,
-                                                              clock_class._ptr)
-
-        if clock_value_ptr is None:
-            return
-
-        clock_value = bt2.clock_value._create_clock_value_from_ptr(clock_value_ptr)
-        return clock_value
-
-    def add_clock_value(self, clock_value):
-        utils._check_type(clock_value, bt2.clock_value._ClockValue)
-        ret = native_bt.event_set_clock_value(self._ptr,
-                                                  clock_value._ptr)
-        utils._handle_ret(ret, "cannot set event object's clock value")
+    @property
+    def clock_snapshots(self):
+        return _EventClockSnapshots(self)
 
     def __getitem__(self, key):
         utils._check_str(key)
@@ -260,28 +292,28 @@ class _Event(object._Object):
         if self.addr == other.addr:
             return True
 
-        self_clock_values = {}
-        other_clock_values = {}
+        self_clock_snapshots = {}
+        other_clock_snapshots = {}
 
         for clock_class_ptr in self._clock_class_ptrs:
-            self_clock_values[int(clock_class_ptr)] = self._get_clock_value_cycles(clock_class_ptr)
+            self_clock_snapshots[int(clock_class_ptr)] = self._get_clock_snapshot_cycles(clock_class_ptr)
 
         for clock_class_ptr in other._clock_class_ptrs:
-            other_clock_values[int(clock_class_ptr)] = self._get_clock_value_cycles(clock_class_ptr)
+            other_clock_snapshots[int(clock_class_ptr)] = self._get_clock_snapshot_cycles(clock_class_ptr)
 
         self_props = (
             self.header_field,
             self.stream_event_context_field,
             self.context_field,
             self.payload_field,
-            self_clock_values,
+            self_clock_snapshots,
         )
         other_props = (
             other.header_field,
             other.stream_event_context_field,
             other.context_field,
             other.payload_field,
-            other_clock_values,
+            other_clock_snapshots,
         )
         return self_props == other_props
 
@@ -300,10 +332,10 @@ class _Event(object._Object):
         # Thus even if we copy the clock class, the user cannot modify
         # it, therefore it's useless to copy it.
         for clock_class in self._clock_classes:
-            clock_value = self.clock_value(clock_class)
+            clock_snapshot = self.clock_snapshots[clock_class]
 
-            if clock_value is not None:
-                cpy.add_clock_value(clock_value)
+            if clock_snapshot is not None:
+                cpy.clock_snapshots.add(clock_snapshot)
 
         return cpy