def __init__(self, name, description=None, frequency=None, precision=None,
offset=None, is_absolute=None, uuid=None):
utils._check_str(name)
ptr = native_bt.ctf_clock_class_create(name)
if ptr is None:
raise bt2.CreationError('cannot create clock class object')
super().__init__(ptr)
if description is not None:
self.description = description
if frequency is not None:
self.frequency = frequency
if precision is not None:
self.precision = precision
if offset is not None:
self.offset = offset
if is_absolute is not None:
self.is_absolute = is_absolute
if uuid is not None:
self.uuid = uuid
def query(self, component_class, object, params=None):
if self.is_canceled:
raise bt2.QueryExecutorCanceled
if not isinstance(component_class, bt2.component._GenericComponentClass):
err = False
try:
if not issubclass(component_class, bt2.component._UserComponent):
err = True
except TypeError:
err = True
if err:
o = component_class
raise TypeError("'{}' is not a component class object".format(o))
utils._check_str(object)
if params is None:
params_ptr = native_bt.value_null
else:
params = bt2.create_value(params)
params_ptr = params._ptr
cc_ptr = component_class._component_class_ptr()
status, result_ptr = native_bt.query_executor_query(self._ptr, cc_ptr,
object, params_ptr)
self._handle_status(status, 'cannot query component class')
assert(result_ptr)
return bt2.value._create_from_ptr(result_ptr)
def __setitem__(self, key, value):
utils._check_str(key)
value = bt2.create_value(value)
ret = native_bt.trace_set_environment_field(self._trace._ptr, key,
value._ptr)
utils._handle_ret(ret,
"cannot set trace class object's environment entry")
def __init__(self,
name,
id=None,
log_level=None,
emf_uri=None,
context_field_class=None,
payload_field_class=None):
utils._check_str(name)
ptr = native_bt.event_class_create(name)
if ptr is None:
raise bt2.CreationError('cannot create event class object')
super().__init__(ptr)
if id is not None:
self.id = id
if log_level is not None:
self.log_level = log_level
if emf_uri is not None:
self.emf_uri = emf_uri
if context_field_class is not None:
self.context_field_class = context_field_class
if payload_field_class is not None:
self.payload_field_class = payload_field_class
def append_option(self, name, field_class, ranges, user_attributes=None):
utils._check_str(name)
utils._check_type(field_class, _FieldClass)
utils._check_type(ranges, self._variant_option_pycls._range_set_pycls)
if name in self:
raise ValueError("duplicate option name '{}'".format(name))
if len(ranges) == 0:
raise ValueError('range set is empty')
user_attributes_value = None
if user_attributes is not None:
# check now that user attributes are valid
user_attributes_value = bt2.create_value(user_attributes)
# TODO: check overlaps (precondition of self._append_option())
status = self._append_option(self._ptr, name, field_class._ptr, ranges._ptr)
utils._handle_func_status(
status, 'cannot append option to variant field class object'
)
if user_attributes is not None:
self[name]._user_attributes = user_attributes_value
def __init__(cls, class_name, bases, namespace, **kwargs):
super().__init__(class_name, bases, namespace)
# skip our own bases; they are never directly instantiated by the user
own_bases = (
'_UserComponent',
'_UserFilterSinkComponent',
'_UserSourceComponent',
'_UserFilterComponent',
'_UserSinkComponent',
)
if class_name in own_bases:
return
comp_cls_name = kwargs.get('name', class_name)
utils._check_str(comp_cls_name)
comp_cls_descr = None
comp_cls_help = None
if hasattr(cls, '__doc__') and cls.__doc__ is not None:
utils._check_str(cls.__doc__)
docstring = _trim_docstring(cls.__doc__)
lines = docstring.splitlines()
if len(lines) >= 1:
comp_cls_descr = lines[0]
if len(lines) >= 3:
comp_cls_help = '\n'.join(lines[2:])
iter_cls = kwargs.get('message_iterator_class')
if _UserSourceComponent in bases:
_UserComponentType._set_iterator_class(cls, iter_cls)
cc_ptr = native_bt.py3_component_class_source_create(cls,
comp_cls_name,
comp_cls_descr,
comp_cls_help)
elif _UserFilterComponent in bases:
_UserComponentType._set_iterator_class(cls, iter_cls)
cc_ptr = native_bt.py3_component_class_filter_create(cls,
comp_cls_name,
comp_cls_descr,
comp_cls_help)
elif _UserSinkComponent in bases:
if not hasattr(cls, '_consume'):
raise bt2.IncompleteUserClass("cannot create component class '{}': missing a _consume() method".format(class_name))
cc_ptr = native_bt.py3_component_class_sink_create(cls,
comp_cls_name,
comp_cls_descr,
comp_cls_help)
else:
raise bt2.IncompleteUserClass("cannot find a known component class base in the bases of '{}'".format(class_name))
if cc_ptr is None:
raise bt2.CreationError("cannot create component class '{}'".format(class_name))
cls._cc_ptr = cc_ptr
def __init__(self,
name,
id=None,
context_field_type=None,
payload_field_type=None,
attributes=None):
utils._check_str(name)
ptr = native_bt.ctf_event_class_create(name)
if ptr is None:
raise bt2.CreationError('cannot create event class object')
super().__init__(ptr)
if id is not None:
self.id = id
if context_field_type is not None:
self.context_field_type = context_field_type
if payload_field_type is not None:
self.payload_field_type = payload_field_type
if attributes is not None:
for name, value in attributes.items():
self.attributes[name] = value
def __init__(self, element_field_class, length_name):
utils._check_type(element_field_class, _FieldClass)
utils._check_str(length_name)
ptr = native_bt.field_class_sequence_create(element_field_class._ptr,
length_name)
self._check_create_status(ptr)
super().__init__(ptr)
def find_plugin(
name,
find_in_std_env_var=True,
find_in_user_dir=True,
find_in_sys_dir=True,
find_in_static=True,
fail_on_load_error=False,
):
utils._check_str(name)
utils._check_bool(fail_on_load_error)
status, ptr = native_bt.bt2_plugin_find(
name,
int(find_in_std_env_var),
int(find_in_user_dir),
int(find_in_sys_dir),
int(find_in_static),
int(fail_on_load_error),
)
if status == native_bt.__BT_FUNC_STATUS_NOT_FOUND:
return
utils._handle_func_status(status, 'failed to find plugin')
assert ptr is not None
return _Plugin._create_from_ptr(ptr)
def __init__(self,
name,
description=None,
frequency=None,
precision=None,
offset=None,
is_absolute=None,
uuid=None):
utils._check_str(name)
ptr = native_bt.ctf_clock_create(name)
if ptr is None:
raise bt2.CreationError('cannot create CTF writer clock object')
super().__init__(ptr)
if description is not None:
self.description = description
if frequency is not None:
self.frequency = frequency
if precision is not None:
self.precision = precision
if offset is not None:
self.offset = offset
if is_absolute is not None:
self.is_absolute = is_absolute
if uuid is not None:
self.uuid = uuid
def query(self, component_class, object, params=None):
if self.is_canceled:
raise bt2.QueryExecutorCanceled
if not isinstance(component_class, bt2.component._GenericComponentClass):
err = False
try:
if not issubclass(component_class, bt2.component._UserComponent):
err = True
except TypeError:
err = True
if err:
o = component_class
raise TypeError("'{}' is not a component class object".format(o))
utils._check_str(object)
if params is None:
params_ptr = native_bt.value_null
else:
params = bt2.create_value(params)
params_ptr = params._ptr
cc_ptr = component_class._component_class_ptr()
status, result_ptr = native_bt.query_executor_query(self._ptr, cc_ptr,
object, params_ptr)
self._handle_status(status, 'cannot query component class')
assert(result_ptr)
return bt2.value._create_from_ptr(result_ptr)
def __init__(self, element_field_type, length_name):
utils._check_type(element_field_type, _FieldType)
utils._check_str(length_name)
ptr = native_bt.ctf_field_type_sequence_create(element_field_type._ptr,
length_name)
self._check_create_status(ptr)
super().__init__(ptr)
def __init__(self, element_field_class, length_name):
utils._check_type(element_field_class, _FieldClass)
utils._check_str(length_name)
ptr = native_bt.field_class_sequence_create(element_field_class._ptr,
length_name)
self._check_create_status(ptr)
super().__init__(ptr)
def append_field(self, name, field_class):
utils._check_str(name)
utils._check_type(field_class, _FieldClass)
ret = self._add_field(field_class._ptr, name)
utils._handle_ret(
ret, "cannot add field to {} field class object".format(
self._NAME.lower()))
def __init__(cls, class_name, bases, namespace, **kwargs):
super().__init__(class_name, bases, namespace)
# skip our own bases; they are never directly instantiated by the user
own_bases = (
'_UserComponent',
'_UserFilterSinkComponent',
'_UserSourceComponent',
'_UserFilterComponent',
'_UserSinkComponent',
)
if class_name in own_bases:
return
comp_cls_name = kwargs.get('name', class_name)
utils._check_str(comp_cls_name)
comp_cls_descr = None
comp_cls_help = None
if hasattr(cls, '__doc__') and cls.__doc__ is not None:
utils._check_str(cls.__doc__)
docstring = _trim_docstring(cls.__doc__)
lines = docstring.splitlines()
if len(lines) >= 1:
comp_cls_descr = lines[0]
if len(lines) >= 3:
comp_cls_help = '\n'.join(lines[2:])
iter_cls = kwargs.get('message_iterator_class')
if _UserSourceComponent in bases:
_UserComponentType._bt_set_iterator_class(cls, iter_cls)
cc_ptr = native_bt.bt2_component_class_source_create(
cls, comp_cls_name, comp_cls_descr, comp_cls_help)
elif _UserFilterComponent in bases:
_UserComponentType._bt_set_iterator_class(cls, iter_cls)
cc_ptr = native_bt.bt2_component_class_filter_create(
cls, comp_cls_name, comp_cls_descr, comp_cls_help)
elif _UserSinkComponent in bases:
if not hasattr(cls, '_user_consume'):
raise bt2._IncompleteUserClass(
"cannot create component class '{}': missing a _user_consume() method"
.format(class_name))
cc_ptr = native_bt.bt2_component_class_sink_create(
cls, comp_cls_name, comp_cls_descr, comp_cls_help)
else:
raise bt2._IncompleteUserClass(
"cannot find a known component class base in the bases of '{}'"
.format(class_name))
if cc_ptr is None:
raise bt2._MemoryError(
"cannot create component class '{}'".format(class_name))
cls._bt_cc_ptr = cc_ptr
def add_component(
self,
component_class,
name,
params=None,
obj=None,
logging_level=bt2_logging.LoggingLevel.NONE,
):
if isinstance(component_class, bt2_component._SourceComponentClassConst):
cc_ptr = component_class._ptr
add_fn = native_bt.bt2_graph_add_source_component
cc_type = native_bt.COMPONENT_CLASS_TYPE_SOURCE
elif isinstance(component_class, bt2_component._FilterComponentClassConst):
cc_ptr = component_class._ptr
add_fn = native_bt.bt2_graph_add_filter_component
cc_type = native_bt.COMPONENT_CLASS_TYPE_FILTER
elif isinstance(component_class, bt2_component._SinkComponentClassConst):
cc_ptr = component_class._ptr
add_fn = native_bt.bt2_graph_add_sink_component
cc_type = native_bt.COMPONENT_CLASS_TYPE_SINK
elif issubclass(component_class, bt2_component._UserSourceComponent):
cc_ptr = component_class._bt_cc_ptr
add_fn = native_bt.bt2_graph_add_source_component
cc_type = native_bt.COMPONENT_CLASS_TYPE_SOURCE
elif issubclass(component_class, bt2_component._UserSinkComponent):
cc_ptr = component_class._bt_cc_ptr
add_fn = native_bt.bt2_graph_add_sink_component
cc_type = native_bt.COMPONENT_CLASS_TYPE_SINK
elif issubclass(component_class, bt2_component._UserFilterComponent):
cc_ptr = component_class._bt_cc_ptr
add_fn = native_bt.bt2_graph_add_filter_component
cc_type = native_bt.COMPONENT_CLASS_TYPE_FILTER
else:
raise TypeError(
"'{}' is not a component class".format(
component_class.__class__.__name__
)
)
utils._check_str(name)
utils._check_log_level(logging_level)
base_cc_ptr = component_class._bt_component_class_ptr()
if obj is not None and not native_bt.bt2_is_python_component_class(base_cc_ptr):
raise ValueError('cannot pass a Python object to a non-Python component')
if params is not None and not isinstance(params, (dict, bt2.MapValue)):
raise TypeError("'params' parameter is not a 'dict' or a 'bt2.MapValue'.")
params = bt2.create_value(params)
params_ptr = params._ptr if params is not None else None
status, comp_ptr = add_fn(
self._ptr, cc_ptr, name, params_ptr, obj, logging_level
)
utils._handle_func_status(status, 'cannot add component to graph')
assert comp_ptr
return bt2_component._create_component_from_const_ptr(comp_ptr, cc_type)
def _add_input_port(self, name, user_data=None):
utils._check_str(name)
fn = native_bt.self_component_sink_add_input_port
comp_status, self_port_ptr = fn(self._bt_ptr, name, user_data)
utils._handle_func_status(
comp_status, 'cannot add input port to sink component object')
assert self_port_ptr
return bt2_port._UserComponentInputPort._create_from_ptr(self_port_ptr)
def __getitem__(self, key):
utils._check_str(key)
cc_ptr = native_bt.trace_get_clock_class_by_name(self._trace._ptr, key)
if cc_ptr is None:
raise KeyError(key)
return bt2.ClockClass._create_from_ptr(cc_ptr)
def __getitem__(self, key):
utils._check_str(key)
port_ptr = self._borrow_port_ptr_by_name(self._component_ptr, key)
if port_ptr is None:
raise KeyError(key)
return self._port_pycls._create_from_ptr_and_get_ref(port_ptr)
def __getitem__(self, label):
utils._check_str(label)
mapping_ptr = self._borrow_mapping_ptr_by_label(self._ptr, label)
if mapping_ptr is None:
raise KeyError(label)
return self._mapping_pycls(mapping_ptr)
def __getitem__(self, key):
utils._check_str(key)
ptr = native_bt.ctf_field_structure_get_field(self._ptr, key)
if ptr is None:
raise KeyError(key)
return _create_from_ptr(ptr)
def create_plugin_from_name(name):
utils._check_str(name)
plugin_ptr = native_bt.plugin_create_from_name(name)
if plugin_ptr is None:
raise bt2.NoSuchPluginError(name)
return _Plugin._create_from_ptr(plugin_ptr)
def create_plugins_from_dir(path, recurse=True):
utils._check_str(path)
plugin_ptrs = native_bt.py3_plugin_create_all_from_dir(path, recurse)
if plugin_ptrs is None:
raise bt2.Error('cannot get plugin objects from directory')
return _plugin_ptrs_to_plugins(plugin_ptrs)
def create_plugins_from_file(path):
utils._check_str(path)
plugin_ptrs = native_bt.py3_plugin_create_all_from_file(path)
if plugin_ptrs is None:
raise bt2.Error('cannot get plugin objects from file')
return _plugin_ptrs_to_plugins(plugin_ptrs)
def __getitem__(self, key):
utils._check_str(key)
ptr = native_bt.field_structure_get_field_by_name(self._ptr, key)
if ptr is None:
raise KeyError(key)
return _create_from_ptr(ptr)
def __getitem__(self, key):
utils._check_str(key)
cc_ptr = self._borrow_component_class_by_name(self._plugin._ptr, key)
if cc_ptr is None:
raise KeyError(key)
return bt2.component._create_component_class_from_ptr_and_get_ref(cc_ptr, self._comp_cls_type)
def _add_input_port(self, name):
utils._check_str(name)
fn = native_bt.private_component_sink_add_input_private_port
comp_status, priv_port_ptr = fn(self._ptr, name, None)
_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)
def find_plugin(name):
utils._check_str(name)
ptr = native_bt.plugin_find(name)
if ptr is None:
return
return _Plugin._create_from_ptr(ptr)
def __getitem__(self, label):
utils._check_str(label)
mapping = self._get_mapping_by_label(self._ptr, label)
if mapping is None:
raise KeyError(label)
return mapping
def _add_input_port(self, name):
utils._check_str(name)
fn = native_bt.private_component_sink_add_input_private_port
comp_status, priv_port_ptr = fn(self._ptr, name, None)
_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)
def __getitem__(self, key):
utils._check_str(key)
cc_ptr = native_bt.trace_get_clock_class_by_name(self._trace._ptr, key)
if cc_ptr is None:
raise KeyError(key)
return bt2.ClockClass._create_from_ptr(cc_ptr)
def find_plugin(name):
utils._check_str(name)
ptr = native_bt.plugin_find(name)
if ptr is None:
return
return _Plugin._create_from_ptr(ptr)
def __init__(self, path):
utils._check_str(path)
ptr = native_bt.ctf_writer_create(path)
if ptr is None:
raise bt2.CreationError('cannot create CTF writer object')
super().__init__(ptr)
def __init__(self, path):
utils._check_str(path)
ptr = native_bt.ctf_writer_create(path)
if ptr is None:
raise bt2.CreationError('cannot create CTF writer object')
super().__init__(ptr)
def __getitem__(self, key):
utils._check_str(key)
cc_ptr = native_bt.plugin_get_component_class_by_name_and_type(
self._plugin._ptr, key, self._comp_cls_type)
if cc_ptr is None:
raise KeyError(key)
return bt2.component._create_generic_component_class_from_ptr(cc_ptr)
def __getitem__(self, key):
utils._check_str(key)
cc_ptr = self._borrow_component_class_by_name(self._plugin._ptr, key)
if cc_ptr is None:
raise KeyError(key)
return bt2_component._create_component_class_from_const_ptr_and_get_ref(
cc_ptr, self._comp_cls_type)
def __getitem__(self, key):
utils._check_str(key)
ec_ptr = native_bt.ctf_stream_class_get_event_class_by_name(
self._ptr, key)
if ec_ptr is None:
raise KeyError(key)
return bt2.EventClass._create_from_ptr(ec_ptr)
def __getitem__(self, key):
utils._check_str(key)
value_ptr = native_bt.trace_get_environment_field_value_by_name(self._trace._ptr,
key)
if value_ptr is None:
raise KeyError(key)
return bt2.value._create_from_ptr(value_ptr)
def __getitem__(self, key):
utils._check_str(key)
ec_ptr = native_bt.ctf_stream_class_get_event_class_by_name(self._ptr,
key)
if ec_ptr is None:
raise KeyError(key)
return bt2.EventClass._create_from_ptr(ec_ptr)
def _add_output_port(self, name, user_data=None):
utils._check_str(name)
fn = native_bt.self_component_filter_add_output_port
comp_status, self_port_ptr = fn(self._bt_ptr, name, user_data)
utils._handle_func_status(
comp_status, 'cannot add output port to filter component object')
assert self_port_ptr
return bt2_port._UserComponentOutputPort._create_from_ptr_and_get_ref(
self_port_ptr)
def __getitem__(self, key):
utils._check_str(key)
value_ptr = native_bt.ctf_event_class_get_attribute_value_by_name(self._event_class_ptr,
key)
if value_ptr is None:
raise KeyError(key)
return bt2.values._create_from_ptr(value_ptr)
def __getitem__(self, key):
utils._check_str(key)
value_ptr = native_bt.trace_get_environment_field_value_by_name(self._trace._ptr,
key)
if value_ptr is None:
raise KeyError(key)
return bt2.values._create_from_ptr(value_ptr)
def __getitem__(self, key):
utils._check_str(key)
value_ptr = native_bt.ctf_event_class_get_attribute_value_by_name(
self._event_class_ptr, key)
if value_ptr is None:
raise KeyError(key)
return bt2.values._create_from_ptr(value_ptr)
def __init__(self, plugin_name, component_class_name, params=None):
utils._check_str(plugin_name)
utils._check_str(component_class_name)
self._plugin_name = plugin_name
self._component_class_name = component_class_name
if type(params) is str:
self._params = bt2.create_value({'path': params})
else:
self._params = bt2.create_value(params)
def sink_component_class(self, name):
utils._check_str(name)
cc_ptr = native_bt.plugin_get_component_class_by_name_and_type(self._ptr,
name,
native_bt.COMPONENT_CLASS_TYPE_SINK)
if cc_ptr is None:
return
return bt2.component._create_generic_component_class_from_ptr(cc_ptr)
def __getitem__(self, key):
utils._check_str(key)
cc_ptr = native_bt.plugin_get_component_class_by_name_and_type(self._plugin._ptr,
key,
self._comp_cls_type)
if cc_ptr is None:
raise KeyError(key)
return bt2.component._create_generic_component_class_from_ptr(cc_ptr)
def __call__(self, name=None):
if name is not None:
utils._check_str(name)
stream_ptr = native_bt.ctf_stream_create(self._ptr, name)
if stream_ptr is None:
raise bt2.CreationError('cannot create stream object')
return bt2.stream._create_from_ptr(stream_ptr)
def __getitem__(self, key):
utils._check_str(key)
port_ptr = self._get_port_by_name_fn(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)
def __init__(self, tag_name, tag_field_type=None):
utils._check_str(tag_name)
if tag_field_type is None:
tag_ft_ptr = None
else:
utils._check_type(tag_field_type, EnumerationFieldType)
tag_ft_ptr = tag_field_type._ptr
ptr = native_bt.field_type_variant_create(tag_ft_ptr,
tag_name)
self._check_create_status(ptr)
super().__init__(ptr)
def __init__(self, tag_name, tag_field_class=None):
utils._check_str(tag_name)
if tag_field_class is None:
tag_fc_ptr = None
else:
utils._check_type(tag_field_class, EnumerationFieldClass)
tag_fc_ptr = tag_field_class._ptr
ptr = native_bt.field_class_variant_create(tag_fc_ptr,
tag_name)
self._check_create_status(ptr)
super().__init__(ptr)
def register_plugin(module_name, name, description=None, author=None,
license=None, version=None):
import sys
if module_name not in sys.modules:
raise RuntimeError("cannot find module '{}' in loaded modules".format(module_name))
utils._check_str(name)
if description is not None:
utils._check_str(description)
if author is not None:
utils._check_str(author)
if license is not None:
utils._check_str(license)
if version is not None:
if not _validate_version(version):
raise ValueError('wrong version: expecting a tuple: (major, minor, patch) or (major, minor, patch, extra)')
sys.modules[module_name]._bt_plugin_info = _PluginInfo(name, description,
author, license,
version)
def find_plugins(path, recurse=True):
utils._check_str(path)
utils._check_bool(recurse)
plugin_set_ptr = None
if os.path.isfile(path):
plugin_set_ptr = native_bt.plugin_create_all_from_file(path)
elif os.path.isdir(path):
plugin_set_ptr = native_bt.plugin_create_all_from_dir(path, int(recurse))
if plugin_set_ptr is None:
return
return _PluginSet._create_from_ptr(plugin_set_ptr)
def create_notification_iterator(self, notification_types=None,
colander_component_name=None):
notif_types = bt2.notification._notif_types_from_notif_classes(notification_types)
if colander_component_name is not None:
utils._check_str(colander_component_name)
notif_iter_ptr = native_bt.py3_create_output_port_notif_iter(int(self._ptr),
colander_component_name,
notif_types)
if notif_iter_ptr is None:
raise bt2.CreationError('cannot create output port notification iterator')
return bt2.notification_iterator._OutputPortNotificationIterator._create_from_ptr(notif_iter_ptr)
def add_mapping(self, name, lower, upper=None):
utils._check_str(name)
if upper is None:
upper = lower
if self.is_signed:
add_fn = native_bt.field_class_enumeration_add_mapping_signed
utils._check_int64(lower)
utils._check_int64(upper)
else:
add_fn = native_bt.field_class_enumeration_add_mapping_unsigned
utils._check_uint64(lower)
utils._check_uint64(upper)
ret = add_fn(self._ptr, name, lower, upper)
utils._handle_ret(ret, "cannot add mapping to enumeration field class object")
def _query(comp_cls_ptr, obj, params):
utils._check_str(obj)
if params is None:
params_ptr = native_bt.value_null
else:
params = bt2.create_value(params)
params_ptr = params._ptr
results_ptr = native_bt.component_class_query(comp_cls_ptr, obj,
params_ptr)
if results_ptr is None:
raise bt2.Error('cannot query info with object "{}"'.format(obj))
if results_ptr == native_bt.value_null:
return
return bt2.values._create_from_ptr(results_ptr)
def add_component(self, component_class, name, params=None):
if isinstance(component_class, bt2.component._GenericComponentClass):
cc_ptr = component_class._ptr
elif issubclass(component_class, bt2.component._UserComponent):
cc_ptr = component_class._cc_ptr
else:
raise TypeError("'{}' is not a component class".format(component_class.__class__.__name__))
utils._check_str(name)
params = bt2.create_value(params)
if params is None:
params_ptr = None
else:
params_ptr = params._ptr
status, comp_ptr = native_bt.graph_add_component(self._ptr, cc_ptr,
name, params_ptr)
self._handle_status(status, 'cannot add component to graph')
assert(comp_ptr)
return bt2.component._create_generic_component_from_ptr(comp_ptr)
