X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bindings%2Fpython%2Fbt2%2Fbt2%2Fcomponent.py;h=3480f6570703e2ae49db6c0a99d62daabf89b0a7;hb=e8ac1aaec8f07304d16bf787950c14cd7c49fc75;hp=459ae955b4572300474a6120a74936519233a36d;hpb=601c002660cfc2434293a50a1bec418a6b41fdaf;p=babeltrace.git diff --git a/bindings/python/bt2/bt2/component.py b/bindings/python/bt2/bt2/component.py index 459ae955..3480f657 100644 --- a/bindings/python/bt2/bt2/component.py +++ b/bindings/python/bt2/bt2/component.py @@ -78,34 +78,30 @@ class _GenericComponentClass(object._SharedObject): class _GenericSourceComponentClass(_GenericComponentClass): - _get_ref = native_bt.component_class_source_get_ref - _put_ref = native_bt.component_class_source_put_ref - _as_component_class_ptr = native_bt.component_class_source_as_component_class + _get_ref = staticmethod(native_bt.component_class_source_get_ref) + _put_ref = staticmethod(native_bt.component_class_source_put_ref) + _as_component_class_ptr = staticmethod(native_bt.component_class_source_as_component_class) class _GenericFilterComponentClass(_GenericComponentClass): - _get_ref = native_bt.component_class_filter_get_ref - _put_ref = native_bt.component_class_filter_put_ref - _as_component_class_ptr = native_bt.component_class_filter_as_component_class + _get_ref = staticmethod(native_bt.component_class_filter_get_ref) + _put_ref = staticmethod(native_bt.component_class_filter_put_ref) + _as_component_class_ptr = staticmethod(native_bt.component_class_filter_as_component_class) class _GenericSinkComponentClass(_GenericComponentClass): - _get_ref = native_bt.component_class_sink_get_ref - _put_ref = native_bt.component_class_sink_put_ref - _as_component_class_ptr = native_bt.component_class_sink_as_component_class + _get_ref = staticmethod(native_bt.component_class_sink_get_ref) + _put_ref = staticmethod(native_bt.component_class_sink_put_ref) + _as_component_class_ptr = staticmethod(native_bt.component_class_sink_as_component_class) def _handle_component_status(status, gen_error_msg): - if status == native_bt.COMPONENT_STATUS_END: + if status == native_bt.SELF_COMPONENT_STATUS_END: raise bt2.Stop - elif status == native_bt.COMPONENT_STATUS_AGAIN: + elif status == native_bt.SELF_COMPONENT_STATUS_AGAIN: raise bt2.TryAgain - elif status == native_bt.COMPONENT_STATUS_UNSUPPORTED: - raise bt2.UnsupportedFeature - elif status == native_bt.COMPONENT_STATUS_REFUSE_PORT_CONNECTION: + elif status == native_bt.SELF_COMPONENT_STATUS_REFUSE_PORT_CONNECTION: raise bt2.PortConnectionRefused - elif status == native_bt.COMPONENT_STATUS_GRAPH_IS_CANCELED: - raise bt2.GraphCanceled elif status < 0: raise bt2.Error(gen_error_msg) @@ -120,54 +116,47 @@ class _PortIterator(collections.abc.Iterator): raise StopIteration comp_ports = self._comp_ports - comp_ptr = comp_ports._component._ptr - port_ptr = comp_ports._get_port_at_index_fn(comp_ptr, self._at) - assert(port_ptr) - - if comp_ports._is_private: - port_pub_ptr = native_bt.port_from_private(port_ptr) - name = native_bt.port_get_name(port_pub_ptr) - native_bt.put(port_pub_ptr) - else: - name = native_bt.port_get_name(port_ptr) + comp_ptr = comp_ports._component_ptr + + port_ptr = comp_ports._borrow_port_ptr_at_index(comp_ptr, self._at) + assert port_ptr is not None + + name = native_bt.port_get_name(comp_ports._port_pycls._as_port_ptr(port_ptr)) + assert name is not None - assert(name is not None) - native_bt.put(port_ptr) self._at += 1 return name class _ComponentPorts(collections.abc.Mapping): - def __init__(self, is_private, component, - get_port_by_name_fn, get_port_at_index_fn, - get_port_count_fn): - self._is_private = is_private - self._component = component - self._get_port_by_name_fn = get_port_by_name_fn - self._get_port_at_index_fn = get_port_at_index_fn - self._get_port_count_fn = get_port_count_fn + + # component_ptr is a bt_component_source *, bt_component_filter * or + # bt_component_sink *. Its type must match the type expected by the + # functions passed as arguments. + + def __init__(self, component_ptr, + borrow_port_ptr_by_name, + borrow_port_ptr_at_index, + get_port_count, + port_pycls): + self._component_ptr = component_ptr + self._borrow_port_ptr_by_name = borrow_port_ptr_by_name + self._borrow_port_ptr_at_index = borrow_port_ptr_at_index + self._get_port_count = get_port_count + self._port_pycls = port_pycls def __getitem__(self, key): utils._check_str(key) - port_ptr = self._get_port_by_name_fn(self._component._ptr, key) + port_ptr = self._borrow_port_ptr_by_name(self._component_ptr, key) if port_ptr is None: raise KeyError(key) - if self._is_private: - return bt2.port._create_private_from_ptr(port_ptr) - else: - return bt2.port._create_from_ptr(port_ptr) + return self._port_pycls._create_from_ptr_and_get_ref(port_ptr) def __len__(self): - if self._is_private: - pub_ptr = native_bt.component_from_private(self._component._ptr) - count = self._get_port_count_fn(pub_ptr) - native_bt.put(pub_ptr) - else: - count = self._get_port_count_fn(self._component._ptr) - - assert(count >= 0) + count = self._get_port_count(self._component_ptr) + assert count >= 0 return count def __iter__(self): @@ -184,22 +173,19 @@ class _ComponentPorts(collections.abc.Mapping): # passed specialized component pointer (e.g. 'bt_component_sink *'). # - _comp_cls_type: property, one of the native_bt.COMPONENT_CLASS_TYPE_* # constants. +# - _as_component_ptr: static method, must return the passed specialized +# component pointer (e.g. 'bt_component_sink *') as a 'bt_component *'. class _Component: @property def name(self): - name = native_bt.component_get_name(self._ptr) - assert(name is not None) + ptr = self._as_component_ptr(self._ptr) + name = native_bt.component_get_name(ptr) + assert name is not None return name @property - def graph(self): - ptr = native_bt.component_get_graph(self._ptr) - assert(ptr) - return bt2.Graph._create_from_ptr(ptr) - - @property - def component_class(self): + def cls(self): cc_ptr = self._borrow_component_class_ptr(self._ptr) assert cc_ptr is not None return _create_component_class_from_ptr_and_get_ref(cc_ptr, self._comp_cls_type) @@ -212,64 +198,77 @@ class _Component: class _SourceComponent(_Component): - _borrow_component_class_ptr = native_bt.component_source_borrow_class_const + _borrow_component_class_ptr = staticmethod(native_bt.component_source_borrow_class_const) _comp_cls_type = native_bt.COMPONENT_CLASS_TYPE_SOURCE - _as_component_class_ptr = native_bt.component_class_source_as_component_class + _as_component_class_ptr = staticmethod(native_bt.component_class_source_as_component_class) + _as_component_ptr = staticmethod(native_bt.component_source_as_component_const) class _FilterComponent(_Component): - _borrow_component_class_ptr = native_bt.component_filter_borrow_class_const + _borrow_component_class_ptr = staticmethod(native_bt.component_filter_borrow_class_const) _comp_cls_type = native_bt.COMPONENT_CLASS_TYPE_FILTER - _as_component_class_ptr = native_bt.component_class_filter_as_component_class + _as_component_class_ptr = staticmethod(native_bt.component_class_filter_as_component_class) + _as_component_ptr = staticmethod(native_bt.component_filter_as_component_const) class _SinkComponent(_Component): - _borrow_component_class_ptr = native_bt.component_sink_borrow_class_const + _borrow_component_class_ptr = staticmethod(native_bt.component_sink_borrow_class_const) _comp_cls_type = native_bt.COMPONENT_CLASS_TYPE_SINK - _as_component_class_ptr = native_bt.component_class_sink_as_component_class + _as_component_class_ptr = staticmethod(native_bt.component_class_sink_as_component_class) + _as_component_ptr = staticmethod(native_bt.component_sink_as_component_const) # This is analogous to _GenericSourceComponentClass, but for source # component objects. class _GenericSourceComponent(object._SharedObject, _SourceComponent): + _get_ref = staticmethod(native_bt.component_source_get_ref) + _put_ref = staticmethod(native_bt.component_source_put_ref) + @property def output_ports(self): - return _ComponentPorts(False, self, - native_bt.component_source_get_output_port_by_name, - native_bt.component_source_get_output_port_by_index, - native_bt.component_source_get_output_port_count) + return _ComponentPorts(self._ptr, + native_bt.component_source_borrow_output_port_by_name_const, + native_bt.component_source_borrow_output_port_by_index_const, + native_bt.component_source_get_output_port_count, + bt2.port._OutputPort) # This is analogous to _GenericFilterComponentClass, but for filter # component objects. class _GenericFilterComponent(object._SharedObject, _FilterComponent): + _get_ref = staticmethod(native_bt.component_filter_get_ref) + _put_ref = staticmethod(native_bt.component_filter_put_ref) + @property def output_ports(self): - return _ComponentPorts(False, self, - native_bt.component_filter_get_output_port_by_name, - native_bt.component_filter_get_output_port_by_index, - native_bt.component_filter_get_output_port_count) + return _ComponentPorts(self._ptr, + native_bt.component_filter_borrow_output_port_by_name_const, + native_bt.component_filter_borrow_output_port_by_index_const, + native_bt.component_filter_get_output_port_count, + bt2.port._OutputPort) @property def input_ports(self): - return _ComponentPorts(False, self, - native_bt.component_filter_get_input_port_by_name, - native_bt.component_filter_get_input_port_by_index, - native_bt.component_filter_get_input_port_count) + return _ComponentPorts(self._ptr, + native_bt.component_filter_borrow_input_port_by_name_const, + native_bt.component_filter_borrow_input_port_by_index_const, + native_bt.component_filter_get_input_port_count, + bt2.port._InputPort) # This is analogous to _GenericSinkComponentClass, but for sink # component objects. class _GenericSinkComponent(object._SharedObject, _SinkComponent): - _get_ref = native_bt.component_sink_get_ref - _put_ref = native_bt.component_sink_put_ref + _get_ref = staticmethod(native_bt.component_sink_get_ref) + _put_ref = staticmethod(native_bt.component_sink_put_ref) @property def input_ports(self): - return _ComponentPorts(False, self, - native_bt.component_sink_get_input_port_by_name, - native_bt.component_sink_get_input_port_by_index, - native_bt.component_sink_get_input_port_count) + return _ComponentPorts(self._ptr, + native_bt.component_sink_borrow_input_port_by_name_const, + native_bt.component_sink_borrow_input_port_by_index_const, + native_bt.component_sink_get_input_port_count, + bt2.port._InputPort) _COMP_CLS_TYPE_TO_GENERIC_COMP_PYCLS = { @@ -295,6 +294,14 @@ _COMP_CLS_TYPE_TO_GENERIC_COMP_CLS_PYCLS = { def _create_component_from_ptr(ptr, comp_cls_type): return _COMP_CLS_TYPE_TO_GENERIC_COMP_PYCLS[comp_cls_type]._create_from_ptr(ptr) + +# Same as the above, but acquire a new reference instead of stealing the +# reference from the caller. + +def _create_component_from_ptr_and_get_ref(ptr, comp_cls_type): + return _COMP_CLS_TYPE_TO_GENERIC_COMP_PYCLS[comp_cls_type]._create_from_ptr_and_get_ref(ptr) + + # Create a component class Python object of type # _GenericSourceComponentClass, _GenericFilterComponentClass or # _GenericSinkComponentClass, depending on comp_cls_type. @@ -548,31 +555,31 @@ class _UserComponentType(type): cc_ptr = cls._as_component_class_ptr(cls._cc_ptr) native_bt.component_class_put_ref(cc_ptr) +# Subclasses must provide these methods or property: +# +# - _as_not_self_specific_component_ptr: static method, must return the passed +# specialized self component pointer (e.g. 'bt_self_component_sink *') as a +# specialized non-self pointer (e.g. 'bt_component_sink *'). +# - _borrow_component_class_ptr: static method, must return a pointer to the +# specialized component class (e.g. 'bt_component_class_sink *') of the +# passed specialized component pointer (e.g. 'bt_component_sink *'). +# - _comp_cls_type: property, one of the native_bt.COMPONENT_CLASS_TYPE_* +# constants. class _UserComponent(metaclass=_UserComponentType): @property def name(self): - pub_ptr = native_bt.component_from_private(self._ptr) - name = native_bt.component_get_name(pub_ptr) - native_bt.put(pub_ptr) - assert(name is not None) + ptr = self._as_not_self_specific_component_ptr(self._ptr) + ptr = self._as_component_ptr(ptr) + name = native_bt.component_get_name(ptr) + assert name is not None return name @property - def graph(self): - pub_ptr = native_bt.component_from_private(self._ptr) - ptr = native_bt.component_get_graph(pub_ptr) - native_bt.put(pub_ptr) - assert(ptr) - return bt2.Graph._create_from_ptr(ptr) - - @property - def component_class(self): - pub_ptr = native_bt.component_from_private(self._ptr) - cc_ptr = native_bt.component_get_class(pub_ptr) - native_bt.put(pub_ptr) - assert(cc_ptr) - return _create_generic_component_class_from_ptr(cc_ptr) + def cls(self): + comp_ptr = self._as_not_self_specific_component_ptr(self._ptr) + cc_ptr = self._borrow_component_class_ptr(comp_ptr) + return _create_component_class_from_ptr_and_get_ref(cc_ptr, self._comp_cls_type) @property def addr(self): @@ -587,11 +594,17 @@ class _UserComponent(metaclass=_UserComponentType): def _accept_port_connection(self, port, other_port): return True - def _accept_port_connection_from_native(self, port_ptr, other_port_ptr): - native_bt.get(port_ptr) - native_bt.get(other_port_ptr) - port = bt2.port._create_private_from_ptr(port_ptr) - other_port = bt2.port._create_from_ptr(other_port_ptr) + def _accept_port_connection_from_native(self, self_port_ptr, self_port_type, other_port_ptr): + port = bt2.port._create_self_from_ptr_and_get_ref( + self_port_ptr, self_port_type) + + if self_port_type == native_bt.PORT_TYPE_OUTPUT: + other_port_type = native_bt.PORT_TYPE_INPUT + else: + other_port_type = native_bt.PORT_TYPE_OUTPUT + + other_port = bt2.port._create_from_ptr_and_get_ref( + other_port_ptr, other_port_type) res = self._accept_port_connection(port, other_port_ptr) if type(res) is not bool: @@ -602,97 +615,171 @@ class _UserComponent(metaclass=_UserComponentType): def _port_connected(self, port, other_port): pass - def _port_connected_from_native(self, port_ptr, other_port_ptr): - native_bt.get(port_ptr) - native_bt.get(other_port_ptr) - port = bt2.port._create_private_from_ptr(port_ptr) - other_port = bt2.port._create_from_ptr(other_port_ptr) + def _port_connected_from_native(self, self_port_ptr, self_port_type, other_port_ptr): + port = bt2.port._create_self_from_ptr_and_get_ref( + self_port_ptr, self_port_type) - try: - self._port_connected(port, other_port) - except: - if not _NO_PRINT_TRACEBACK: - traceback.print_exc() + if self_port_type == native_bt.PORT_TYPE_OUTPUT: + other_port_type = native_bt.PORT_TYPE_INPUT + else: + other_port_type = native_bt.PORT_TYPE_OUTPUT - def _port_disconnected(self, port): - pass + other_port = bt2.port._create_from_ptr_and_get_ref( + other_port_ptr, other_port_type) + self._port_connected(port, other_port) + + def _graph_is_configured_from_native(self): + self._graph_is_configured() + + def _create_trace_class(self, env=None, uuid=None, + assigns_automatic_stream_class_id=True): + ptr = self._as_self_component_ptr(self._ptr) + tc_ptr = native_bt.trace_class_create(ptr) + + if tc_ptr is None: + raise bt2.CreationError('could not create trace class') + + tc = bt2._TraceClass._create_from_ptr(tc_ptr) + + if env is not None: + for key, value in env.items(): + tc.env[key] = value + + if uuid is not None: + tc._uuid = uuid + + tc._assigns_automatic_stream_class_id = assigns_automatic_stream_class_id + + return tc + + def _create_clock_class(self, frequency=None, name=None, description=None, + precision=None, offset=None, origin_is_unix_epoch=True, + uuid=None): + ptr = self._as_self_component_ptr(self._ptr) + cc_ptr = native_bt.clock_class_create(ptr) + + if cc_ptr is None: + raise bt2.CreationError('could not create clock class') - def _port_disconnected_from_native(self, port_ptr): - native_bt.get(port_ptr) - port = bt2.port._create_private_from_ptr(port_ptr) + cc = bt2.clock_class._ClockClass._create_from_ptr(cc_ptr) - try: - self._port_disconnected(port) - except: - if not _NO_PRINT_TRACEBACK: - traceback.print_exc() + if frequency is not None: + cc._frequency = frequency + + if name is not None: + cc._name = name + + if description is not None: + cc._description = description + + if precision is not None: + cc._precision = precision + + if offset is not None: + cc._offset = offset + + cc._origin_is_unix_epoch = origin_is_unix_epoch + + if uuid is not None: + cc._uuid = uuid + + return cc class _UserSourceComponent(_UserComponent, _SourceComponent): + _as_not_self_specific_component_ptr = staticmethod(native_bt.self_component_source_as_component_source) + _as_self_component_ptr = staticmethod(native_bt.self_component_source_as_self_component) + @property def _output_ports(self): - return _ComponentPorts(True, self, - native_bt.private_component_source_get_output_private_port_by_name, - native_bt.private_component_source_get_output_private_port_by_index, - native_bt.component_source_get_output_port_count) + def get_output_port_count(self_ptr): + ptr = self._as_not_self_specific_component_ptr(self_ptr) + return native_bt.component_source_get_output_port_count(ptr) + + return _ComponentPorts(self._ptr, + native_bt.self_component_source_borrow_output_port_by_name, + native_bt.self_component_source_borrow_output_port_by_index, + get_output_port_count, + bt2.port._UserComponentOutputPort) - def _add_output_port(self, name): + def _add_output_port(self, name, user_data=None): utils._check_str(name) - fn = native_bt.private_component_source_add_output_private_port - comp_status, priv_port_ptr = fn(self._ptr, name, None) + fn = native_bt.self_component_source_add_output_port + comp_status, self_port_ptr = fn(self._ptr, name, user_data) _handle_component_status(comp_status, 'cannot add output port to source component object') - assert(priv_port_ptr) - return bt2.port._create_private_from_ptr(priv_port_ptr) + assert self_port_ptr is not None + return bt2.port._UserComponentOutputPort._create_from_ptr(self_port_ptr) class _UserFilterComponent(_UserComponent, _FilterComponent): + _as_not_self_specific_component_ptr = staticmethod(native_bt.self_component_filter_as_component_filter) + _as_self_component_ptr = staticmethod(native_bt.self_component_filter_as_self_component) + @property def _output_ports(self): - return _ComponentPorts(True, self, - native_bt.private_component_filter_get_output_private_port_by_name, - native_bt.private_component_filter_get_output_private_port_by_index, - native_bt.component_filter_get_output_port_count) + def get_output_port_count(self_ptr): + ptr = self._as_not_self_specific_component_ptr(self_ptr) + return native_bt.component_filter_get_output_port_count(ptr) + + return _ComponentPorts(self._ptr, + native_bt.self_component_filter_borrow_output_port_by_name, + native_bt.self_component_filter_borrow_output_port_by_index, + get_output_port_count, + bt2.port._UserComponentOutputPort) @property def _input_ports(self): - return _ComponentPorts(True, self, - native_bt.private_component_filter_get_input_private_port_by_name, - native_bt.private_component_filter_get_input_private_port_by_index, - native_bt.component_filter_get_input_port_count) + def get_input_port_count(self_ptr): + ptr = self._as_not_self_specific_component_ptr(self_ptr) + return native_bt.component_filter_get_input_port_count(ptr) - def _add_output_port(self, name): + return _ComponentPorts(self._ptr, + native_bt.self_component_filter_borrow_input_port_by_name, + native_bt.self_component_filter_borrow_input_port_by_index, + get_input_port_count, + bt2.port._UserComponentInputPort) + + def _add_output_port(self, name, user_data=None): utils._check_str(name) - fn = native_bt.private_component_filter_add_output_private_port - comp_status, priv_port_ptr = fn(self._ptr, name, None) + fn = native_bt.self_component_filter_add_output_port + comp_status, self_port_ptr = fn(self._ptr, name, user_data) _handle_component_status(comp_status, 'cannot add output port to filter component object') - assert(priv_port_ptr) - return bt2.port._create_private_from_ptr(priv_port_ptr) + assert self_port_ptr + return bt2.port._UserComponentOutputPort._create_from_ptr(self_port_ptr) - def _add_input_port(self, name): + def _add_input_port(self, name, user_data=None): utils._check_str(name) - fn = native_bt.private_component_filter_add_input_private_port - comp_status, priv_port_ptr = fn(self._ptr, name, None) + fn = native_bt.self_component_filter_add_input_port + comp_status, self_port_ptr = fn(self._ptr, name, user_data) _handle_component_status(comp_status, 'cannot add input port to filter component object') - assert(priv_port_ptr) - return bt2.port._create_private_from_ptr(priv_port_ptr) + assert self_port_ptr + return bt2.port._UserComponentInputPort._create_from_ptr(self_port_ptr) class _UserSinkComponent(_UserComponent, _SinkComponent): + _as_not_self_specific_component_ptr = staticmethod(native_bt.self_component_sink_as_component_sink) + _as_self_component_ptr = staticmethod(native_bt.self_component_sink_as_self_component) + @property def _input_ports(self): - return _ComponentPorts(True, self, - native_bt.private_component_sink_get_input_private_port_by_name, - native_bt.private_component_sink_get_input_private_port_by_index, - native_bt.component_sink_get_input_port_count) + def get_input_port_count(self_ptr): + ptr = self._as_not_self_specific_component_ptr(self_ptr) + return native_bt.component_sink_get_input_port_count(ptr) + + return _ComponentPorts(self._ptr, + native_bt.self_component_sink_borrow_input_port_by_name, + native_bt.self_component_sink_borrow_input_port_by_index, + get_input_port_count, + bt2.port._UserComponentInputPort) - def _add_input_port(self, name): + def _add_input_port(self, name, user_data=None): utils._check_str(name) - fn = native_bt.private_component_sink_add_input_private_port - comp_status, priv_port_ptr = fn(self._ptr, name, None) + fn = native_bt.self_component_sink_add_input_port + comp_status, self_port_ptr = fn(self._ptr, name, user_data) _handle_component_status(comp_status, 'cannot add input port to sink component object') - assert(priv_port_ptr) - return bt2.port._create_private_from_ptr(priv_port_ptr) + assert self_port_ptr + return bt2.port._UserComponentInputPort._create_from_ptr(self_port_ptr)