[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;
}

enum bt_component_status bt_component_filter_get_input_port_count(
		struct bt_component *component, uint64_t *count)
{
	enum bt_component_status status = BT_COMPONENT_STATUS_OK;
	struct bt_component_filter *filter;

	if (!component || !count) {
	        status = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

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

	filter = container_of(component, struct bt_component_filter, parent);
	*count = (uint64_t) filter->input_ports->len;
end:
	return status;
}

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;
}

enum bt_component_status bt_component_filter_get_output_port_count(
		struct bt_component *component, uint64_t *count)
{
	enum bt_component_status status = BT_COMPONENT_STATUS_OK;
	struct bt_component_filter *filter;

	if (!component || !count) {
	        status = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

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

	filter = container_of(component, struct bt_component_filter, parent);
	*count = (uint64_t) filter->output_ports->len;
end:
	return status;
}

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
346df6cf JG	130	enum bt_component_status bt_component_filter_get_input_port_count(
346df6cf JG	131	struct bt_component component, uint64_t count)
34a9ed19	132	{
346df6cf	133	enum bt_component_status status = BT_COMPONENT_STATUS_OK;
34a9ed19	134	struct bt_component_filter *filter;
34a9ed19	135
346df6cf JG	136	if (!component \|\| !count) {
346df6cf JG	137	status = BT_COMPONENT_STATUS_INVALID;
34a9ed19 JG	138	goto end;
	139	}
	140
366e034f	141	if (component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
346df6cf	142	status = BT_COMPONENT_STATUS_INVALID;
34a9ed19 JG	143	goto end;
	144	}
	145
	146	filter = container_of(component, struct bt_component_filter, parent);
346df6cf	147	*count = (uint64_t) filter->input_ports->len;
366e034f	148	end:
346df6cf	149	return status;
366e034f JG	150	}
	151
	152	struct bt_port *bt_component_filter_get_input_port(
	153	struct bt_component component, const char name)
	154	{
	155	struct bt_component_filter *filter;
	156	struct bt_port *ret_port = NULL;
	157
	158	if (!component \|\| !name \|\|
	159	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
34a9ed19 JG	160	goto end;
	161	}
	162
366e034f JG	163	filter = container_of(component, struct bt_component_filter, parent);
	164	ret_port = bt_component_get_port(filter->input_ports, name);
	165	end:
	166	return ret_port;
	167	}
d3e4dcd8	168
366e034f JG	169	struct bt_port *bt_component_filter_get_input_port_at_index(
	170	struct bt_component *component, int index)
	171	{
	172	struct bt_port *port = NULL;
	173	struct bt_component_filter *filter;
	174
	175	if (!component \|\|
	176	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	177	goto end;
34a9ed19 JG	178	}
34a9ed19 JG	179
366e034f JG	180	filter = container_of(component, struct bt_component_filter, parent);
366e034f JG	181	port = bt_component_get_port_at_index(filter->input_ports, index);
34a9ed19	182	end:
366e034f	183	return port;
34a9ed19 JG	184	}
34a9ed19 JG	185
366e034f	186	struct bt_port *bt_component_filter_get_default_input_port(
34a9ed19 JG	187	struct bt_component *component)
34a9ed19 JG	188	{
366e034f JG	189	return bt_component_filter_get_input_port(component,
366e034f JG	190	DEFAULT_INPUT_PORT_NAME);
8b0ce102 PP	191	}
8b0ce102 PP	192
366e034f JG	193	struct bt_port *bt_component_filter_add_input_port(
366e034f JG	194	struct bt_component component, const char name)
8b0ce102	195	{
366e034f JG	196	struct bt_port *port;
	197	struct bt_component_filter *filter;
	198
	199	if (!component \|\|
	200	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	201	port = NULL;
	202	goto end;
	203	}
	204
	205	filter = container_of(component, struct bt_component_filter, parent);
	206	port = bt_component_add_port(component, filter->input_ports,
	207	BT_PORT_TYPE_INPUT, name);
	208	end:
	209	return port;
34a9ed19	210	}
526fc31a	211
366e034f JG	212	enum bt_component_status bt_component_filter_remove_input_port(
366e034f JG	213	struct bt_component component, const char name)
526fc31a	214	{
366e034f JG	215	enum bt_component_status status;
366e034f JG	216	struct bt_component_filter *filter;
526fc31a	217
366e034f JG	218	if (!component \|\|
	219	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	220	status = BT_COMPONENT_STATUS_INVALID;
	221	goto end;
	222	}
	223
	224	filter = container_of(component, struct bt_component_filter, parent);
	225	status = bt_component_remove_port(component, filter->input_ports,
	226	name);
	227	end:
	228	return status;
526fc31a JG	229	}
526fc31a JG	230
346df6cf JG	231	enum bt_component_status bt_component_filter_get_output_port_count(
346df6cf JG	232	struct bt_component component, uint64_t count)
526fc31a	233	{
346df6cf	234	enum bt_component_status status = BT_COMPONENT_STATUS_OK;
366e034f	235	struct bt_component_filter *filter;
526fc31a	236
346df6cf JG	237	if (!component \|\| !count) {
346df6cf JG	238	status = BT_COMPONENT_STATUS_INVALID;
526fc31a JG	239	goto end;
	240	}
	241
366e034f	242	if (component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
346df6cf	243	status = BT_COMPONENT_STATUS_INVALID;
366e034f	244	goto end;
526fc31a JG	245	}
526fc31a JG	246
366e034f	247	filter = container_of(component, struct bt_component_filter, parent);
346df6cf	248	*count = (uint64_t) filter->output_ports->len;
526fc31a	249	end:
346df6cf	250	return status;
526fc31a JG	251	}
526fc31a JG	252
366e034f JG	253	struct bt_port *bt_component_filter_get_output_port(
366e034f JG	254	struct bt_component component, const char name)
526fc31a	255	{
526fc31a	256	struct bt_component_filter *filter;
366e034f	257	struct bt_port *ret_port = NULL;
526fc31a	258
366e034f JG	259	if (!component \|\| !name \|\|
366e034f JG	260	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
526fc31a JG	261	goto end;
	262	}
	263
366e034f JG	264	filter = container_of(component, struct bt_component_filter, parent);
	265	ret_port = bt_component_get_port(filter->output_ports, name);
	266	end:
	267	return ret_port;
	268	}
	269
	270	struct bt_port *bt_component_filter_get_output_port_at_index(
	271	struct bt_component *component, int index)
	272	{
	273	struct bt_port *port = NULL;
	274	struct bt_component_filter *filter;
	275
	276	if (!component \|\|
	277	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
526fc31a JG	278	goto end;
	279	}
	280
366e034f JG	281	filter = container_of(component, struct bt_component_filter, parent);
	282	port = bt_component_get_port_at_index(filter->output_ports, index);
	283	end:
	284	return port;
	285	}
	286
	287	struct bt_port *bt_component_filter_get_default_output_port(
	288	struct bt_component *component)
	289	{
	290	return bt_component_filter_get_output_port(component,
	291	DEFAULT_OUTPUT_PORT_NAME);
	292	}
	293
	294	struct bt_port *bt_component_filter_add_output_port(
	295	struct bt_component component, const char name)
	296	{
	297	struct bt_port *port;
	298	struct bt_component_filter *filter;
	299
	300	if (!component \|\|
	301	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	302	port = NULL;
526fc31a JG	303	goto end;
	304	}
	305
	306	filter = container_of(component, struct bt_component_filter, parent);
366e034f JG	307	port = bt_component_add_port(component, filter->output_ports,
	308	BT_PORT_TYPE_OUTPUT, name);
	309	end:
	310	return port;
	311	}
	312
	313	enum bt_component_status bt_component_filter_remove_output_port(
	314	struct bt_component component, const char name)
	315	{
	316	enum bt_component_status status;
	317	struct bt_component_filter *filter;
	318
	319	if (!component \|\|
	320	component->class->type != BT_COMPONENT_CLASS_TYPE_FILTER) {
	321	status = BT_COMPONENT_STATUS_INVALID;
526fc31a JG	322	goto end;
526fc31a JG	323	}
366e034f JG	324
	325	filter = container_of(component, struct bt_component_filter, parent);
	326	status = bt_component_remove_port(component, filter->output_ports,
	327	name);
526fc31a	328	end:
366e034f	329	return status;
526fc31a	330	}