X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Futils%2Fcounter%2Fcounter.c;h=e667e2529f134ad7c137b7e482fabdf3407dd83e;hb=d6e69534ef08a2dd8bff9eb5af1eab63736b3d31;hp=bbcb82769590b4dd7f4bdecf676970c417f8d8e7;hpb=d4393e0875e7b08f6ee97d617cc5f2c9286742a4;p=babeltrace.git

diff --git a/plugins/utils/counter/counter.c b/plugins/utils/counter/counter.c
index bbcb8276..e667e252 100644
--- a/plugins/utils/counter/counter.c
+++ b/plugins/utils/counter/counter.c
@@ -48,8 +48,6 @@ uint64_t get_total_count(struct counter *counter)
 		counter->count.packet_begin +
 		counter->count.packet_end +
 		counter->count.inactivity +
-		counter->count.discarded_events +
-		counter->count.discarded_packets +
 		counter->count.other;
 }
 
@@ -64,35 +62,27 @@ void print_count(struct counter *counter)
 	PRINTF_COUNT("packet beginning", "packet beginnings", packet_begin);
 	PRINTF_COUNT("packet end", "packet ends", packet_end);
 	PRINTF_COUNT("inactivity", "inactivities", inactivity);
-	PRINTF_COUNT("discarded events notification",
-		"discarded events notifications", discarded_events_notifs);
-	PRINTF_COUNT("  known discarded event", "  known discarded events",
-		discarded_events);
-	PRINTF_COUNT("discarded packets notification",
-		"discarded packets notifications", discarded_packets_notifs);
-	PRINTF_COUNT("  known discarded packet", "  known discarded packets",
-		discarded_packets);
 
 	if (counter->count.other > 0) {
-		PRINTF_COUNT("  other (unknown) notification",
-			"  other (unknown) notifications", other);
+		PRINTF_COUNT("  other (unknown) message",
+			"  other (unknown) messages", other);
 	}
 
-	printf("%s%15" PRIu64 " notification%s (TOTAL)%s\n",
+	printf("%s%15" PRIu64 " message%s (TOTAL)%s\n",
 		bt_common_color_bold(), total, total == 1 ? "" : "s",
 		bt_common_color_reset());
 	counter->last_printed_total = total;
 }
 
 static
