X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=inline;f=formats%2Fctf%2Fir%2Fevent.c;h=c553f7a707eff35e4d4a024a91128a675583215b;hb=f3985ab106d89d8e764c1a8dd0c8bda09b755d10;hp=82ed0d947528546d436b3c8566116603f42c103e;hpb=272df73edf74c3d8d6cbbf6450258fdbc9fbad36;p=babeltrace.git

diff --git a/formats/ctf/ir/event.c b/formats/ctf/ir/event.c
index 82ed0d94..c553f7a7 100644
--- a/formats/ctf/ir/event.c
+++ b/formats/ctf/ir/event.c
@@ -28,13 +28,18 @@
 
 #include <babeltrace/ctf-ir/fields-internal.h>
 #include <babeltrace/ctf-ir/field-types-internal.h>
+#include <babeltrace/ctf-ir/clock-class.h>
 #include <babeltrace/ctf-ir/event-internal.h>
 #include <babeltrace/ctf-ir/event-class.h>
 #include <babeltrace/ctf-ir/event-class-internal.h>
 #include <babeltrace/ctf-ir/stream-class.h>
 #include <babeltrace/ctf-ir/stream-class-internal.h>
+#include <babeltrace/ctf-ir/stream-internal.h>
+#include <babeltrace/ctf-ir/packet.h>
+#include <babeltrace/ctf-ir/packet-internal.h>
 #include <babeltrace/ctf-ir/trace-internal.h>
 #include <babeltrace/ctf-ir/validation-internal.h>
+#include <babeltrace/ctf-ir/packet-internal.h>
 #include <babeltrace/ctf-ir/utils.h>
 #include <babeltrace/ref.h>
 #include <babeltrace/ctf-ir/attributes-internal.h>
@@ -42,8 +47,6 @@
 
 static
 void bt_ctf_event_destroy(struct bt_object *obj);
-static
-int set_integer_field_value(struct bt_ctf_field *field, uint64_t value);
 
 struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
 {
@@ -61,6 +64,7 @@ struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
 	struct bt_ctf_field_type *event_context_type = NULL;
 	struct bt_ctf_field_type *event_payload_type = NULL;
 	struct bt_ctf_field *event_header = NULL;
+	struct bt_ctf_field *stream_event_context = NULL;
 	struct bt_ctf_field *event_context = NULL;
 	struct bt_ctf_field *event_payload = NULL;
 	struct bt_value *environment = NULL;
@@ -115,7 +119,6 @@ struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
 	BT_PUT(stream_event_ctx_type);
 	BT_PUT(event_context_type);
 	BT_PUT(event_payload_type);
-
 	if (ret) {
 		/*
 		 * This means something went wrong during the validation
@@ -151,13 +154,22 @@ struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
 	 * lifetime.
 	 */
 	event->event_class = bt_get(event_class);
+	event->clock_values = g_hash_table_new_full(g_direct_hash,
+			g_direct_equal, bt_put, bt_put);
 	event_header =
 		bt_ctf_field_create(validation_output.event_header_type);
-
 	if (!event_header) {
 		goto error;
 	}
 
+	if (validation_output.stream_event_ctx_type) {
+		stream_event_context = bt_ctf_field_create(
+			validation_output.stream_event_ctx_type);
+		if (!stream_event_context) {
+			goto error;
+		}
+	}
+
 	if (validation_output.event_context_type) {
 		event_context = bt_ctf_field_create(
 			validation_output.event_context_type);
@@ -183,6 +195,7 @@ struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
 	bt_ctf_validation_replace_types(trace, stream_class,
 		event_class, &validation_output, validation_flags);
 	BT_MOVE(event->event_header, event_header);
+	BT_MOVE(event->stream_event_context, stream_event_context);
 	BT_MOVE(event->context_payload, event_context);
 	BT_MOVE(event->fields_payload, event_payload);
 
@@ -216,6 +229,7 @@ error:
 	BT_PUT(stream_class);
 	BT_PUT(trace);
 	BT_PUT(event_header);
+	BT_PUT(stream_event_context);
 	BT_PUT(event_context);
 	BT_PUT(event_payload);
 	assert(!packet_header_type);
@@ -244,40 +258,27 @@ end:
 
 struct bt_ctf_stream *bt_ctf_event_get_stream(struct bt_ctf_event *event)
 {
-	return (struct bt_ctf_stream *) bt_object_get_parent(event);
-}
-
-struct bt_ctf_clock *bt_ctf_event_get_clock(struct bt_ctf_event *event)
-{
-	struct bt_ctf_clock *clock = NULL;
-	struct bt_ctf_event_class *event_class;
-	struct bt_ctf_stream_class *stream_class;
+	struct bt_ctf_stream *stream = NULL;
 
 	if (!event) {
 		goto end;
 	}
 
-	event_class = bt_ctf_event_get_class(event);
-	if (!event_class) {
-		goto end;
-	}
-
-	stream_class = bt_ctf_event_class_get_stream_class(event_class);
-	if (!stream_class) {
-		goto error_put_event_class;
-	}
-
-	clock = bt_ctf_stream_class_get_clock(stream_class);
-	if (!clock) {
-		goto error_put_stream_class;
+	/*
+	 * If the event has a parent, then this is its (writer) stream.
+	 * If the event has no parent, then if it has a packet, this
+	 * is its (non-writer) stream.
+	 */
+	if (event->base.parent) {
+		stream = (struct bt_ctf_stream *) bt_object_get_parent(event);
+	} else {
+		if (event->packet) {
+			stream = bt_get(event->packet->stream);
+		}
 	}
 
-error_put_stream_class:
-	bt_put(stream_class);
-error_put_event_class:
-	bt_put(event_class);
 end:
-	return clock;
+	return stream;
 }
 
 int bt_ctf_event_set_payload(struct bt_ctf_event *event,
@@ -286,7 +287,7 @@ int bt_ctf_event_set_payload(struct bt_ctf_event *event,
 {
 	int ret = 0;
 
-	if (!event || !payload) {
+	if (!event || !payload || event->frozen) {
 		ret = -1;
 		goto end;
 	}
@@ -334,7 +335,7 @@ int bt_ctf_event_set_payload_field(struct bt_ctf_event *event,
 	int ret = 0;
 	struct bt_ctf_field_type *payload_type = NULL;
 
-	if (!event || !payload) {
+	if (!event || event->frozen) {
 		ret = -1;
 		goto end;
 	}
@@ -351,10 +352,8 @@ int bt_ctf_event_set_payload_field(struct bt_ctf_event *event,
 		goto end;
 	}
 
-	bt_get(payload);
 	bt_put(event->fields_payload);
-	event->fields_payload = payload;
-
+	event->fields_payload = bt_get(payload);
 end:
 	bt_put(payload_type);
 	return ret;
@@ -417,13 +416,13 @@ int bt_ctf_event_set_header(struct bt_ctf_event *event,
 	struct bt_ctf_field_type *field_type = NULL;
 	struct bt_ctf_stream_class *stream_class = NULL;
 
-	if (!event || !header) {
+	if (!event || event->frozen) {
 		ret = -1;
 		goto end;
 	}
 
 	stream_class = (struct bt_ctf_stream_class *) bt_object_get_parent(
-		event->event_class);
+			event->event_class);
 	/*
 	 * Ensure the provided header's type matches the one registered to the
 	 * stream class.
@@ -435,9 +434,8 @@ int bt_ctf_event_set_header(struct bt_ctf_event *event,
 		goto end;
 	}
 
-	bt_get(header);
 	bt_put(event->event_header);
-	event->event_header = header;
+	event->event_header = bt_get(header);
 end:
 	bt_put(stream_class);
 	bt_put(field_type);
@@ -465,7 +463,7 @@ int bt_ctf_event_set_event_context(struct bt_ctf_event *event,
 	int ret = 0;
 	struct bt_ctf_field_type *field_type = NULL;
 
-	if (!event || !context) {
+	if (!event || event->frozen) {
 		ret = -1;
 		goto end;
 	}
@@ -477,14 +475,61 @@ int bt_ctf_event_set_event_context(struct bt_ctf_event *event,
 		goto end;
 	}
 
-	bt_get(context);
 	bt_put(event->context_payload);
-	event->context_payload = context;
+	event->context_payload = bt_get(context);
 end:
 	bt_put(field_type);
 	return ret;
 }
 
+struct bt_ctf_field *bt_ctf_event_get_stream_event_context(
+		struct bt_ctf_event *event)
+{
+	struct bt_ctf_field *stream_event_context = NULL;
+
+	if (!event || !event->stream_event_context) {
+		goto end;
+	}
+
+	stream_event_context = event->stream_event_context;
+end:
+	return bt_get(stream_event_context);
+}
+
+int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event,
+		struct bt_ctf_field *stream_event_context)
+{
+	int ret = 0;
+	struct bt_ctf_field_type *field_type = NULL;
+	struct bt_ctf_stream_class *stream_class = NULL;
+
+	if (!event || event->frozen) {
+		ret = -1;
+		goto end;
+	}
+
+	stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
+	/*
+	 * We should not have been able to create the event without associating
+	 * the event class to a stream class.
+	 */
+	assert(stream_class);
+
+	field_type = bt_ctf_field_get_type(stream_event_context);
+	if (bt_ctf_field_type_compare(field_type,
+			stream_class->event_context_type)) {
+		ret = -1;
+		goto end;
+	}
+
+	bt_get(stream_event_context);
+	BT_MOVE(event->stream_event_context, stream_event_context);
+end:
+	BT_PUT(stream_class);
+	bt_put(field_type);
+	return ret;
+}
+
 void bt_ctf_event_get(struct bt_ctf_event *event)
 {
 	bt_get(event);
@@ -508,53 +553,47 @@ void bt_ctf_event_destroy(struct bt_object *obj)
 		 */
 		bt_put(event->event_class);
 	}
+	g_hash_table_destroy(event->clock_values);
 	bt_put(event->event_header);
+	bt_put(event->stream_event_context);
 	bt_put(event->context_payload);
 	bt_put(event->fields_payload);
+	bt_put(event->packet);
 	g_free(event);
 }
 
-static
-int set_integer_field_value(struct bt_ctf_field* field, uint64_t value)
+struct bt_ctf_clock_value *bt_ctf_event_get_clock_value(
+		struct bt_ctf_event *event, struct bt_ctf_clock_class *clock_class)
 {
-	int ret = 0;
-	struct bt_ctf_field_type *field_type = NULL;
+	struct bt_ctf_clock_value *clock_value = NULL;
 
-	if (!field) {
-		ret = -1;
+	if (!event || !clock_class) {
 		goto end;
 	}
 
-	if (!bt_ctf_field_validate(field)) {
-		/* Payload already set, skip! (not an error) */
+	clock_value = g_hash_table_lookup(event->clock_values, clock_class);
+	if (!clock_value) {
 		goto end;
 	}
 
-	field_type = bt_ctf_field_get_type(field);
-	assert(field_type);
+	bt_get(clock_value);
+end:
+	return clock_value;
+}
+
+int bt_ctf_event_set_clock_value(struct bt_ctf_event *event,
+		struct bt_ctf_clock_value *value)
+{
+	int ret = 0;
 
-	if (bt_ctf_field_type_get_type_id(field_type) !=
-			BT_CTF_TYPE_ID_INTEGER) {
-		/* Not an integer and the value is unset, error. */
+	if (!event || !value || event->frozen) {
 		ret = -1;
 		goto end;
 	}
 
-	if (bt_ctf_field_type_integer_get_signed(field_type)) {
-		ret = bt_ctf_field_signed_integer_set_value(field, (int64_t) value);
-		if (ret) {
-			/* Value is out of range, error. */
-			goto end;
-		}
-	} else {
-		ret = bt_ctf_field_unsigned_integer_set_value(field, value);
-		if (ret) {
-			/* Value is out of range, error. */
-			goto end;
-		}
-	}
+	g_hash_table_insert(event->clock_values,
+		bt_ctf_clock_value_get_class(value), bt_get(value));
 end:
-	bt_put(field_type);
 	return ret;
 }
 
@@ -563,6 +602,7 @@ int bt_ctf_event_validate(struct bt_ctf_event *event)
 {
 	/* Make sure each field's payload has been set */
 	int ret;
+	struct bt_ctf_stream_class *stream_class = NULL;
 
 	assert(event);
 	ret = bt_ctf_field_validate(event->event_header);
@@ -570,6 +610,19 @@ int bt_ctf_event_validate(struct bt_ctf_event *event)
 		goto end;
 	}
 
+	stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
+	/*
+	 * We should not have been able to create the event without associating
+	 * the event class to a stream class.
+	 */
+	assert(stream_class);
+	if (stream_class->event_context_type) {
+		ret = bt_ctf_field_validate(event->stream_event_context);
+		if (ret) {
+			goto end;
+		}
+	}
+
 	ret = bt_ctf_field_validate(event->fields_payload);
 	if (ret) {
 		goto end;
@@ -579,6 +632,7 @@ int bt_ctf_event_validate(struct bt_ctf_event *event)
 		ret = bt_ctf_field_validate(event->context_payload);
 	}
 end:
+	bt_put(stream_class);
 	return ret;
 }
 
@@ -607,104 +661,76 @@ end:
 	return ret;
 }
 
-BT_HIDDEN
-int bt_ctf_event_populate_event_header(struct bt_ctf_event *event)
+struct bt_ctf_packet *bt_ctf_event_get_packet(struct bt_ctf_event *event)
 {
-	int ret = 0;
-	struct bt_ctf_field *id_field = NULL, *timestamp_field = NULL;
+	struct bt_ctf_packet *packet = NULL;
 
-	if (!event) {
-		ret = -1;
+	if (!event || !event->packet) {
 		goto end;
 	}
 
-	id_field = bt_ctf_field_structure_get_field(event->event_header, "id");
-	if (id_field) {
-		ret = set_integer_field_value(id_field,
-			(uint64_t) bt_ctf_event_class_get_id(
-				event->event_class));
-		if (ret) {
-			goto end;
-		}
-	}
-
-	timestamp_field = bt_ctf_field_structure_get_field(event->event_header,
-		"timestamp");
-	if (timestamp_field) {
-		struct bt_ctf_field_type *timestamp_field_type =
-			bt_ctf_field_get_type(timestamp_field);
-		struct bt_ctf_clock *mapped_clock;
-
-		assert(timestamp_field_type);
-		mapped_clock = bt_ctf_field_type_integer_get_mapped_clock(
-			timestamp_field_type);
-		bt_put(timestamp_field_type);
-		if (mapped_clock) {
-			int64_t timestamp;
-
-			ret = bt_ctf_clock_get_time(mapped_clock, &timestamp);
-			bt_put(mapped_clock);
-			if (ret) {
-				goto end;
-			}
-
-			ret = set_integer_field_value(timestamp_field,
-				timestamp);
-			if (ret) {
-				goto end;
-			}
-		}
-	}
+	packet = bt_get(event->packet);
 end:
-	bt_put(id_field);
-	bt_put(timestamp_field);
-	return ret;
+	return packet;
 }
 
-struct bt_ctf_event *bt_ctf_event_copy(struct bt_ctf_event *event)
+int bt_ctf_event_set_packet(struct bt_ctf_event *event,
+		struct bt_ctf_packet *packet)
 {
-	struct bt_ctf_event *copy = NULL;
-
-	if (!event) {
-		goto error;
-	}
+	struct bt_ctf_stream_class *event_stream_class = NULL;
+	struct bt_ctf_stream_class *packet_stream_class = NULL;
+	struct bt_ctf_stream *stream = NULL;
+	int ret = 0;
 
-	copy = g_new0(struct bt_ctf_event, 1);
-	if (!copy) {
-		goto error;
+	if (!event || !packet || event->frozen) {
+		ret = -1;
+		goto end;
 	}
 
-	bt_object_init(copy, bt_ctf_event_destroy);
-	copy->event_class = bt_get(event->event_class);
-
-	if (event->event_header) {
-		copy->event_header = bt_ctf_field_copy(event->event_header);
-
-		if (!copy->event_header) {
-			goto error;
+	/*
+	 * Make sure the new packet was created by this event's
+	 * stream, if it is set.
+	 */
+	stream = bt_ctf_event_get_stream(event);
+	if (stream) {
+		if (packet->stream != stream) {
+			ret = -1;
+			goto end;
 		}
-	}
+	} else {
+		event_stream_class =
+			bt_ctf_event_class_get_stream_class(event->event_class);
+		packet_stream_class =
+			bt_ctf_stream_get_class(packet->stream);
 
-	if (event->context_payload) {
-		copy->context_payload = bt_ctf_field_copy(
-			event->context_payload);
+		assert(event_stream_class);
+		assert(packet_stream_class);
 
-		if (!copy->context_payload) {
-			goto error;
+		if (event_stream_class != packet_stream_class) {
+			ret = -1;
+			goto end;
 		}
 	}
 
-	if (event->fields_payload) {
-		copy->fields_payload = bt_ctf_field_copy(event->fields_payload);
+	bt_get(packet);
+	BT_MOVE(event->packet, packet);
 
-		if (!copy->fields_payload) {
-			goto error;
-		}
-	}
+end:
+	BT_PUT(stream);
+	BT_PUT(event_stream_class);
+	BT_PUT(packet_stream_class);
 
-	return copy;
+	return ret;
+}
 
-error:
-	BT_PUT(copy);
-	return copy;
+BT_HIDDEN
+void bt_ctf_event_freeze(struct bt_ctf_event *event)
+{
+	assert(event);
+	bt_ctf_packet_freeze(event->packet);
+	bt_ctf_field_freeze(event->event_header);
+	bt_ctf_field_freeze(event->stream_event_context);
+	bt_ctf_field_freeze(event->context_payload);
+	bt_ctf_field_freeze(event->fields_payload);
+	event->frozen = 1;
 }