1 # The MIT License (MIT)
3 # Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
5 # Permission is hereby granted, free of charge, to any person obtaining a copy
6 # of this software and associated documentation files (the "Software"), to deal
7 # in the Software without restriction, including without limitation the rights
8 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 # copies of the Software, and to permit persons to whom the Software is
10 # furnished to do so, subject to the following conditions:
12 # The above copyright notice and this permission notice shall be included in
13 # all copies or substantial portions of the Software.
15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 from bt2
import native_bt
, object, utils
24 import bt2
.message_iterator
25 import collections
.abc
34 _env_var
= os
.environ
.get('BABELTRACE_PYTHON_BT2_NO_TRACEBACK')
35 _NO_PRINT_TRACEBACK
= _env_var
== '1'
38 # This class wraps a component class pointer. This component class could
39 # have been created by Python code, but since we only have the pointer,
40 # we can only wrap it in a generic way and lose the original Python
43 # Subclasses must implement some methods that this base class uses:
45 # - _as_component_class_ptr: static method, convert the passed component class
46 # pointer to a 'bt_component_class *'.
48 class _GenericComponentClass(object._SharedObject
):
51 ptr
= self
._as
_component
_class
_ptr
(self
._ptr
)
52 name
= native_bt
.component_class_get_name(ptr
)
53 assert name
is not None
57 def description(self
):
58 ptr
= self
._as
_component
_class
_ptr
(self
._ptr
)
59 return native_bt
.component_class_get_description(ptr
)
63 ptr
= self
._as
_component
_class
_ptr
(self
._ptr
)
64 return native_bt
.component_class_get_help(ptr
)
66 def _component_class_ptr(self
):
67 return self
._as
_component
_class
_ptr
(self
._ptr
)
69 def __eq__(self
, other
):
70 if not isinstance(other
, _GenericComponentClass
):
72 if not issubclass(other
, _UserComponent
):
77 return self
.addr
== other
.addr
80 class _GenericSourceComponentClass(_GenericComponentClass
):
81 _get_ref
= staticmethod(native_bt
.component_class_source_get_ref
)
82 _put_ref
= staticmethod(native_bt
.component_class_source_put_ref
)
83 _as_component_class_ptr
= staticmethod(native_bt
.component_class_source_as_component_class
)
86 class _GenericFilterComponentClass(_GenericComponentClass
):
87 _get_ref
= staticmethod(native_bt
.component_class_filter_get_ref
)
88 _put_ref
= staticmethod(native_bt
.component_class_filter_put_ref
)
89 _as_component_class_ptr
= staticmethod(native_bt
.component_class_filter_as_component_class
)
92 class _GenericSinkComponentClass(_GenericComponentClass
):
93 _get_ref
= staticmethod(native_bt
.component_class_sink_get_ref
)
94 _put_ref
= staticmethod(native_bt
.component_class_sink_put_ref
)
95 _as_component_class_ptr
= staticmethod(native_bt
.component_class_sink_as_component_class
)
98 def _handle_component_status(status
, gen_error_msg
):
99 if status
== native_bt
.SELF_COMPONENT_STATUS_END
:
101 elif status
== native_bt
.SELF_COMPONENT_STATUS_AGAIN
:
103 elif status
== native_bt
.SELF_COMPONENT_STATUS_REFUSE_PORT_CONNECTION
:
104 raise bt2
.PortConnectionRefused
106 raise bt2
.Error(gen_error_msg
)
109 class _PortIterator(collections
.abc
.Iterator
):
110 def __init__(self
, comp_ports
):
111 self
._comp
_ports
= comp_ports
115 if self
._at
== len(self
._comp
_ports
):
118 comp_ports
= self
._comp
_ports
119 comp_ptr
= comp_ports
._component
_ptr
121 port_ptr
= comp_ports
._borrow
_port
_ptr
_at
_index
(comp_ptr
, self
._at
)
122 assert port_ptr
is not None
124 name
= native_bt
.port_get_name(comp_ports
._port
_pycls
._as
_port
_ptr
(port_ptr
))
125 assert name
is not None
131 class _ComponentPorts(collections
.abc
.Mapping
):
133 # component_ptr is a bt_component_source *, bt_component_filter * or
134 # bt_component_sink *. Its type must match the type expected by the
135 # functions passed as arguments.
137 def __init__(self
, component_ptr
,
138 borrow_port_ptr_by_name
,
139 borrow_port_ptr_at_index
,
142 self
._component
_ptr
= component_ptr
143 self
._borrow
_port
_ptr
_by
_name
= borrow_port_ptr_by_name
144 self
._borrow
_port
_ptr
_at
_index
= borrow_port_ptr_at_index
145 self
._get
_port
_count
= get_port_count
146 self
._port
_pycls
= port_pycls
148 def __getitem__(self
, key
):
149 utils
._check
_str
(key
)
150 port_ptr
= self
._borrow
_port
_ptr
_by
_name
(self
._component
_ptr
, key
)
155 return self
._port
_pycls
._create
_from
_ptr
_and
_get
_ref
(port_ptr
)
158 count
= self
._get
_port
_count
(self
._component
_ptr
)
163 return _PortIterator(self
)
166 # This class holds the methods which are common to both generic
167 # component objects and Python user component objects.
169 # Subclasses must provide these methods or property:
171 # - _borrow_component_class_ptr: static method, must return a pointer to the
172 # specialized component class (e.g. 'bt_component_class_sink *') of the
173 # passed specialized component pointer (e.g. 'bt_component_sink *').
174 # - _comp_cls_type: property, one of the native_bt.COMPONENT_CLASS_TYPE_*
176 # - _as_component_ptr: static method, must return the passed specialized
177 # component pointer (e.g. 'bt_component_sink *') as a 'bt_component *'.
182 ptr
= self
._as
_component
_ptr
(self
._ptr
)
183 name
= native_bt
.component_get_name(ptr
)
184 assert name
is not None
188 def component_class(self
):
189 cc_ptr
= self
._borrow
_component
_class
_ptr
(self
._ptr
)
190 assert cc_ptr
is not None
191 return _create_component_class_from_ptr_and_get_ref(cc_ptr
, self
._comp
_cls
_type
)
193 def __eq__(self
, other
):
194 if not hasattr(other
, 'addr'):
197 return self
.addr
== other
.addr
200 class _SourceComponent(_Component
):
201 _borrow_component_class_ptr
= staticmethod(native_bt
.component_source_borrow_class_const
)
202 _comp_cls_type
= native_bt
.COMPONENT_CLASS_TYPE_SOURCE
203 _as_component_class_ptr
= staticmethod(native_bt
.component_class_source_as_component_class
)
204 _as_component_ptr
= staticmethod(native_bt
.component_source_as_component_const
)
207 class _FilterComponent(_Component
):
208 _borrow_component_class_ptr
= staticmethod(native_bt
.component_filter_borrow_class_const
)
209 _comp_cls_type
= native_bt
.COMPONENT_CLASS_TYPE_FILTER
210 _as_component_class_ptr
= staticmethod(native_bt
.component_class_filter_as_component_class
)
211 _as_component_ptr
= staticmethod(native_bt
.component_filter_as_component_const
)
214 class _SinkComponent(_Component
):
215 _borrow_component_class_ptr
= staticmethod(native_bt
.component_sink_borrow_class_const
)
216 _comp_cls_type
= native_bt
.COMPONENT_CLASS_TYPE_SINK
217 _as_component_class_ptr
= staticmethod(native_bt
.component_class_sink_as_component_class
)
218 _as_component_ptr
= staticmethod(native_bt
.component_sink_as_component_const
)
221 # This is analogous to _GenericSourceComponentClass, but for source
223 class _GenericSourceComponent(object._SharedObject
, _SourceComponent
):
224 _get_ref
= staticmethod(native_bt
.component_source_get_ref
)
225 _put_ref
= staticmethod(native_bt
.component_source_put_ref
)
228 def output_ports(self
):
229 return _ComponentPorts(self
._ptr
,
230 native_bt
.component_source_borrow_output_port_by_name_const
,
231 native_bt
.component_source_borrow_output_port_by_index_const
,
232 native_bt
.component_source_get_output_port_count
,
233 bt2
.port
._OutputPort
)
236 # This is analogous to _GenericFilterComponentClass, but for filter
238 class _GenericFilterComponent(object._SharedObject
, _FilterComponent
):
239 _get_ref
= staticmethod(native_bt
.component_filter_get_ref
)
240 _put_ref
= staticmethod(native_bt
.component_filter_put_ref
)
243 def output_ports(self
):
244 return _ComponentPorts(self
._ptr
,
245 native_bt
.component_filter_borrow_output_port_by_name_const
,
246 native_bt
.component_filter_borrow_output_port_by_index_const
,
247 native_bt
.component_filter_get_output_port_count
,
248 bt2
.port
._OutputPort
)
251 def input_ports(self
):
252 return _ComponentPorts(self
._ptr
,
253 native_bt
.component_filter_borrow_input_port_by_name_const
,
254 native_bt
.component_filter_borrow_input_port_by_index_const
,
255 native_bt
.component_filter_get_input_port_count
,
259 # This is analogous to _GenericSinkComponentClass, but for sink
261 class _GenericSinkComponent(object._SharedObject
, _SinkComponent
):
262 _get_ref
= staticmethod(native_bt
.component_sink_get_ref
)
263 _put_ref
= staticmethod(native_bt
.component_sink_put_ref
)
266 def input_ports(self
):
267 return _ComponentPorts(self
._ptr
,
268 native_bt
.component_sink_borrow_input_port_by_name_const
,
269 native_bt
.component_sink_borrow_input_port_by_index_const
,
270 native_bt
.component_sink_get_input_port_count
,
274 _COMP_CLS_TYPE_TO_GENERIC_COMP_PYCLS
= {
275 native_bt
.COMPONENT_CLASS_TYPE_SOURCE
: _GenericSourceComponent
,
276 native_bt
.COMPONENT_CLASS_TYPE_FILTER
: _GenericFilterComponent
,
277 native_bt
.COMPONENT_CLASS_TYPE_SINK
: _GenericSinkComponent
,
281 _COMP_CLS_TYPE_TO_GENERIC_COMP_CLS_PYCLS
= {
282 native_bt
.COMPONENT_CLASS_TYPE_SOURCE
: _GenericSourceComponentClass
,
283 native_bt
.COMPONENT_CLASS_TYPE_FILTER
: _GenericFilterComponentClass
,
284 native_bt
.COMPONENT_CLASS_TYPE_SINK
: _GenericSinkComponentClass
,
288 # Create a component Python object of type _GenericSourceComponent,
289 # _GenericFilterComponent or _GenericSinkComponent, depending on
292 # Steals the reference to ptr from the caller.
294 def _create_component_from_ptr(ptr
, comp_cls_type
):
295 return _COMP_CLS_TYPE_TO_GENERIC_COMP_PYCLS
[comp_cls_type
]._create
_from
_ptr
(ptr
)
298 # Same as the above, but acquire a new reference instead of stealing the
299 # reference from the caller.
301 def _create_component_from_ptr_and_get_ref(ptr
, comp_cls_type
):
302 return _COMP_CLS_TYPE_TO_GENERIC_COMP_PYCLS
[comp_cls_type
]._create
_from
_ptr
_and
_get
_ref
(ptr
)
305 # Create a component class Python object of type
306 # _GenericSourceComponentClass, _GenericFilterComponentClass or
307 # _GenericSinkComponentClass, depending on comp_cls_type.
309 # Acquires a new reference to ptr.
311 def _create_component_class_from_ptr_and_get_ref(ptr
, comp_cls_type
):
312 return _COMP_CLS_TYPE_TO_GENERIC_COMP_CLS_PYCLS
[comp_cls_type
]._create
_from
_ptr
_and
_get
_ref
(ptr
)
315 def _trim_docstring(docstring
):
316 lines
= docstring
.expandtabs().splitlines()
319 for line
in lines
[1:]:
320 stripped
= line
.lstrip()
323 indent
= min(indent
, len(line
) - len(stripped
))
325 trimmed
= [lines
[0].strip()]
327 if indent
< sys
.maxsize
:
328 for line
in lines
[1:]:
329 trimmed
.append(line
[indent
:].rstrip())
331 while trimmed
and not trimmed
[-1]:
334 while trimmed
and not trimmed
[0]:
337 return '\n'.join(trimmed
)
340 # Metaclass for component classes defined by Python code.
342 # The Python user can create a standard Python class which inherits one
343 # of the three base classes (_UserSourceComponent, _UserFilterComponent,
344 # or _UserSinkComponent). Those base classes set this class
345 # (_UserComponentType) as their metaclass.
347 # Once the body of a user-defined component class is executed, this
348 # metaclass is used to create and initialize the class. The metaclass
349 # creates a native BT component class of the corresponding type and
350 # associates it with this user-defined class. The metaclass also defines
351 # class methods like the `name` and `description` properties to match
352 # the _GenericComponentClass interface.
354 # The component class name which is used is either:
356 # * The `name` parameter of the class:
358 # class MySink(bt2.SinkComponent, name='my-custom-sink'):
361 # * If the `name` class parameter is not used: the name of the class
362 # itself (`MySink` in the example above).
364 # The component class description which is used is the user-defined
367 # class MySink(bt2.SinkComponent):
368 # 'Description goes here'
371 # A user-defined Python component class can have an __init__() method
372 # which must at least accept the `params` and `name` arguments:
374 # def __init__(self, params, name, something_else):
377 # The user-defined component class can also have a _finalize() method
378 # (do NOT use __del__()) to be notified when the component object is
381 # User-defined source and filter component classes must use the
382 # `message_iterator_class` class parameter to specify the
383 # message iterator class to use for this component class:
385 # class MyMessageIterator(bt2._UserMessageIterator):
388 # class MySource(bt2._UserSourceComponent,
389 # message_iterator_class=MyMessageIterator):
392 # This message iterator class must inherit
393 # bt2._UserMessageIterator, and it must define the _get() and
394 # _next() methods. The message iterator class can also define an
395 # __init__() method: this method has access to the original Python
396 # component object which was used to create it as the `component`
397 # property. The message iterator class can also define a
398 # _finalize() method (again, do NOT use __del__()): this is called when
399 # the message iterator is (really) destroyed.
401 # When the user-defined class is destroyed, this metaclass's __del__()
402 # method is called: the native BT component class pointer is put (not
403 # needed anymore, at least not by any Python code since all references
404 # are dropped for __del__() to be called).
405 class _UserComponentType(type):
406 # __new__() is used to catch custom class parameters
407 def __new__(meta_cls
, class_name
, bases
, attrs
, **kwargs
):
408 return super().__new
__(meta_cls
, class_name
, bases
, attrs
)
410 def __init__(cls
, class_name
, bases
, namespace
, **kwargs
):
411 super().__init
__(class_name
, bases
, namespace
)
413 # skip our own bases; they are never directly instantiated by the user
416 '_UserFilterSinkComponent',
417 '_UserSourceComponent',
418 '_UserFilterComponent',
419 '_UserSinkComponent',
422 if class_name
in own_bases
:
425 comp_cls_name
= kwargs
.get('name', class_name
)
426 utils
._check
_str
(comp_cls_name
)
427 comp_cls_descr
= None
430 if hasattr(cls
, '__doc__') and cls
.__doc
__ is not None:
431 utils
._check
_str
(cls
.__doc
__)
432 docstring
= _trim_docstring(cls
.__doc
__)
433 lines
= docstring
.splitlines()
436 comp_cls_descr
= lines
[0]
439 comp_cls_help
= '\n'.join(lines
[2:])
441 iter_cls
= kwargs
.get('message_iterator_class')
443 if _UserSourceComponent
in bases
:
444 _UserComponentType
._set
_iterator
_class
(cls
, iter_cls
)
445 cc_ptr
= native_bt
.py3_component_class_source_create(cls
,
449 elif _UserFilterComponent
in bases
:
450 _UserComponentType
._set
_iterator
_class
(cls
, iter_cls
)
451 cc_ptr
= native_bt
.py3_component_class_filter_create(cls
,
455 elif _UserSinkComponent
in bases
:
456 if not hasattr(cls
, '_consume'):
457 raise bt2
.IncompleteUserClass("cannot create component class '{}': missing a _consume() method".format(class_name
))
459 cc_ptr
= native_bt
.py3_component_class_sink_create(cls
,
464 raise bt2
.IncompleteUserClass("cannot find a known component class base in the bases of '{}'".format(class_name
))
467 raise bt2
.CreationError("cannot create component class '{}'".format(class_name
))
471 def _init_from_native(cls
, comp_ptr
, params_ptr
):
472 # create instance, not user-initialized yet
473 self
= cls
.__new
__(cls
)
475 # pointer to native self component object (weak/borrowed)
478 # call user's __init__() method
479 if params_ptr
is not None:
480 params
= bt2
.value
._create
_from
_ptr
_and
_get
_ref
(params_ptr
)
484 self
.__init
__(params
)
487 def __call__(cls
, *args
, **kwargs
):
488 raise bt2
.Error('cannot directly instantiate a user component from a Python module')
491 def _set_iterator_class(cls
, iter_cls
):
493 raise bt2
.IncompleteUserClass("cannot create component class '{}': missing message iterator class".format(cls
.__name
__))
495 if not issubclass(iter_cls
, bt2
.message_iterator
._UserMessageIterator
):
496 raise bt2
.IncompleteUserClass("cannot create component class '{}': message iterator class does not inherit bt2._UserMessageIterator".format(cls
.__name
__))
498 if not hasattr(iter_cls
, '__next__'):
499 raise bt2
.IncompleteUserClass("cannot create component class '{}': message iterator class is missing a __next__() method".format(cls
.__name
__))
501 cls
._iter
_cls
= iter_cls
505 ptr
= cls
._as
_component
_class
_ptr
(cls
._cc
_ptr
)
506 return native_bt
.component_class_get_name(ptr
)
509 def description(cls
):
510 ptr
= cls
._as
_component
_class
_ptr
(cls
._cc
_ptr
)
511 return native_bt
.component_class_get_description(ptr
)
515 ptr
= cls
._as
_component
_class
_ptr
(cls
._cc
_ptr
)
516 return native_bt
.component_class_get_help(ptr
)
520 return int(cls
._cc
_ptr
)
522 def _query_from_native(cls
, query_exec_ptr
, obj
, params_ptr
):
523 # this can raise, in which case the native call to
524 # bt_component_class_query() returns NULL
525 if params_ptr
is not None:
526 params
= bt2
.value
._create
_from
_ptr
_and
_get
_ref
(params_ptr
)
530 query_exec
= bt2
.QueryExecutor
._create
_from
_ptr
_and
_get
_ref
(
533 # this can raise, but the native side checks the exception
534 results
= cls
._query
(query_exec
, obj
, params
)
536 # this can raise, but the native side checks the exception
537 results
= bt2
.create_value(results
)
540 results_addr
= int(native_bt
.value_null
)
542 # return new reference
543 results_addr
= int(results
._release
())
547 def _query(cls
, query_executor
, obj
, params
):
548 raise NotImplementedError
550 def _component_class_ptr(self
):
551 return self
._as
_component
_class
_ptr
(self
._cc
_ptr
)
554 if hasattr(cls
, '_cc_ptr'):
555 cc_ptr
= cls
._as
_component
_class
_ptr
(cls
._cc
_ptr
)
556 native_bt
.component_class_put_ref(cc_ptr
)
558 # Subclasses must provide these methods or property:
560 # - _as_not_self_specific_component_ptr: static method, must return the passed
561 # specialized self component pointer (e.g. 'bt_self_component_sink *') as a
562 # specialized non-self pointer (e.g. 'bt_component_sink *').
563 # - _borrow_component_class_ptr: static method, must return a pointer to the
564 # specialized component class (e.g. 'bt_component_class_sink *') of the
565 # passed specialized component pointer (e.g. 'bt_component_sink *').
566 # - _comp_cls_type: property, one of the native_bt.COMPONENT_CLASS_TYPE_*
569 class _UserComponent(metaclass
=_UserComponentType
):
572 ptr
= self
._as
_not
_self
_specific
_component
_ptr
(self
._ptr
)
573 ptr
= self
._as
_component
_ptr
(ptr
)
574 name
= native_bt
.component_get_name(ptr
)
575 assert name
is not None
579 def component_class(self
):
580 comp_ptr
= self
._as
_not
_self
_specific
_component
_ptr
(self
._ptr
)
581 cc_ptr
= self
._borrow
_component
_class
_ptr
(comp_ptr
)
582 return _create_component_class_from_ptr_and_get_ref(cc_ptr
, self
._comp
_cls
_type
)
586 return int(self
._ptr
)
588 def __init__(self
, params
=None):
594 def _accept_port_connection(self
, port
, other_port
):
597 def _accept_port_connection_from_native(self
, self_port_ptr
, self_port_type
, other_port_ptr
):
598 port
= bt2
.port
._create
_self
_from
_ptr
_and
_get
_ref
(
599 self_port_ptr
, self_port_type
)
601 if self_port_type
== native_bt
.PORT_TYPE_OUTPUT
:
602 other_port_type
= native_bt
.PORT_TYPE_INPUT
604 other_port_type
= native_bt
.PORT_TYPE_OUTPUT
606 other_port
= bt2
.port
._create
_from
_ptr
_and
_get
_ref
(
607 other_port_ptr
, other_port_type
)
608 res
= self
._accept
_port
_connection
(port
, other_port_ptr
)
610 if type(res
) is not bool:
611 raise TypeError("'{}' is not a 'bool' object")
615 def _port_connected(self
, port
, other_port
):
618 def _port_connected_from_native(self
, self_port_ptr
, self_port_type
, other_port_ptr
):
619 port
= bt2
.port
._create
_self
_from
_ptr
_and
_get
_ref
(
620 self_port_ptr
, self_port_type
)
622 if self_port_type
== native_bt
.PORT_TYPE_OUTPUT
:
623 other_port_type
= native_bt
.PORT_TYPE_INPUT
625 other_port_type
= native_bt
.PORT_TYPE_OUTPUT
627 other_port
= bt2
.port
._create
_from
_ptr
_and
_get
_ref
(
628 other_port_ptr
, other_port_type
)
629 self
._port
_connected
(port
, other_port
)
631 def _graph_is_configured_from_native(self
):
632 self
._graph
_is
_configured
()
634 def _create_trace_class(self
, env
=None, uuid
=None,
635 assigns_automatic_stream_class_id
=True):
636 ptr
= self
._as
_self
_component
_ptr
(self
._ptr
)
637 tc_ptr
= native_bt
.trace_class_create(ptr
)
640 raise bt2
.CreationError('could not create trace class')
642 tc
= bt2
.TraceClass
._create
_from
_ptr
(tc_ptr
)
645 for key
, value
in env
.items():
651 tc
._assigns
_automatic
_stream
_class
_id
= assigns_automatic_stream_class_id
655 def _create_clock_class(self
, frequency
=None, name
=None, description
=None,
656 precision
=None, offset
=None, origin_is_unix_epoch
=True,
658 ptr
= self
._as
_self
_component
_ptr
(self
._ptr
)
659 cc_ptr
= native_bt
.clock_class_create(ptr
)
662 raise bt2
.CreationError('could not create clock class')
664 cc
= bt2
.clock_class
._ClockClass
._create
_from
_ptr
(cc_ptr
)
666 if frequency
is not None:
667 cc
._frequency
= frequency
672 if description
is not None:
673 cc
._description
= description
675 if precision
is not None:
676 cc
._precision
= precision
678 if offset
is not None:
681 cc
._origin
_is
_unix
_epoch
= origin_is_unix_epoch
689 class _UserSourceComponent(_UserComponent
, _SourceComponent
):
690 _as_not_self_specific_component_ptr
= staticmethod(native_bt
.self_component_source_as_component_source
)
691 _as_self_component_ptr
= staticmethod(native_bt
.self_component_source_as_self_component
)
694 def _output_ports(self
):
695 def get_output_port_count(self_ptr
):
696 ptr
= self
._as
_not
_self
_specific
_component
_ptr
(self_ptr
)
697 return native_bt
.component_source_get_output_port_count(ptr
)
699 return _ComponentPorts(self
._ptr
,
700 native_bt
.self_component_source_borrow_output_port_by_name
,
701 native_bt
.self_component_source_borrow_output_port_by_index
,
702 get_output_port_count
,
703 bt2
.port
._UserComponentOutputPort
)
705 def _add_output_port(self
, name
):
706 utils
._check
_str
(name
)
707 fn
= native_bt
.self_component_source_add_output_port
708 comp_status
, self_port_ptr
= fn(self
._ptr
, name
, None)
709 _handle_component_status(comp_status
,
710 'cannot add output port to source component object')
711 assert self_port_ptr
is not None
712 return bt2
.port
._UserComponentOutputPort
._create
_from
_ptr
(self_port_ptr
)
715 class _UserFilterComponent(_UserComponent
, _FilterComponent
):
716 _as_not_self_specific_component_ptr
= staticmethod(native_bt
.self_component_filter_as_component_filter
)
717 _as_self_component_ptr
= staticmethod(native_bt
.self_component_filter_as_self_component
)
720 def _output_ports(self
):
721 def get_output_port_count(self_ptr
):
722 ptr
= self
._as
_not
_self
_specific
_component
_ptr
(self_ptr
)
723 return native_bt
.component_filter_get_output_port_count(ptr
)
725 return _ComponentPorts(self
._ptr
,
726 native_bt
.self_component_filter_borrow_output_port_by_name
,
727 native_bt
.self_component_filter_borrow_output_port_by_index
,
728 get_output_port_count
,
729 bt2
.port
._UserComponentOutputPort
)
732 def _input_ports(self
):
733 def get_input_port_count(self_ptr
):
734 ptr
= self
._as
_not
_self
_specific
_component
_ptr
(self_ptr
)
735 return native_bt
.component_filter_get_input_port_count(ptr
)
737 return _ComponentPorts(self
._ptr
,
738 native_bt
.self_component_filter_borrow_input_port_by_name
,
739 native_bt
.self_component_filter_borrow_input_port_by_index
,
740 get_input_port_count
,
741 bt2
.port
._UserComponentInputPort
)
743 def _add_output_port(self
, name
):
744 utils
._check
_str
(name
)
745 fn
= native_bt
.self_component_filter_add_output_port
746 comp_status
, self_port_ptr
= fn(self
._ptr
, name
, None)
747 _handle_component_status(comp_status
,
748 'cannot add output port to filter component object')
750 return bt2
.port
._UserComponentOutputPort
._create
_from
_ptr
(self_port_ptr
)
752 def _add_input_port(self
, name
):
753 utils
._check
_str
(name
)
754 fn
= native_bt
.self_component_filter_add_input_port
755 comp_status
, self_port_ptr
= fn(self
._ptr
, name
, None)
756 _handle_component_status(comp_status
,
757 'cannot add input port to filter component object')
759 return bt2
.port
._UserComponentInputPort
._create
_from
_ptr
(self_port_ptr
)
762 class _UserSinkComponent(_UserComponent
, _SinkComponent
):
763 _as_not_self_specific_component_ptr
= staticmethod(native_bt
.self_component_sink_as_component_sink
)
764 _as_self_component_ptr
= staticmethod(native_bt
.self_component_sink_as_self_component
)
767 def _input_ports(self
):
768 def get_input_port_count(self_ptr
):
769 ptr
= self
._as
_not
_self
_specific
_component
_ptr
(self_ptr
)
770 return native_bt
.component_sink_get_input_port_count(ptr
)
772 return _ComponentPorts(self
._ptr
,
773 native_bt
.self_component_sink_borrow_input_port_by_name
,
774 native_bt
.self_component_sink_borrow_input_port_by_index
,
775 get_input_port_count
,
776 bt2
.port
._UserComponentInputPort
)
778 def _add_input_port(self
, name
):
779 utils
._check
_str
(name
)
780 fn
= native_bt
.self_component_sink_add_input_port
781 comp_status
, self_port_ptr
= fn(self
._ptr
, name
, None)
782 _handle_component_status(comp_status
,
783 'cannot add input port to sink component object')
785 return bt2
.port
._UserComponentInputPort
._create
_from
_ptr
(self_port_ptr
)