bccc18257109766e2dbd70c26305fa832cdbdd38
[babeltrace.git] / src / bindings / python / bt2 / bt2 / native_bt_graph.i.h
1 /*
2 * The MIT License (MIT)
3 *
4 * Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 static
26 void graph_listener_removed(void *py_callable)
27 {
28 BT_ASSERT(py_callable);
29 Py_DECREF(py_callable);
30 }
31
32 static bt_graph_listener_func_status port_added_listener(
33 const void *component,
34 swig_type_info *component_swig_type,
35 bt_component_class_type component_class_type,
36 const void *port,
37 swig_type_info *port_swig_type,
38 bt_port_type port_type,
39 void *py_callable)
40 {
41 PyObject *py_component_ptr = NULL;
42 PyObject *py_port_ptr = NULL;
43 PyObject *py_res = NULL;
44 bt_graph_listener_func_status status;
45
46 py_component_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(component), component_swig_type, 0);
47 if (!py_component_ptr) {
48 BT_LOGF_STR("Failed to create component SWIG pointer object.");
49 status = __BT_FUNC_STATUS_MEMORY_ERROR;
50 goto end;
51 }
52
53 py_port_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(port), port_swig_type, 0);
54 if (!py_port_ptr) {
55 BT_LOGF_STR("Failed to create port SWIG pointer object.");
56 status = __BT_FUNC_STATUS_MEMORY_ERROR;
57 goto end;
58 }
59
60 py_res = PyObject_CallFunction(py_callable, "(OiOi)",
61 py_component_ptr, component_class_type, py_port_ptr, port_type);
62 if (!py_res) {
63 loge_exception("Graph's port added listener (Python)",
64 BT_LOG_OUTPUT_LEVEL);
65 PyErr_Clear();
66 status = __BT_FUNC_STATUS_ERROR;
67 goto end;
68 }
69
70 BT_ASSERT(py_res == Py_None);
71 status = __BT_FUNC_STATUS_OK;
72
73 end:
74 Py_XDECREF(py_res);
75 Py_XDECREF(py_port_ptr);
76 Py_XDECREF(py_component_ptr);
77 return status;
78 }
79
80 static
81 bt_graph_listener_func_status
82 source_component_output_port_added_listener(const bt_component_source *component_source,
83 const bt_port_output *port_output, void *py_callable)
84 {
85 return port_added_listener(
86 component_source, SWIGTYPE_p_bt_component_source, BT_COMPONENT_CLASS_TYPE_SOURCE,
87 port_output, SWIGTYPE_p_bt_port_output, BT_PORT_TYPE_OUTPUT, py_callable);
88 }
89
90 static
91 bt_graph_listener_func_status
92 filter_component_input_port_added_listener(const bt_component_filter *component_filter,
93 const bt_port_input *port_input, void *py_callable)
94 {
95 return port_added_listener(
96 component_filter, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
97 port_input, SWIGTYPE_p_bt_port_input, BT_PORT_TYPE_INPUT, py_callable);
98 }
99
100 static
101 bt_graph_listener_func_status
102 filter_component_output_port_added_listener(const bt_component_filter *component_filter,
103 const bt_port_output *port_output, void *py_callable)
104 {
105 return port_added_listener(
106 component_filter, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
107 port_output, SWIGTYPE_p_bt_port_output, BT_PORT_TYPE_OUTPUT, py_callable);
108 }
109
110 static
111 bt_graph_listener_func_status
112 sink_component_input_port_added_listener(const bt_component_sink *component_sink,
113 const bt_port_input *port_input, void *py_callable)
114 {
115 return port_added_listener(
116 component_sink, SWIGTYPE_p_bt_component_sink, BT_COMPONENT_CLASS_TYPE_SINK,
117 port_input, SWIGTYPE_p_bt_port_input, BT_PORT_TYPE_INPUT, py_callable);
118 }
119
120 static
121 PyObject *bt_bt2_graph_add_port_added_listener(struct bt_graph *graph,
122 PyObject *py_callable)
123 {
124 PyObject *py_listener_ids = NULL;
125 PyObject *py_listener_id = NULL;
126 bt_listener_id listener_id;
127 bt_graph_add_listener_status status;
128 const char * const module_name =
129 "graph_add_port_added_listener() (Python)";
130
131 BT_ASSERT(graph);
132 BT_ASSERT(py_callable);
133
134 /*
135 * Behind the scene, we will be registering 4 different listeners and
136 * return all of their ids.
137 */
138 py_listener_ids = PyTuple_New(4);
139 if (!py_listener_ids) {
140 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
141 "Failed to allocate one PyTuple.");
142 goto error;
143 }
144
145 /* source output port */
146 status = bt_graph_add_source_component_output_port_added_listener(
147 graph, source_component_output_port_added_listener,
148 graph_listener_removed, py_callable, &listener_id);
149 if (status != __BT_FUNC_STATUS_OK) {
150 /*
151 * bt_graph_add_source_component_output_port_added_listener has
152 * already logged/appended an error cause.
153 */
154 goto error;
155 }
156
157 py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
158 if (!py_listener_id) {
159 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
160 "Failed to allocate one PyLong.");
161 goto error;
162 }
163
164 PyTuple_SET_ITEM(py_listener_ids, 0, py_listener_id);
165 py_listener_id = NULL;
166
167 /* filter input port */
168 status = bt_graph_add_filter_component_input_port_added_listener(
169 graph, filter_component_input_port_added_listener,
170 graph_listener_removed, py_callable, &listener_id);
171 if (status != __BT_FUNC_STATUS_OK) {
172 /*
173 * bt_graph_add_filter_component_input_port_added_listener has
174 * already logged/appended an error cause.
175 */
176 goto error;
177 }
178
179 py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
180 if (!py_listener_id) {
181 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
182 "Failed to allocate one PyLong.");
183 goto error;
184 }
185
186 PyTuple_SET_ITEM(py_listener_ids, 1, py_listener_id);
187 py_listener_id = NULL;
188
189 /* filter output port */
190 status = bt_graph_add_filter_component_output_port_added_listener(
191 graph, filter_component_output_port_added_listener,
192 graph_listener_removed, py_callable, &listener_id);
193 if (status != __BT_FUNC_STATUS_OK) {
194 /*
195 * bt_graph_add_filter_component_output_port_added_listener has
196 * already logged/appended an error cause.
197 */
198 goto error;
199 }
200
201 py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
202 if (!py_listener_id) {
203 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
204 "Failed to allocate one PyLong.");
205 goto error;
206 }
207
208 PyTuple_SET_ITEM(py_listener_ids, 2, py_listener_id);
209 py_listener_id = NULL;
210
211 /* sink input port */
212 status = bt_graph_add_sink_component_input_port_added_listener(
213 graph, sink_component_input_port_added_listener,
214 graph_listener_removed, py_callable, &listener_id);
215 if (status != __BT_FUNC_STATUS_OK) {
216 /*
217 * bt_graph_add_sink_component_input_port_added_listener has
218 * already logged/appended an error cause.
219 */
220 goto error;
221 }
222
223 py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
224 if (!py_listener_id) {
225 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
226 "Failed to allocate one PyLong.");
227 goto error;
228 }
229
230
231 PyTuple_SET_ITEM(py_listener_ids, 3, py_listener_id);
232 py_listener_id = NULL;
233
234 Py_INCREF(py_callable);
235 Py_INCREF(py_callable);
236 Py_INCREF(py_callable);
237 Py_INCREF(py_callable);
238
239 goto end;
240
241 error:
242 Py_XDECREF(py_listener_ids);
243 py_listener_ids = Py_None;
244 Py_INCREF(py_listener_ids);
245
246 end:
247
248 Py_XDECREF(py_listener_id);
249 return py_listener_ids;
250 }
251
252 static
253 bt_graph_listener_func_status ports_connected_listener(
254 const void *upstream_component,
255 swig_type_info *upstream_component_swig_type,
256 bt_component_class_type upstream_component_class_type,
257 const bt_port_output *upstream_port,
258 const void *downstream_component,
259 swig_type_info *downstream_component_swig_type,
260 bt_component_class_type downstream_component_class_type,
261 const bt_port_input *downstream_port,
262 void *py_callable)
263 {
264 PyObject *py_upstream_component_ptr = NULL;
265 PyObject *py_upstream_port_ptr = NULL;
266 PyObject *py_downstream_component_ptr = NULL;
267 PyObject *py_downstream_port_ptr = NULL;
268 PyObject *py_res = NULL;
269 bt_graph_listener_func_status status;
270
271 py_upstream_component_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(upstream_component),
272 upstream_component_swig_type, 0);
273 if (!py_upstream_component_ptr) {
274 BT_LOGF_STR("Failed to create upstream component SWIG pointer object.");
275 status = __BT_FUNC_STATUS_MEMORY_ERROR;
276 goto end;
277 }
278
279 py_upstream_port_ptr = SWIG_NewPointerObj(
280 SWIG_as_voidptr(upstream_port), SWIGTYPE_p_bt_port_output, 0);
281 if (!py_upstream_port_ptr) {
282 BT_LOGF_STR("Failed to create upstream port SWIG pointer object.");
283 status = __BT_FUNC_STATUS_MEMORY_ERROR;
284 goto end;
285 }
286
287 py_downstream_component_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(downstream_component),
288 downstream_component_swig_type, 0);
289 if (!py_downstream_component_ptr) {
290 BT_LOGF_STR("Failed to create downstream component SWIG pointer object.");
291 status = __BT_FUNC_STATUS_MEMORY_ERROR;
292 goto end;
293 }
294
295 py_downstream_port_ptr = SWIG_NewPointerObj(
296 SWIG_as_voidptr(downstream_port), SWIGTYPE_p_bt_port_input, 0);
297 if (!py_downstream_port_ptr) {
298 BT_LOGF_STR("Failed to create downstream port SWIG pointer object.");
299 status = __BT_FUNC_STATUS_MEMORY_ERROR;
300 goto end;
301 }
302
303 py_res = PyObject_CallFunction(py_callable, "(OiOOiO)",
304 py_upstream_component_ptr, upstream_component_class_type,
305 py_upstream_port_ptr,
306 py_downstream_component_ptr, downstream_component_class_type,
307 py_downstream_port_ptr);
308 if (!py_res) {
309 loge_exception("Graph's port connected listener (Python)",
310 BT_LOG_OUTPUT_LEVEL);
311 PyErr_Clear();
312 status = __BT_FUNC_STATUS_ERROR;
313 goto end;
314 }
315
316 BT_ASSERT(py_res == Py_None);
317 status = __BT_FUNC_STATUS_OK;
318
319 end:
320 Py_XDECREF(py_upstream_component_ptr);
321 Py_XDECREF(py_upstream_port_ptr);
322 Py_XDECREF(py_downstream_component_ptr);
323 Py_XDECREF(py_downstream_port_ptr);
324 Py_XDECREF(py_res);
325 return status;
326 }
327
328 static
329 bt_graph_listener_func_status source_filter_component_ports_connected_listener(
330 const bt_component_source *source_component,
331 const bt_component_filter *filter_component,
332 const bt_port_output *upstream_port,
333 const bt_port_input *downstream_port, void *py_callable)
334 {
335 return ports_connected_listener(
336 source_component, SWIGTYPE_p_bt_component_source, BT_COMPONENT_CLASS_TYPE_SOURCE,
337 upstream_port,
338 filter_component, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
339 downstream_port,
340 py_callable);
341 }
342
343 static
344 bt_graph_listener_func_status source_sink_component_ports_connected_listener(
345 const bt_component_source *source_component,
346 const bt_component_sink *sink_component,
347 const bt_port_output *upstream_port,
348 const bt_port_input *downstream_port, void *py_callable)
349 {
350 return ports_connected_listener(
351 source_component, SWIGTYPE_p_bt_component_source, BT_COMPONENT_CLASS_TYPE_SOURCE,
352 upstream_port,
353 sink_component, SWIGTYPE_p_bt_component_sink, BT_COMPONENT_CLASS_TYPE_SINK,
354 downstream_port,
355 py_callable);
356 }
357
358 static
359 bt_graph_listener_func_status filter_filter_component_ports_connected_listener(
360 const bt_component_filter *filter_component_left,
361 const bt_component_filter *filter_component_right,
362 const bt_port_output *upstream_port,
363 const bt_port_input *downstream_port, void *py_callable)
364 {
365 return ports_connected_listener(
366 filter_component_left, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
367 upstream_port,
368 filter_component_right, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
369 downstream_port,
370 py_callable);
371 }
372
373 static
374 bt_graph_listener_func_status filter_sink_component_ports_connected_listener(
375 const bt_component_filter *filter_component,
376 const bt_component_sink *sink_component,
377 const bt_port_output *upstream_port,
378 const bt_port_input *downstream_port, void *py_callable)
379 {
380 return ports_connected_listener(
381 filter_component, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
382 upstream_port,
383 sink_component, SWIGTYPE_p_bt_component_sink, BT_COMPONENT_CLASS_TYPE_SINK,
384 downstream_port,
385 py_callable);
386 }
387
388 static
389 PyObject *bt_bt2_graph_add_ports_connected_listener(struct bt_graph *graph,
390 PyObject *py_callable)
391 {
392 PyObject *py_listener_ids = NULL;
393 PyObject *py_listener_id = NULL;
394 bt_listener_id listener_id;
395 bt_graph_add_listener_status status;
396 const char * const module_name =
397 "graph_add_ports_connected_listener() (Python)";
398
399 BT_ASSERT(graph);
400 BT_ASSERT(py_callable);
401
402 /* Behind the scene, we will be registering 4 different listeners and
403 * return all of their ids. */
404 py_listener_ids = PyTuple_New(4);
405 if (!py_listener_ids) {
406 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
407 "Failed to allocate one PyTuple.");
408 goto error;
409 }
410
411 /* source -> filter connection */
412 status = bt_graph_add_source_filter_component_ports_connected_listener(
413 graph, source_filter_component_ports_connected_listener,
414 graph_listener_removed, py_callable, &listener_id);
415 if (status != __BT_FUNC_STATUS_OK) {
416 /*
417 * bt_graph_add_source_filter_component_ports_connected_listener
418 * has already logged/appended an error cause.
419 */
420 goto error;
421 }
422
423 py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
424 if (!py_listener_id) {
425 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
426 "Failed to allocate one PyLong.");
427 goto error;
428 }
429
430 PyTuple_SET_ITEM(py_listener_ids, 0, py_listener_id);
431 py_listener_id = NULL;
432
433 /* source -> sink connection */
434 status = bt_graph_add_source_sink_component_ports_connected_listener(
435 graph, source_sink_component_ports_connected_listener,
436 graph_listener_removed, py_callable, &listener_id);
437 if (status != __BT_FUNC_STATUS_OK) {
438 /*
439 * bt_graph_add_source_sink_component_ports_connected_listener
440 * has already logged/appended an error cause.
441 */
442 goto error;
443 }
444
445 py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
446 if (!py_listener_id) {
447 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
448 "Failed to allocate one PyLong.");
449 goto error;
450 }
451
452 PyTuple_SET_ITEM(py_listener_ids, 1, py_listener_id);
453 py_listener_id = NULL;
454
455 /* filter -> filter connection */
456 status = bt_graph_add_filter_filter_component_ports_connected_listener(
457 graph, filter_filter_component_ports_connected_listener,
458 graph_listener_removed, py_callable, &listener_id);
459 if (status != __BT_FUNC_STATUS_OK) {
460 /*
461 * bt_graph_add_filter_filter_component_ports_connected_listener
462 * has already logged/appended an error cause.
463 */
464 goto error;
465 }
466
467 py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
468 if (!py_listener_id) {
469 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
470 "Failed to allocate one PyLong.");
471 goto error;
472 }
473
474 PyTuple_SET_ITEM(py_listener_ids, 2, py_listener_id);
475 py_listener_id = NULL;
476
477 /* filter -> sink connection */
478 status = bt_graph_add_filter_sink_component_ports_connected_listener(
479 graph, filter_sink_component_ports_connected_listener,
480 graph_listener_removed, py_callable, &listener_id);
481 if (status != __BT_FUNC_STATUS_OK) {
482 /*
483 * bt_graph_add_filter_sink_component_ports_connected_listener
484 * has already logged/appended an error cause.
485 */
486 goto error;
487 }
488
489 py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
490 if (!py_listener_id) {
491 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
492 "Failed to allocate one PyLong.");
493 goto error;
494 }
495
496 PyTuple_SET_ITEM(py_listener_ids, 3, py_listener_id);
497 py_listener_id = NULL;
498
499 Py_INCREF(py_callable);
500 Py_INCREF(py_callable);
501 Py_INCREF(py_callable);
502 Py_INCREF(py_callable);
503
504 goto end;
505
506 error:
507 Py_XDECREF(py_listener_ids);
508 py_listener_ids = Py_None;
509 Py_INCREF(py_listener_ids);
510
511 end:
512
513 Py_XDECREF(py_listener_id);
514 return py_listener_ids;
515 }
This page took 0.04026 seconds and 3 git commands to generate.