-void try_print_count(struct counter *counter, uint64_t notif_count)
+void try_print_count(struct counter *counter, uint64_t msg_count)
 {
 	if (counter->step == 0) {
 		/* No update */
 		return;
 	}
 
-	counter->at += notif_count;
+	counter->at += msg_count;
 
 	if (counter->at >= counter->step) {
 		counter->at = 0;
@@ -113,67 +103,69 @@ void try_print_last(struct counter *counter)
 
 void destroy_private_counter_data(struct counter *counter)
 {
-	bt_put(counter->notif_iter);
+	bt_self_component_port_input_message_iterator_put_ref(counter->msg_iter);
 	g_free(counter);
 }
 
-void counter_finalize(struct bt_private_component *component)
+BT_HIDDEN
+void counter_finalize(bt_self_component_sink *comp)
 {
 	struct counter *counter;
 
-	BT_ASSERT(component);
-	counter = bt_private_component_get_user_data(component);
+	BT_ASSERT(comp);
+	counter = bt_self_component_get_data(
+			bt_self_component_sink_as_self_component(comp));
 	BT_ASSERT(counter);
 	try_print_last(counter);
-	bt_put(counter->notif_iter);
+	bt_self_component_port_input_message_iterator_put_ref(counter->msg_iter);
 	g_free(counter);
 }
 
-enum bt_component_status counter_init(struct bt_private_component *component,
-		struct bt_value *params, UNUSED_VAR void *init_method_data)
+BT_HIDDEN
+enum bt_self_component_status counter_init(
+		bt_self_component_sink *component,
+		const bt_value *params,
+		UNUSED_VAR void *init_method_data)
 {
-	enum bt_component_status ret;
+	enum bt_self_component_status ret;
 	struct counter *counter = g_new0(struct counter, 1);
-	struct bt_value *step = NULL;
-	struct bt_value *hide_zero = NULL;
+	const bt_value *step = NULL;
+	const bt_value *hide_zero = NULL;
 
 	if (!counter) {
-		ret = BT_COMPONENT_STATUS_NOMEM;
-		goto end;
+		ret = BT_SELF_COMPONENT_STATUS_NOMEM;
+		goto error;
 	}
 
-	ret = bt_private_component_sink_add_input_private_port(component,
+	ret = bt_self_component_sink_add_input_port(component,
 		"in", NULL, NULL);
-	if (ret != BT_COMPONENT_STATUS_OK) {
-		goto end;
+	if (ret != BT_SELF_COMPONENT_STATUS_OK) {
+		goto error;
 	}
 
 	counter->last_printed_total = -1ULL;
 	counter->step = 1000;
-	step = bt_value_map_borrow(params, "step");
+	step = bt_value_map_borrow_entry_value_const(params, "step");
 	if (step && bt_value_is_integer(step)) {
 		int64_t val;
 
-		(void) bt_value_integer_get(step, &val);
-
+		val = bt_value_integer_get(step);
 		if (val >= 0) {
 			counter->step = (uint64_t) val;
 		}
 	}
 
-	hide_zero = bt_value_map_borrow(params, "hide-zero");
+	hide_zero = bt_value_map_borrow_entry_value_const(params, "hide-zero");
 	if (hide_zero && bt_value_is_bool(hide_zero)) {
 		bt_bool val;
 
-		(void) bt_value_bool_get(hide_zero, &val);
+		val = bt_value_bool_get(hide_zero);
 		counter->hide_zero = (bool) val;
 	}
 
-	ret = bt_private_component_set_user_data(component, counter);
-	if (ret != BT_COMPONENT_STATUS_OK) {
-		goto error;
-	}
-
+	bt_self_component_set_data(
+		bt_self_component_sink_as_self_component(component),
+		counter);
 	goto end;
 
 error:
@@ -183,127 +175,114 @@ end:
 	return ret;
 }
 
-void counter_port_connected(
-		struct bt_private_component *component,
-		struct bt_private_port *self_port,
-		struct bt_port *other_port)
+BT_HIDDEN
+enum bt_self_component_status counter_port_connected(
+		bt_self_component_sink *comp,
+		bt_self_component_port_input *self_port,
+		const bt_port_output *other_port)
 {
+	enum bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
 	struct counter *counter;
-	struct bt_notification_iterator *iterator;
-	struct bt_private_connection *connection;
-	enum bt_connection_status conn_status;
+	bt_self_component_port_input_message_iterator *iterator;
 
-	counter = bt_private_component_get_user_data(component);
+	counter = bt_self_component_get_data(
+		bt_self_component_sink_as_self_component(comp));
 	BT_ASSERT(counter);
-	connection = bt_private_port_get_private_connection(self_port);
-	BT_ASSERT(connection);
-	conn_status = bt_private_connection_create_notification_iterator(
-		connection, &iterator);
-	if (conn_status != BT_CONNECTION_STATUS_OK) {
-		counter->error = true;
+	iterator = bt_self_component_port_input_message_iterator_create(
+		self_port);
+	if (!iterator) {
+		status = BT_SELF_COMPONENT_STATUS_NOMEM;
 		goto end;
 	}
 
-	BT_MOVE(counter->notif_iter, iterator);
+	BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_MOVE_REF(
+		counter->msg_iter, iterator);
 
 end:
-	bt_put(connection);
+	return status;
 }
 
-enum bt_component_status counter_consume(struct bt_private_component *component)
+BT_HIDDEN
+enum bt_self_component_status counter_consume(
+		bt_self_component_sink *comp)
 {
-	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
+	enum bt_self_component_status ret = BT_SELF_COMPONENT_STATUS_OK;
 	struct counter *counter;
-	enum bt_notification_iterator_status it_ret;
-	int64_t count;
-	uint64_t notif_count;
-	bt_notification_array notifs;
+	enum bt_message_iterator_status it_ret;
+	uint64_t msg_count;
+	bt_message_array_const msgs;
 
-	counter = bt_private_component_get_user_data(component);
+	counter = bt_self_component_get_data(
+			bt_self_component_sink_as_self_component(comp));
 	BT_ASSERT(counter);
 
-	if (unlikely(counter->error)) {
-		ret = BT_COMPONENT_STATUS_ERROR;
-		goto end;
-	}
-
-	if (unlikely(!counter->notif_iter)) {
+	if (unlikely(!counter->msg_iter)) {
 		try_print_last(counter);
-		ret = BT_COMPONENT_STATUS_END;
+		ret = BT_SELF_COMPONENT_STATUS_END;
 		goto end;
 	}
 
-	/* Consume notifications */
-	it_ret = bt_private_connection_notification_iterator_next(
-		counter->notif_iter, &notifs, &notif_count);
+	/* Consume messages */
+	it_ret = bt_self_component_port_input_message_iterator_next(
+		counter->msg_iter, &msgs, &msg_count);
 	if (it_ret < 0) {
-		ret = BT_COMPONENT_STATUS_ERROR;
+		ret = BT_SELF_COMPONENT_STATUS_ERROR;
 		goto end;
 	}
 
 	switch (it_ret) {
-	case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
-		ret = BT_COMPONENT_STATUS_AGAIN;
-		goto end;
-	case BT_NOTIFICATION_ITERATOR_STATUS_END:
-		try_print_last(counter);
-		ret = BT_COMPONENT_STATUS_END;
-		goto end;
-	case BT_NOTIFICATION_ITERATOR_STATUS_OK:
+	case BT_MESSAGE_ITERATOR_STATUS_OK:
 	{
 		uint64_t i;
 
-		for (i = 0; i < notif_count; i++) {
-			struct bt_notification *notif = notifs[i];
+		for (i = 0; i < msg_count; i++) {
+			const bt_message *msg = msgs[i];
 
-			BT_ASSERT(notif);
-			switch (bt_notification_get_type(notif)) {
-			case BT_NOTIFICATION_TYPE_EVENT:
+			BT_ASSERT(msg);
+			switch (bt_message_get_type(msg)) {
+			case BT_MESSAGE_TYPE_EVENT:
 				counter->count.event++;
 				break;
-			case BT_NOTIFICATION_TYPE_INACTIVITY:
+			case BT_MESSAGE_TYPE_INACTIVITY:
 				counter->count.inactivity++;
 				break;
-			case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
+			case BT_MESSAGE_TYPE_STREAM_BEGINNING:
 				counter->count.stream_begin++;
 				break;
-			case BT_NOTIFICATION_TYPE_STREAM_END:
+			case BT_MESSAGE_TYPE_STREAM_END:
 				counter->count.stream_end++;
 				break;
-			case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+			case BT_MESSAGE_TYPE_PACKET_BEGINNING:
 				counter->count.packet_begin++;
 				break;
-			case BT_NOTIFICATION_TYPE_PACKET_END:
+			case BT_MESSAGE_TYPE_PACKET_END:
 				counter->count.packet_end++;
 				break;
-			case BT_NOTIFICATION_TYPE_DISCARDED_EVENTS:
-				counter->count.discarded_events_notifs++;
-				count = bt_notification_discarded_events_get_count(
-					notif);
-				if (count >= 0) {
-					counter->count.discarded_events += count;
-				}
-				break;
-			case BT_NOTIFICATION_TYPE_DISCARDED_PACKETS:
-				counter->count.discarded_packets_notifs++;
-				count = bt_notification_discarded_packets_get_count(
-					notif);
-				if (count >= 0) {
-					counter->count.discarded_packets += count;
-				}
-				break;
 			default:
 				counter->count.other++;
 			}
 
-			bt_put(notif);
+			bt_message_put_ref(msg);
 		}
+
+		ret = BT_SELF_COMPONENT_STATUS_OK;
+		break;
 	}
+	case BT_MESSAGE_ITERATOR_STATUS_AGAIN:
+		ret = BT_SELF_COMPONENT_STATUS_AGAIN;
+		goto end;
+	case BT_MESSAGE_ITERATOR_STATUS_END:
+		try_print_last(counter);
+		ret = BT_SELF_COMPONENT_STATUS_END;
+		goto end;
+	case BT_MESSAGE_ITERATOR_STATUS_NOMEM:
+		ret = BT_SELF_COMPONENT_STATUS_NOMEM;
+		goto end;
 	default:
 		break;
 	}
 
-	try_print_count(counter, notif_count);
+	try_print_count(counter, msg_count);
 
 end:
 	return ret;