Merge branch 'move-datamode-ownership-to-eventhandler' into 'master'

Move DataModel ownership to EventHandler

See merge request micro-ROS/ros_tracing/tracetools_analysis!45

tracetools_analysis/tracetools_analysis/processor/__init__.py

@@ -27,6 +27,8 @@ from tracetools_read import DictEvent
 from tracetools_read import get_event_name
 from tracetools_read import get_field
 
+from ..data_model import DataModel
+
 
 class EventMetadata():
     """Container for event metadata."""
@@ -105,27 +107,29 @@ class EventHandler(Dependant):
     """
     Base event handling class.
 
-    Provides handling functions for some events, depending on the name.
+    Provides handling functions for some events, depending on the name. Passes that on to a data
-    Passes that on to a data model. To be subclassed.
+    model. Should be subclassed, but it is not necessary since the handling functions can be
+    anything; therefore it does not raise any error if it is directly instantiated.
     """
 
     def __init__(
         self,
         *,
         handler_map: HandlerMap,
+        data_model: DataModel = None,
         **kwargs,
     ) -> None:
         """
         Create an EventHandler.
 
-        TODO make subclasses pass on their *DataModel to this class
-
         :param handler_map: the mapping from event name to handling method
+        :param data_model: the data model
         """
         assert handler_map is not None and len(handler_map) > 0, \
             f'empty map: {self.__class__.__name__}'
         assert all(required_name in handler_map.keys() for required_name in self.required_events())
         self._handler_map = handler_map
+        self._data_model = data_model
         self._processor = None
 
     @property
@@ -134,9 +138,9 @@ class EventHandler(Dependant):
         return self._handler_map
 
     @property
-    def data(self) -> None:
+    def data(self) -> Union[DataModel, None]:
         """Get the data model."""
-        return None
+        return self._data_model
 
     @property
     def processor(self) -> 'Processor':

tracetools_analysis/tracetools_analysis/processor/cpu_time.py

@@ -43,11 +43,10 @@ class CpuTimeHandler(EventHandler):
         }
         super().__init__(
             handler_map=handler_map,
+            data_model=CpuTimeDataModel(),
             **kwargs,
         )
 
-        self._data_model = CpuTimeDataModel()
-
         # Temporary buffers
         # cpu_id -> start timestamp of the running thread
         self._cpu_start: Dict[int, int] = {}
@@ -58,10 +57,6 @@ class CpuTimeHandler(EventHandler):
             'sched_switch',
         }
 
-    @property
-    def data(self) -> CpuTimeDataModel:
-        return self._data_model
-
     def _handle_sched_switch(
         self, event: Dict, metadata: EventMetadata
     ) -> None:

tracetools_analysis/tracetools_analysis/processor/memory_usage.py

@@ -32,14 +32,11 @@ class MemoryUsageHandler(EventHandler):
         **kwargs,
     ) -> None:
         if type(self) is MemoryUsageHandler:
-            raise RuntimeError('Do not instanciate MemoryUsageHandler directly!')
+            raise RuntimeError('Do not instantiate directly!')
-        super().__init__(**kwargs)
+        super().__init__(
-
+            data_model=MemoryUsageDataModel(),
-        self._data_model = MemoryUsageDataModel()
+            **kwargs,
-
+        )
-    @property
-    def data(self) -> MemoryUsageDataModel:
-        return self._data_model
 
     def _update(
         self,

tracetools_analysis/tracetools_analysis/processor/profile.py

@@ -66,10 +66,10 @@ class ProfileHandler(EventHandler):
         }
         super().__init__(
             handler_map=handler_map,
+            data_model=ProfileDataModel(),
             **kwargs,
         )
 
-        self._data_model = ProfileDataModel()
         self._address_to_func = {
             self.addr_to_int(addr): name for addr, name in address_to_func.items()
         }
@@ -100,10 +100,6 @@ class ProfileHandler(EventHandler):
         """Transform an address into an `int` if it's a hex `str`."""
         return int(addr, 16) if isinstance(addr, str) else addr
 
-    @property
-    def data(self) -> ProfileDataModel:
-        return self._data_model
-
     def _handle_sched_switch(
         self, event: Dict, metadata: EventMetadata
     ) -> None:

tracetools_analysis/tracetools_analysis/processor/ros2.py

@@ -69,11 +69,10 @@ class Ros2Handler(EventHandler):
         }
         super().__init__(
             handler_map=handler_map,
+            data_model=Ros2DataModel(),
             **kwargs,
         )
 
-        self._data_model = Ros2DataModel()
-
         # Temporary buffers
         self._callback_instances = {}
 
@@ -83,10 +82,6 @@ class Ros2Handler(EventHandler):
             'ros2:rcl_init',
         }
 
-    @property
-    def data(self) -> Ros2DataModel:
-        return self._data_model
-
     def _handle_rcl_init(
         self, event: Dict, metadata: EventMetadata,
     ) -> None: