[babeltrace.git] / src / bindings / python / bt2 / bt2 / native_bt_graph.i.h

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
 */

static bt_graph_listener_func_status port_added_listener(
	const void *component,
	swig_type_info *component_swig_type,
	bt_component_class_type component_class_type,
	const void *port,
	swig_type_info *port_swig_type,
	bt_port_type port_type,
	void *py_callable)
{
	PyObject *py_component_ptr = NULL;
	PyObject *py_port_ptr = NULL;
	PyObject *py_res = NULL;
	bt_graph_listener_func_status status;

	py_component_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(component), component_swig_type, 0);
	if (!py_component_ptr) {
		BT_LOGF_STR("Failed to create component SWIG pointer object.");
		status = __BT_FUNC_STATUS_MEMORY_ERROR;
		goto end;
	}

	py_port_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(port), port_swig_type, 0);
	if (!py_port_ptr) {
		BT_LOGF_STR("Failed to create port SWIG pointer object.");
		status = __BT_FUNC_STATUS_MEMORY_ERROR;
		goto end;
	}

	py_res = PyObject_CallFunction(py_callable, "(OiOi)",
		py_component_ptr, component_class_type, py_port_ptr, port_type);
	if (!py_res) {
		loge_exception_append_cause_clear(
			"Graph's port added listener (Python)",
			BT_LOG_OUTPUT_LEVEL);
		status = __BT_FUNC_STATUS_ERROR;
		goto end;
	}

	BT_ASSERT(py_res == Py_None);
	status = __BT_FUNC_STATUS_OK;

end:
	Py_XDECREF(py_res);
	Py_XDECREF(py_port_ptr);
	Py_XDECREF(py_component_ptr);
	return status;
}

static
bt_graph_listener_func_status
source_component_output_port_added_listener(const bt_component_source *component_source,
					    const bt_port_output *port_output, void *py_callable)
{
	return port_added_listener(
		component_source, SWIGTYPE_p_bt_component_source, BT_COMPONENT_CLASS_TYPE_SOURCE,
		port_output, SWIGTYPE_p_bt_port_output, BT_PORT_TYPE_OUTPUT, py_callable);
}

static
bt_graph_listener_func_status
filter_component_input_port_added_listener(const bt_component_filter *component_filter,
					   const bt_port_input *port_input, void *py_callable)
{
	return port_added_listener(
		component_filter, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
		port_input, SWIGTYPE_p_bt_port_input, BT_PORT_TYPE_INPUT, py_callable);
}

static
bt_graph_listener_func_status
filter_component_output_port_added_listener(const bt_component_filter *component_filter,
					    const bt_port_output *port_output, void *py_callable)
{
	return port_added_listener(
		component_filter, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
		port_output, SWIGTYPE_p_bt_port_output, BT_PORT_TYPE_OUTPUT, py_callable);
}

static
bt_graph_listener_func_status
sink_component_input_port_added_listener(const bt_component_sink *component_sink,
					 const bt_port_input *port_input, void *py_callable)
{
	return port_added_listener(
		component_sink, SWIGTYPE_p_bt_component_sink, BT_COMPONENT_CLASS_TYPE_SINK,
		port_input, SWIGTYPE_p_bt_port_input, BT_PORT_TYPE_INPUT, py_callable);
}

