[babeltrace.git] / lib / component / filter.c

/*
 * filter.c
 *
 * Babeltrace Filter Component
 *
 * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <babeltrace/compiler.h>
#include <babeltrace/values.h>
#include <babeltrace/component/component-filter-internal.h>
#include <babeltrace/component/component-internal.h>
#include <babeltrace/component/component-class-internal.h>
#include <babeltrace/component/notification/notification.h>
#include <babeltrace/component/notification/iterator-internal.h>

BT_HIDDEN
struct bt_notification_iterator *bt_component_filter_create_notification_iterator(
		struct bt_component *component)
{
	return bt_component_create_iterator(component, NULL);
}

BT_HIDDEN
struct bt_notification_iterator *bt_component_filter_create_notification_iterator_with_init_method_data(
		struct bt_component *component, void *init_method_data)
{
	return bt_component_create_iterator(component, init_method_data);
}

static
void bt_component_filter_destroy(struct bt_component *component)
{
	struct bt_component_filter *filter = container_of(component,
			struct bt_component_filter, parent);

	if (filter->input_ports) {
		g_ptr_array_free(filter->input_ports, TRUE);
	}

	if (filter->output_ports) {
		g_ptr_array_free(filter->output_ports, TRUE);
	}
}

BT_HIDDEN
struct bt_component *bt_component_filter_create(
		struct bt_component_class *class, struct bt_value *params)
{
	int ret;
	struct bt_component_filter *filter = NULL;
	enum bt_component_status status;

	filter = g_new0(struct bt_component_filter, 1);
	if (!filter) {
		goto end;
	}

	filter->parent.class = bt_get(class);
	status = bt_component_init(&filter->parent, bt_component_filter_destroy);
	if (status != BT_COMPONENT_STATUS_OK) {
		goto error;
	}

	ret = bt_component_init_input_ports(&filter->parent,
			&filter->input_ports);
	if (ret) {
		goto error;
	}

	ret = bt_component_init_output_ports(&filter->parent,
			&filter->output_ports);
	if (ret) {
		goto error;
	}

end:
	return filter ? &filter->parent : NULL;
error:
	BT_PUT(filter);
	goto end;
}

BT_HIDDEN
enum bt_component_status bt_component_filter_validate(
		struct bt_component *component)
{
	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;

	if (!component) {
		ret = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

	if (!component->class) {
		ret = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

	if (component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		ret = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

	/* Enforce iterator limits. */
end:
	return ret;
}

