[babeltrace.git] / doc / api / libbabeltrace2 / examples / epitome.c

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#include <babeltrace2/babeltrace.h>

/* Sink component's private data */
struct epitome_out {
    /* Upstream message iterator (owned by this) */
    bt_message_iterator *message_iterator;

    /* Current event message index */
    uint64_t index;
};

/*
 * Initializes the sink component.
 */
static
bt_component_class_initialize_method_status epitome_out_initialize(
        bt_self_component_sink *self_component_sink,
        bt_self_component_sink_configuration *configuration,
        const bt_value *params, void *initialize_method_data)
{
    /* Allocate a private data structure */
    struct epitome_out *epitome_out = malloc(sizeof(*epitome_out));

    /* Initialize the first event message's index */
    epitome_out->index = 1;

    /* Set the component's user data to our private data structure */
    bt_self_component_set_data(
        bt_self_component_sink_as_self_component(self_component_sink),
        epitome_out);

    /*
     * Add an input port named `in` to the sink component.
     *
     * This is needed so that this sink component can be connected to a
     * filter or a source component. With a connected upstream
     * component, this sink component can create a message iterator
     * to consume messages.
     */
    bt_self_component_sink_add_input_port(self_component_sink,
        "in", NULL, NULL);

    return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
}

/*
 * Finalizes the sink component.
 */
static
void epitome_out_finalize(bt_self_component_sink *self_component_sink)
{
    /* Retrieve our private data from the component's user data */
    struct epitome_out *epitome_out = bt_self_component_get_data(
        bt_self_component_sink_as_self_component(self_component_sink));

    /* Free the allocated structure */
    free(epitome_out);
}

/*
 * Called when the trace processing graph containing the sink component
 * is configured.
 *
 * This is where we can create our upstream message iterator.
 */
static
bt_component_class_sink_graph_is_configured_method_status
epitome_out_graph_is_configured(bt_self_component_sink *self_component_sink)
{
    /* Retrieve our private data from the component's user data */
    struct epitome_out *epitome_out = bt_self_component_get_data(
        bt_self_component_sink_as_self_component(self_component_sink));

    /* Borrow our unique port */
    bt_self_component_port_input *in_port =
        bt_self_component_sink_borrow_input_port_by_index(
            self_component_sink, 0);

    /* Create the uptream message iterator */
    bt_message_iterator_create_from_sink_component(self_component_sink,
        in_port, &epitome_out->message_iterator);

    return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
}

/*
 * Prints a line for `message`, if it's an event message, to the
 * standard output.
 */
static
void print_message(struct epitome_out *epitome_out, const bt_message *message)
{
    /* Discard if it's not an event message */
    if (bt_message_get_type(message) != BT_MESSAGE_TYPE_EVENT) {
        goto end;
    }

    /* Borrow the event message's event and its class */
    const bt_event *event =
        bt_message_event_borrow_event_const(message);
    const bt_event_class *event_class = bt_event_borrow_class_const(event);

    /* Get the number of payload field members */
    const bt_field *payload_field =
        bt_event_borrow_payload_field_const(event);
    uint64_t member_count = bt_field_class_structure_get_member_count(
        bt_field_borrow_class_const(payload_field));

    /* Write a corresponding line to the standard output */
    printf("#%" PRIu64 ": %s (%" PRIu64 " payload member%s)\n",
        epitome_out->index, bt_event_class_get_name(event_class),
        member_count, member_count == 1 ? "" : "s");

    /* Increment the current event message's index */
    epitome_out->index++;

end:
    return;
}

/*
 * Consumes a batch of messages and writes the corresponding lines to
 * the standard output.
 */
bt_component_class_sink_consume_method_status epitome_out_consume(
        bt_self_component_sink *self_component_sink)
{
    bt_component_class_sink_consume_method_status status =
        BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;

    /* Retrieve our private data from the component's user data */
    struct epitome_out *epitome_out = bt_self_component_get_data(
        bt_self_component_sink_as_self_component(self_component_sink));

    /* Consume a batch of messages from the upstream message iterator */
    bt_message_array_const messages;
    uint64_t message_count;
    bt_message_iterator_next_status next_status =
        bt_message_iterator_next(epitome_out->message_iterator, &messages,
            &message_count);

    switch (next_status) {
    case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
        /* End of iteration: put the message iterator's reference */
        bt_message_iterator_put_ref(epitome_out->message_iterator);
        status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_END;
        goto end;
    case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
        status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_AGAIN;
        goto end;
    case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
        status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_MEMORY_ERROR;
        goto end;
    case BT_MESSAGE_ITERATOR_NEXT_STATUS_ERROR:
        status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
        goto end;
    default:
        break;
    }

    /* For each consumed message */
    for (uint64_t i = 0; i < message_count; i++) {
        /* Current message */
        const bt_message *message = messages[i];

        /* Print line for current message if it's an event message */
        print_message(epitome_out, message);

        /* Put this message's reference */
        bt_message_put_ref(message);
    }

end:
    return status;
}

/* Mandatory */
BT_PLUGIN_MODULE();

/* Define the `epitome` plugin */
BT_PLUGIN(epitome);

/* Define the `output` sink component class */
BT_PLUGIN_SINK_COMPONENT_CLASS(output, epitome_out_consume);

/* Set some of the `output` sink component class's optional methods */
BT_PLUGIN_SINK_COMPONENT_CLASS_INITIALIZE_METHOD(output,
    epitome_out_initialize);
BT_PLUGIN_SINK_COMPONENT_CLASS_FINALIZE_METHOD(output, epitome_out_finalize);
BT_PLUGIN_SINK_COMPONENT_CLASS_GRAPH_IS_CONFIGURED_METHOD(output,
    epitome_out_graph_is_configured);
Commit	Line	Data
43c59509 PP	1	#include <stdlib.h>
	2	#include <stdio.h>
	3	#include <stdint.h>
	4	#include <inttypes.h>
	5	#include <string.h>
	6	#include <babeltrace2/babeltrace.h>
	7
	8	/* Sink component's private data */
	9	struct epitome_out {
	10	/* Upstream message iterator (owned by this) */
	11	bt_message_iterator *message_iterator;
	12
	13	/* Current event message index */
	14	uint64_t index;
	15	};
	16
	17	/*
	18	* Initializes the sink component.
	19	*/
	20	static
	21	bt_component_class_initialize_method_status epitome_out_initialize(
	22	bt_self_component_sink *self_component_sink,
	23	bt_self_component_sink_configuration *configuration,
	24	const bt_value params, void initialize_method_data)
	25	{
	26	/* Allocate a private data structure */
	27	struct epitome_out epitome_out = malloc(sizeof(epitome_out));
	28
	29	/* Initialize the first event message's index */
	30	epitome_out->index = 1;
	31
	32	/* Set the component's user data to our private data structure */
	33	bt_self_component_set_data(
	34	bt_self_component_sink_as_self_component(self_component_sink),
	35	epitome_out);
	36
	37	/*
	38	* Add an input port named `in` to the sink component.
	39	*
	40	* This is needed so that this sink component can be connected to a
	41	* filter or a source component. With a connected upstream
	42	* component, this sink component can create a message iterator
	43	* to consume messages.
	44	*/
	45	bt_self_component_sink_add_input_port(self_component_sink,
	46	"in", NULL, NULL);
	47
	48	return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
	49	}
	50
	51	/*
	52	* Finalizes the sink component.
	53	*/
	54	static
	55	void epitome_out_finalize(bt_self_component_sink *self_component_sink)
	56	{
	57	/* Retrieve our private data from the component's user data */
	58	struct epitome_out *epitome_out = bt_self_component_get_data(
	59	bt_self_component_sink_as_self_component(self_component_sink));
	60
	61	/* Free the allocated structure */
	62	free(epitome_out);
	63	}
	64
65	/*
66	* Called when the trace processing graph containing the sink component
67	* is configured.
68	*
69	* This is where we can create our upstream message iterator.
70	*/
71	static
72	bt_component_class_sink_graph_is_configured_method_status
73	epitome_out_graph_is_configured(bt_self_component_sink *self_component_sink)
74	{
75	/* Retrieve our private data from the component's user data */
76	struct epitome_out *epitome_out = bt_self_component_get_data(
77	bt_self_component_sink_as_self_component(self_component_sink));
78
79	/* Borrow our unique port */
80	bt_self_component_port_input *in_port =
81	bt_self_component_sink_borrow_input_port_by_index(
82	self_component_sink, 0);
83
84	/* Create the uptream message iterator */
85	bt_message_iterator_create_from_sink_component(self_component_sink,
86	in_port, &epitome_out->message_iterator);
87
88	return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
89	}
90
91	/*
92	* Prints a line for `message`, if it's an event message, to the
93	* standard output.
94	*/
95	static
96	void print_message(struct epitome_out epitome_out, const bt_message message)
97	{
98	/* Discard if it's not an event message */
99	if (bt_message_get_type(message) != BT_MESSAGE_TYPE_EVENT) {
100	goto end;
101	}
102
103	/* Borrow the event message's event and its class */
104	const bt_event *event =
105	bt_message_event_borrow_event_const(message);
106	const bt_event_class *event_class = bt_event_borrow_class_const(event);
107
108	/* Get the number of payload field members */
109	const bt_field *payload_field =
110	bt_event_borrow_payload_field_const(event);
111	uint64_t member_count = bt_field_class_structure_get_member_count(
112	bt_field_borrow_class_const(payload_field));
113
114	/* Write a corresponding line to the standard output */
115	printf("#%" PRIu64 ": %s (%" PRIu64 " payload member%s)\n",
116	epitome_out->index, bt_event_class_get_name(event_class),
117	member_count, member_count == 1 ? "" : "s");
118
119	/* Increment the current event message's index */
120	epitome_out->index++;
121
122	end:
123	return;
124	}
125
126	/*
127	* Consumes a batch of messages and writes the corresponding lines to
128	* the standard output.
129	*/
130	bt_component_class_sink_consume_method_status epitome_out_consume(
131	bt_self_component_sink *self_component_sink)
132	{
133	bt_component_class_sink_consume_method_status status =
134	BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
135
136	/* Retrieve our private data from the component's user data */
137	struct epitome_out *epitome_out = bt_self_component_get_data(
138	bt_self_component_sink_as_self_component(self_component_sink));
139
140	/* Consume a batch of messages from the upstream message iterator */
141	bt_message_array_const messages;
142	uint64_t message_count;
143	bt_message_iterator_next_status next_status =
144	bt_message_iterator_next(epitome_out->message_iterator, &messages,
145	&message_count);
146
147	switch (next_status) {
148	case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
149	/* End of iteration: put the message iterator's reference */
150	bt_message_iterator_put_ref(epitome_out->message_iterator);
151	status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_END;
152	goto end;
153	case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
154	status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_AGAIN;
155	goto end;
156	case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
157	status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_MEMORY_ERROR;
158	goto end;
159	case BT_MESSAGE_ITERATOR_NEXT_STATUS_ERROR:
160	status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
161	goto end;
162	default:
163	break;
164	}
165
166	/* For each consumed message */
167	for (uint64_t i = 0; i < message_count; i++) {
168	/* Current message */
169	const bt_message *message = messages[i];
170
171	/* Print line for current message if it's an event message */
172	print_message(epitome_out, message);
173
174	/* Put this message's reference */
175	bt_message_put_ref(message);
176	}
177
178	end:
179	return status;
180	}
181
182	/* Mandatory */
183	BT_PLUGIN_MODULE();
184
185	/* Define the `epitome` plugin */
186	BT_PLUGIN(epitome);
187
188	/* Define the `output` sink component class */
189	BT_PLUGIN_SINK_COMPONENT_CLASS(output, epitome_out_consume);
190
191	/* Set some of the `output` sink component class's optional methods */
192	BT_PLUGIN_SINK_COMPONENT_CLASS_INITIALIZE_METHOD(output,
193	epitome_out_initialize);
194	BT_PLUGIN_SINK_COMPONENT_CLASS_FINALIZE_METHOD(output, epitome_out_finalize);
195	BT_PLUGIN_SINK_COMPONENT_CLASS_GRAPH_IS_CONFIGURED_METHOD(output,
196	epitome_out_graph_is_configured);