static
PyObject *bt_bt2_graph_add_port_added_listener(struct bt_graph *graph,
		PyObject *py_callable)
{
	PyObject *py_listener_ids = NULL;
	PyObject *py_listener_id = NULL;
	bt_listener_id listener_id;
	bt_graph_add_listener_status status;
	const char * const module_name =
		"graph_add_port_added_listener() (Python)";

	BT_ASSERT(graph);
	BT_ASSERT(py_callable);

	/*
	 * Behind the scene, we will be registering 4 different listeners and
	 * return all of their ids.
	 */
	py_listener_ids = PyTuple_New(4);
	if (!py_listener_ids) {
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
			"Failed to allocate one PyTuple.");
		goto error;
	}

	/* source output port */
	status = bt_graph_add_source_component_output_port_added_listener(
		graph, source_component_output_port_added_listener,
		py_callable, &listener_id);
	if (status != __BT_FUNC_STATUS_OK) {
		/*
		 * bt_graph_add_source_component_output_port_added_listener has
		 * already logged/appended an error cause.
		 */
		goto error;
	}

	py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
	if (!py_listener_id) {
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
			"Failed to allocate one PyLong.");
		goto error;
	}

	PyTuple_SET_ITEM(py_listener_ids, 0, py_listener_id);
	py_listener_id = NULL;

	/* filter input port */
	status = bt_graph_add_filter_component_input_port_added_listener(
		graph, filter_component_input_port_added_listener,
		py_callable, &listener_id);
	if (status != __BT_FUNC_STATUS_OK) {
		/*
		 * bt_graph_add_filter_component_input_port_added_listener has
		 * already logged/appended an error cause.
		 */
		goto error;
	}

	py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
	if (!py_listener_id) {
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
			"Failed to allocate one PyLong.");
		goto error;
	}

	PyTuple_SET_ITEM(py_listener_ids, 1, py_listener_id);
	py_listener_id = NULL;

	/* filter output port */
	status = bt_graph_add_filter_component_output_port_added_listener(
		graph, filter_component_output_port_added_listener,
		py_callable, &listener_id);
	if (status != __BT_FUNC_STATUS_OK) {
		/*
		 * bt_graph_add_filter_component_output_port_added_listener has
		 * already logged/appended an error cause.
		 */
		goto error;
	}

	py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
	if (!py_listener_id) {
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
			"Failed to allocate one PyLong.");
		goto error;
	}

	PyTuple_SET_ITEM(py_listener_ids, 2, py_listener_id);
	py_listener_id = NULL;

	/* sink input port */
	status = bt_graph_add_sink_component_input_port_added_listener(
		graph, sink_component_input_port_added_listener,
		py_callable, &listener_id);
	if (status != __BT_FUNC_STATUS_OK) {
		/*
		 * bt_graph_add_sink_component_input_port_added_listener has
		 * already logged/appended an error cause.
		 */
		goto error;
	}

	py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
	if (!py_listener_id) {
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
			"Failed to allocate one PyLong.");
		goto error;
	}

	PyTuple_SET_ITEM(py_listener_ids, 3, py_listener_id);
	py_listener_id = NULL;
	goto end;

error:
	Py_XDECREF(py_listener_ids);
	py_listener_ids = Py_None;
	Py_INCREF(py_listener_ids);

end:
	Py_XDECREF(py_listener_id);
	return py_listener_ids;
}

static
bt_graph_add_component_status
bt_bt2_graph_add_source_component(
		bt_graph *graph,
		const bt_component_class_source *component_class,
		const char *name, const bt_value *params,
		PyObject *obj, bt_logging_level log_level,
		const bt_component_source **component)
{
	return bt_graph_add_source_component_with_initialize_method_data(graph,
		component_class, name, params, obj == Py_None ? NULL : obj,
		log_level, component);
}

static
bt_graph_add_component_status
bt_bt2_graph_add_filter_component(
		bt_graph *graph,
		const bt_component_class_filter *component_class,
		const char *name, const bt_value *params,
		PyObject *obj, bt_logging_level log_level,
		const bt_component_filter **component)
{
	return bt_graph_add_filter_component_with_initialize_method_data(graph,
		component_class, name, params, obj == Py_None ? NULL : obj,
		log_level, component);
}