int bt_component_filter_get_input_port_count(struct bt_component *component)
{
	int ret;
	struct bt_component_filter *filter;

	if (!component) {
		ret = -1;
		goto end;
	}

	if (component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		ret = -1;
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	ret = filter->input_ports->len;
end:
	return ret;
}

struct bt_port *bt_component_filter_get_input_port(
		struct bt_component *component, const char *name)
{
	struct bt_component_filter *filter;
	struct bt_port *ret_port = NULL;

	if (!component || !name ||
			component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	ret_port = bt_component_get_port(filter->input_ports, name);
end:
	return ret_port;
}

struct bt_port *bt_component_filter_get_input_port_at_index(
		struct bt_component *component, int index)
{
	struct bt_port *port = NULL;
	struct bt_component_filter *filter;

	if (!component ||
			component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	port = bt_component_get_port_at_index(filter->input_ports, index);
end:
	return port;
}

struct bt_port *bt_component_filter_get_default_input_port(
		struct bt_component *component)
{
	return bt_component_filter_get_input_port(component,
			DEFAULT_INPUT_PORT_NAME);
}

struct bt_port *bt_component_filter_add_input_port(
		struct bt_component *component, const char *name)
{
	struct bt_port *port;
	struct bt_component_filter *filter;

	if (!component ||
			component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		port = NULL;
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	port = bt_component_add_port(component, filter->input_ports,
			BT_PORT_TYPE_INPUT, name);
end:
	return port;
}

enum bt_component_status bt_component_filter_remove_input_port(
		struct bt_component *component, const char *name)
{
	enum bt_component_status status;
	struct bt_component_filter *filter;

	if (!component ||
			component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		status = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	status = bt_component_remove_port(component, filter->input_ports,
			name);
end:
	return status;
}

int bt_component_filter_get_output_port_count(struct bt_component *component)
{
	int ret;
	struct bt_component_filter *filter;

	if (!component) {
		ret = -1;
		goto end;
	}

	if (component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		ret = -1;
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	ret = filter->output_ports->len;
end:
	return ret;
}

struct bt_port *bt_component_filter_get_output_port(
		struct bt_component *component, const char *name)
{
	struct bt_component_filter *filter;
	struct bt_port *ret_port = NULL;

	if (!component || !name ||
			component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	ret_port = bt_component_get_port(filter->output_ports, name);
end:
	return ret_port;
}

struct bt_port *bt_component_filter_get_output_port_at_index(
		struct bt_component *component, int index)
{
	struct bt_port *port = NULL;
	struct bt_component_filter *filter;

	if (!component ||
			component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	port = bt_component_get_port_at_index(filter->output_ports, index);
end:
	return port;
}

struct bt_port *bt_component_filter_get_default_output_port(
		struct bt_component *component)
{
	return bt_component_filter_get_output_port(component,
			DEFAULT_OUTPUT_PORT_NAME);
}

struct bt_port *bt_component_filter_add_output_port(
		struct bt_component *component, const char *name)
{
	struct bt_port *port;
	struct bt_component_filter *filter;

	if (!component ||
			component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		port = NULL;
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	port = bt_component_add_port(component, filter->output_ports,
			BT_PORT_TYPE_OUTPUT, name);
end:
	return port;
}

enum bt_component_status bt_component_filter_remove_output_port(
		struct bt_component *component, const char *name)
{
	enum bt_component_status status;
	struct bt_component_filter *filter;

	if (!component ||
			component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
		status = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

	filter = container_of(component, struct bt_component_filter, parent);
	status = bt_component_remove_port(component, filter->output_ports,
			name);
end:
	return status;
}
Commit	Line	Data
34ac9eaf JG	1	/*
	2	* filter.c
	3	*
	4	* Babeltrace Filter Component
	5	*
	6	* Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	7	*
	8	* Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to deal
	12	* in the Software without restriction, including without limitation the rights
	13	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	14	* copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* The above copyright notice and this permission notice shall be included in
	18	* all copies or substantial portions of the Software.
	19	*
	20	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	21	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	23	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	24	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	25	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	26	* SOFTWARE.
	27	*/
	28
	29	#include <babeltrace/compiler.h>
	30	#include <babeltrace/values.h>
d71dcf2c	31	#include <babeltrace/component/component-filter-internal.h>
33b34c43	32	#include <babeltrace/component/component-internal.h>
d3e4dcd8	33	#include <babeltrace/component/component-class-internal.h>
33b34c43 PP	34	#include <babeltrace/component/notification/notification.h>
33b34c43 PP	35	#include <babeltrace/component/notification/iterator-internal.h>
34ac9eaf	36
920b1d51	37	BT_HIDDEN
366e034f JG	38	struct bt_notification_iterator *bt_component_filter_create_notification_iterator(
366e034f JG	39	struct bt_component *component)
34a9ed19	40	{
366e034f JG	41	return bt_component_create_iterator(component, NULL);
366e034f JG	42	}
34a9ed19	43
920b1d51	44	BT_HIDDEN
366e034f JG	45	struct bt_notification_iterator *bt_component_filter_create_notification_iterator_with_init_method_data(
	46	struct bt_component component, void init_method_data)
	47	{
	48	return bt_component_create_iterator(component, init_method_data);
	49	}
34a9ed19	50
366e034f JG	51	static
	52	void bt_component_filter_destroy(struct bt_component *component)
	53	{
	54	struct bt_component_filter *filter = container_of(component,
	55	struct bt_component_filter, parent);
34a9ed19	56
366e034f JG	57	if (filter->input_ports) {
366e034f JG	58	g_ptr_array_free(filter->input_ports, TRUE);
34a9ed19 JG	59	}
34a9ed19 JG	60
366e034f JG	61	if (filter->output_ports) {
	62	g_ptr_array_free(filter->output_ports, TRUE);
	63	}
34a9ed19 JG	64	}
34a9ed19 JG	65
366e034f JG	66	BT_HIDDEN
	67	struct bt_component *bt_component_filter_create(
	68	struct bt_component_class class, struct bt_value params)
34a9ed19	69	{
366e034f JG	70	int ret;
	71	struct bt_component_filter *filter = NULL;
	72	enum bt_component_status status;
34a9ed19	73
366e034f JG	74	filter = g_new0(struct bt_component_filter, 1);
366e034f JG	75	if (!filter) {
34a9ed19 JG	76	goto end;
	77	}
	78
366e034f JG	79	filter->parent.class = bt_get(class);
	80	status = bt_component_init(&filter->parent, bt_component_filter_destroy);
	81	if (status != BT_COMPONENT_STATUS_OK) {
	82	goto error;
	83	}
	84
	85	ret = bt_component_init_input_ports(&filter->parent,
	86	&filter->input_ports);
	87	if (ret) {
	88	goto error;
	89	}
	90
	91	ret = bt_component_init_output_ports(&filter->parent,
	92	&filter->output_ports);
	93	if (ret) {
	94	goto error;
34a9ed19 JG	95	}
34a9ed19 JG	96
34a9ed19	97	end:
366e034f JG	98	return filter ? &filter->parent : NULL;
	99	error:
	100	BT_PUT(filter);
	101	goto end;
34a9ed19 JG	102	}
34a9ed19 JG	103
366e034f JG	104	BT_HIDDEN
	105	enum bt_component_status bt_component_filter_validate(
	106	struct bt_component *component)
34a9ed19	107	{
34a9ed19 JG	108	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
34a9ed19 JG	109
366e034f	110	if (!component) {
34a9ed19 JG	111	ret = BT_COMPONENT_STATUS_INVALID;
	112	goto end;
	113	}
	114
366e034f JG	115	if (!component->class) {
366e034f JG	116	ret = BT_COMPONENT_STATUS_INVALID;
34a9ed19 JG	117	goto end;
	118	}
	119
366e034f	120	if (component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
34a9ed19 JG	121	ret = BT_COMPONENT_STATUS_INVALID;
	122	goto end;
	123	}
	124
366e034f	125	/* Enforce iterator limits. */
34a9ed19 JG	126	end:
	127	return ret;
	128	}
	129
366e034f	130	int bt_component_filter_get_input_port_count(struct bt_component *component)
34a9ed19	131	{
366e034f	132	int ret;
34a9ed19	133	struct bt_component_filter *filter;
34a9ed19	134
366e034f JG	135	if (!component) {
366e034f JG	136	ret = -1;
34a9ed19 JG	137	goto end;
	138	}
	139
366e034f JG	140	if (component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
366e034f JG	141	ret = -1;
34a9ed19 JG	142	goto end;
	143	}
	144
	145	filter = container_of(component, struct bt_component_filter, parent);
366e034f JG	146	ret = filter->input_ports->len;
	147	end:
	148	return ret;
	149	}
	150
	151	struct bt_port *bt_component_filter_get_input_port(
	152	struct bt_component component, const char name)
	153	{
	154	struct bt_component_filter *filter;
	155	struct bt_port *ret_port = NULL;
	156
	157	if (!component \|\| !name \|\|
	158	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
34a9ed19 JG	159	goto end;
	160	}
	161
366e034f JG	162	filter = container_of(component, struct bt_component_filter, parent);
	163	ret_port = bt_component_get_port(filter->input_ports, name);
	164	end:
	165	return ret_port;
	166	}
d3e4dcd8	167
366e034f JG	168	struct bt_port *bt_component_filter_get_input_port_at_index(
	169	struct bt_component *component, int index)
	170	{
	171	struct bt_port *port = NULL;
	172	struct bt_component_filter *filter;
	173
	174	if (!component \|\|
	175	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	176	goto end;
34a9ed19 JG	177	}
34a9ed19 JG	178
366e034f JG	179	filter = container_of(component, struct bt_component_filter, parent);
366e034f JG	180	port = bt_component_get_port_at_index(filter->input_ports, index);
34a9ed19	181	end:
366e034f	182	return port;
34a9ed19 JG	183	}
34a9ed19 JG	184
366e034f	185	struct bt_port *bt_component_filter_get_default_input_port(
34a9ed19 JG	186	struct bt_component *component)
34a9ed19 JG	187	{
366e034f JG	188	return bt_component_filter_get_input_port(component,
366e034f JG	189	DEFAULT_INPUT_PORT_NAME);
8b0ce102 PP	190	}
8b0ce102 PP	191
366e034f JG	192	struct bt_port *bt_component_filter_add_input_port(
366e034f JG	193	struct bt_component component, const char name)
8b0ce102	194	{
366e034f JG	195	struct bt_port *port;
	196	struct bt_component_filter *filter;
	197
	198	if (!component \|\|
	199	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	200	port = NULL;
	201	goto end;
	202	}
	203
	204	filter = container_of(component, struct bt_component_filter, parent);
	205	port = bt_component_add_port(component, filter->input_ports,
	206	BT_PORT_TYPE_INPUT, name);
	207	end:
	208	return port;
34a9ed19	209	}
526fc31a	210
366e034f JG	211	enum bt_component_status bt_component_filter_remove_input_port(
366e034f JG	212	struct bt_component component, const char name)
526fc31a	213	{
366e034f JG	214	enum bt_component_status status;
366e034f JG	215	struct bt_component_filter *filter;
526fc31a	216
366e034f JG	217	if (!component \|\|
	218	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	219	status = BT_COMPONENT_STATUS_INVALID;
	220	goto end;
	221	}
	222
	223	filter = container_of(component, struct bt_component_filter, parent);
	224	status = bt_component_remove_port(component, filter->input_ports,
	225	name);
	226	end:
	227	return status;
526fc31a JG	228	}
526fc31a JG	229
366e034f	230	int bt_component_filter_get_output_port_count(struct bt_component *component)
526fc31a	231	{
366e034f JG	232	int ret;
366e034f JG	233	struct bt_component_filter *filter;
526fc31a	234
366e034f JG	235	if (!component) {
366e034f JG	236	ret = -1;
526fc31a JG	237	goto end;
	238	}
	239
366e034f JG	240	if (component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	241	ret = -1;
	242	goto end;
526fc31a JG	243	}
526fc31a JG	244
366e034f JG	245	filter = container_of(component, struct bt_component_filter, parent);
366e034f JG	246	ret = filter->output_ports->len;
526fc31a	247	end:
366e034f	248	return ret;
526fc31a JG	249	}
526fc31a JG	250
366e034f JG	251	struct bt_port *bt_component_filter_get_output_port(
366e034f JG	252	struct bt_component component, const char name)
526fc31a	253	{
526fc31a	254	struct bt_component_filter *filter;
366e034f	255	struct bt_port *ret_port = NULL;
526fc31a	256
366e034f JG	257	if (!component \|\| !name \|\|
366e034f JG	258	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
526fc31a JG	259	goto end;
	260	}
	261
366e034f JG	262	filter = container_of(component, struct bt_component_filter, parent);
	263	ret_port = bt_component_get_port(filter->output_ports, name);
	264	end:
	265	return ret_port;
	266	}
	267
	268	struct bt_port *bt_component_filter_get_output_port_at_index(
	269	struct bt_component *component, int index)
	270	{
	271	struct bt_port *port = NULL;
	272	struct bt_component_filter *filter;
	273
	274	if (!component \|\|
	275	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
526fc31a JG	276	goto end;
	277	}
	278
366e034f JG	279	filter = container_of(component, struct bt_component_filter, parent);
	280	port = bt_component_get_port_at_index(filter->output_ports, index);
	281	end:
	282	return port;
	283	}
	284
	285	struct bt_port *bt_component_filter_get_default_output_port(
	286	struct bt_component *component)
	287	{
	288	return bt_component_filter_get_output_port(component,
	289	DEFAULT_OUTPUT_PORT_NAME);
	290	}
	291
	292	struct bt_port *bt_component_filter_add_output_port(
	293	struct bt_component component, const char name)
	294	{
	295	struct bt_port *port;
	296	struct bt_component_filter *filter;
	297
	298	if (!component \|\|
	299	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	300	port = NULL;
526fc31a JG	301	goto end;
	302	}
	303
	304	filter = container_of(component, struct bt_component_filter, parent);
366e034f JG	305	port = bt_component_add_port(component, filter->output_ports,
	306	BT_PORT_TYPE_OUTPUT, name);
	307	end:
	308	return port;
	309	}
	310
	311	enum bt_component_status bt_component_filter_remove_output_port(
	312	struct bt_component component, const char name)
	313	{
	314	enum bt_component_status status;
	315	struct bt_component_filter *filter;
	316
	317	if (!component \|\|
	318	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	319	status = BT_COMPONENT_STATUS_INVALID;
526fc31a JG	320	goto end;
526fc31a JG	321	}
366e034f JG	322
	323	filter = container_of(component, struct bt_component_filter, parent);
	324	status = bt_component_remove_port(component, filter->output_ports,
	325	name);
526fc31a	326	end:
366e034f	327	return status;
526fc31a	328	}