static
bt_graph_add_component_status
bt_bt2_graph_add_sink_component(
		bt_graph *graph,
		const bt_component_class_sink *component_class,
		const char *name, const bt_value *params,
		PyObject *obj, bt_logging_level log_level,
		const bt_component_sink **component)
{
	return bt_graph_add_sink_component_with_initialize_method_data(graph,
		component_class, name, params, obj == Py_None ? NULL : obj,
		log_level, component);
}
Commit	Line	Data
4212232c	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
4212232c PP	3	*
4212232c PP	4	* Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
4212232c PP	5	*/
4212232c PP	6
4212232c PP	7	static bt_graph_listener_func_status port_added_listener(
	8	const void *component,
	9	swig_type_info *component_swig_type,
	10	bt_component_class_type component_class_type,
	11	const void *port,
	12	swig_type_info *port_swig_type,
	13	bt_port_type port_type,
	14	void *py_callable)
	15	{
	16	PyObject *py_component_ptr = NULL;
	17	PyObject *py_port_ptr = NULL;
	18	PyObject *py_res = NULL;
	19	bt_graph_listener_func_status status;
	20
	21	py_component_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(component), component_swig_type, 0);
	22	if (!py_component_ptr) {
	23	BT_LOGF_STR("Failed to create component SWIG pointer object.");
	24	status = __BT_FUNC_STATUS_MEMORY_ERROR;
	25	goto end;
	26	}
	27
	28	py_port_ptr = SWIG_NewPointerObj(SWIG_as_voidptr(port), port_swig_type, 0);
	29	if (!py_port_ptr) {
	30	BT_LOGF_STR("Failed to create port SWIG pointer object.");
	31	status = __BT_FUNC_STATUS_MEMORY_ERROR;
	32	goto end;
	33	}
	34
	35	py_res = PyObject_CallFunction(py_callable, "(OiOi)",
	36	py_component_ptr, component_class_type, py_port_ptr, port_type);
	37	if (!py_res) {
981f33dd	38	loge_exception_append_cause_clear(
84e438af	39	"Graph's port added listener (Python)",
4212232c	40	BT_LOG_OUTPUT_LEVEL);
4212232c PP	41	status = __BT_FUNC_STATUS_ERROR;
	42	goto end;
	43	}
	44
	45	BT_ASSERT(py_res == Py_None);
	46	status = __BT_FUNC_STATUS_OK;
	47
	48	end:
	49	Py_XDECREF(py_res);
	50	Py_XDECREF(py_port_ptr);
	51	Py_XDECREF(py_component_ptr);
	52	return status;
	53	}
	54
	55	static
	56	bt_graph_listener_func_status
	57	source_component_output_port_added_listener(const bt_component_source *component_source,
	58	const bt_port_output port_output, void py_callable)
	59	{
	60	return port_added_listener(
	61	component_source, SWIGTYPE_p_bt_component_source, BT_COMPONENT_CLASS_TYPE_SOURCE,
	62	port_output, SWIGTYPE_p_bt_port_output, BT_PORT_TYPE_OUTPUT, py_callable);
	63	}
	64
	65	static
	66	bt_graph_listener_func_status
	67	filter_component_input_port_added_listener(const bt_component_filter *component_filter,
	68	const bt_port_input port_input, void py_callable)
	69	{
	70	return port_added_listener(
	71	component_filter, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
	72	port_input, SWIGTYPE_p_bt_port_input, BT_PORT_TYPE_INPUT, py_callable);
	73	}
	74
	75	static
	76	bt_graph_listener_func_status
	77	filter_component_output_port_added_listener(const bt_component_filter *component_filter,
	78	const bt_port_output port_output, void py_callable)
	79	{
	80	return port_added_listener(
	81	component_filter, SWIGTYPE_p_bt_component_filter, BT_COMPONENT_CLASS_TYPE_FILTER,
	82	port_output, SWIGTYPE_p_bt_port_output, BT_PORT_TYPE_OUTPUT, py_callable);
	83	}
	84
	85	static
	86	bt_graph_listener_func_status
	87	sink_component_input_port_added_listener(const bt_component_sink *component_sink,
	88	const bt_port_input port_input, void py_callable)
	89	{
	90	return port_added_listener(
	91	component_sink, SWIGTYPE_p_bt_component_sink, BT_COMPONENT_CLASS_TYPE_SINK,
	92	port_input, SWIGTYPE_p_bt_port_input, BT_PORT_TYPE_INPUT, py_callable);
	93	}
	94
	95	static
	96	PyObject bt_bt2_graph_add_port_added_listener(struct bt_graph graph,
	97	PyObject *py_callable)
	98	{
	99	PyObject *py_listener_ids = NULL;
	100	PyObject *py_listener_id = NULL;
	101	bt_listener_id listener_id;
	102	bt_graph_add_listener_status status;
	103	const char * const module_name =
	104	"graph_add_port_added_listener() (Python)";
105
106	BT_ASSERT(graph);
107	BT_ASSERT(py_callable);
108
109	/*
110	* Behind the scene, we will be registering 4 different listeners and
111	* return all of their ids.
112	*/
113	py_listener_ids = PyTuple_New(4);
114	if (!py_listener_ids) {
115	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
116	"Failed to allocate one PyTuple.");
117	goto error;
118	}
119
120	/* source output port */
121	status = bt_graph_add_source_component_output_port_added_listener(
122	graph, source_component_output_port_added_listener,
f3d6b4c2	123	py_callable, &listener_id);
4212232c PP	124	if (status != __BT_FUNC_STATUS_OK) {
	125	/*
	126	* bt_graph_add_source_component_output_port_added_listener has
	127	* already logged/appended an error cause.
	128	*/
	129	goto error;
	130	}
	131
	132	py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
	133	if (!py_listener_id) {
	134	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
	135	"Failed to allocate one PyLong.");
	136	goto error;
	137	}
	138
	139	PyTuple_SET_ITEM(py_listener_ids, 0, py_listener_id);
	140	py_listener_id = NULL;
	141
	142	/* filter input port */
	143	status = bt_graph_add_filter_component_input_port_added_listener(
	144	graph, filter_component_input_port_added_listener,
f3d6b4c2	145	py_callable, &listener_id);
4212232c PP	146	if (status != __BT_FUNC_STATUS_OK) {
	147	/*
	148	* bt_graph_add_filter_component_input_port_added_listener has
	149	* already logged/appended an error cause.
	150	*/
	151	goto error;
	152	}
	153
	154	py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
	155	if (!py_listener_id) {
	156	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
	157	"Failed to allocate one PyLong.");
	158	goto error;
	159	}
	160
	161	PyTuple_SET_ITEM(py_listener_ids, 1, py_listener_id);
	162	py_listener_id = NULL;
	163
	164	/* filter output port */
	165	status = bt_graph_add_filter_component_output_port_added_listener(
	166	graph, filter_component_output_port_added_listener,
f3d6b4c2	167	py_callable, &listener_id);
4212232c PP	168	if (status != __BT_FUNC_STATUS_OK) {
	169	/*
	170	* bt_graph_add_filter_component_output_port_added_listener has
	171	* already logged/appended an error cause.
	172	*/
	173	goto error;
	174	}
	175
	176	py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
	177	if (!py_listener_id) {
	178	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
	179	"Failed to allocate one PyLong.");
	180	goto error;
	181	}
	182
	183	PyTuple_SET_ITEM(py_listener_ids, 2, py_listener_id);
	184	py_listener_id = NULL;
	185
	186	/* sink input port */
	187	status = bt_graph_add_sink_component_input_port_added_listener(
	188	graph, sink_component_input_port_added_listener,
f3d6b4c2	189	py_callable, &listener_id);
4212232c PP	190	if (status != __BT_FUNC_STATUS_OK) {
	191	/*
	192	* bt_graph_add_sink_component_input_port_added_listener has
	193	* already logged/appended an error cause.
	194	*/
	195	goto error;
	196	}
	197
	198	py_listener_id = PyLong_FromUnsignedLongLong(listener_id);
	199	if (!py_listener_id) {
	200	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(module_name,
	201	"Failed to allocate one PyLong.");
	202	goto error;
	203	}
	204
4212232c PP	205	PyTuple_SET_ITEM(py_listener_ids, 3, py_listener_id);
4212232c PP	206	py_listener_id = NULL;
4212232c PP	207	goto end;
	208
	209	error:
	210	Py_XDECREF(py_listener_ids);
	211	py_listener_ids = Py_None;
	212	Py_INCREF(py_listener_ids);
	213
	214	end:
4212232c PP	215	Py_XDECREF(py_listener_id);
	216	return py_listener_ids;
	217	}
	218
66964f3f PP	219	static
	220	bt_graph_add_component_status
	221	bt_bt2_graph_add_source_component(
	222	bt_graph *graph,
	223	const bt_component_class_source *component_class,
	224	const char name, const bt_value params,
	225	PyObject *obj, bt_logging_level log_level,
	226	const bt_component_source **component)
	227	{
21a9f056	228	return bt_graph_add_source_component_with_initialize_method_data(graph,
66964f3f PP	229	component_class, name, params, obj == Py_None ? NULL : obj,
	230	log_level, component);
	231	}
	232
	233	static
	234	bt_graph_add_component_status
	235	bt_bt2_graph_add_filter_component(
	236	bt_graph *graph,
	237	const bt_component_class_filter *component_class,
	238	const char name, const bt_value params,
	239	PyObject *obj, bt_logging_level log_level,
	240	const bt_component_filter **component)
	241	{
21a9f056	242	return bt_graph_add_filter_component_with_initialize_method_data(graph,
66964f3f PP	243	component_class, name, params, obj == Py_None ? NULL : obj,
	244	log_level, component);
	245	}
	246
	247	static
	248	bt_graph_add_component_status
	249	bt_bt2_graph_add_sink_component(
	250	bt_graph *graph,
	251	const bt_component_class_sink *component_class,
	252	const char name, const bt_value params,
	253	PyObject *obj, bt_logging_level log_level,
	254	const bt_component_sink **component)
	255	{
21a9f056	256	return bt_graph_add_sink_component_with_initialize_method_data(graph,
66964f3f PP	257	component_class, name, params, obj == Py_None ? NULL : obj,
	258	log_level, component);
	259	}