Add stream_event_context accessors

Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>

diff --git a/formats/ctf/ir/event-fields.c b/formats/ctf/ir/event-fields.c
index f9288f2b98f58d963345d27299f9b7cd4dfcf711..8bc0557b5f6b2e799bd6eb72e33cda14215b057a 100644 (file)
--- a/formats/ctf/ir/event-fields.c
+++ b/formats/ctf/ir/event-fields.c
@@ -1006,8 +1006,6 @@ struct bt_ctf_field *bt_ctf_field_copy(struct bt_ctf_field *field)
                goto end;
        }
 
-       bt_ctf_field_type_get(field->type);
-       copy->type = field->type;
        ret = field_copy_funcs[type_id](field, copy);
        if (ret) {
                bt_ctf_field_put(copy);
@@ -1770,7 +1768,7 @@ int bt_ctf_field_integer_copy(struct bt_ctf_field *src,
        struct bt_ctf_field_integer *integer_src, *integer_dst;
 
        integer_src = container_of(src, struct bt_ctf_field_integer, parent);
-       integer_dst = container_of(src, struct bt_ctf_field_integer, parent);
+       integer_dst = container_of(dst, struct bt_ctf_field_integer, parent);
 
        memcpy(&integer_dst->definition, &integer_src->definition,
                sizeof(struct definition_integer));
@@ -1824,18 +1822,15 @@ static
 int bt_ctf_field_structure_copy(struct bt_ctf_field *src,
                struct bt_ctf_field *dst)
 {
-       int ret, i;
+       int ret = 0, i;
        struct bt_ctf_field_structure *struct_src, *struct_dst;
 
        struct_src = container_of(src, struct bt_ctf_field_structure, parent);
        struct_dst = container_of(dst, struct bt_ctf_field_structure, parent);
 
+       /* This field_name_to_index HT is owned by the structure field type */
        struct_dst->field_name_to_index = struct_src->field_name_to_index;
-       struct_dst->fields = g_ptr_array_sized_new(struct_src->fields->len);
-       if (!struct_dst->fields) {
-               ret = -1;
-               goto end;
-       }
+       g_ptr_array_set_size(struct_dst->fields, struct_src->fields->len);
 
        for (i = 0; i < struct_src->fields->len; i++) {
                struct bt_ctf_field *field_copy = bt_ctf_field_copy(
@@ -1845,7 +1840,7 @@ int bt_ctf_field_structure_copy(struct bt_ctf_field *src,
                        ret = -1;
                        goto end;
                }
-               g_ptr_array_add(struct_dst->fields, field_copy);
+               g_ptr_array_index(struct_dst->fields, i) = field_copy;
        }
 end:
        return ret;
@@ -1889,7 +1884,7 @@ int bt_ctf_field_array_copy(struct bt_ctf_field *src,
        array_src = container_of(src, struct bt_ctf_field_array, parent);
        array_dst = container_of(dst, struct bt_ctf_field_array, parent);
 
-       array_dst->elements = g_ptr_array_sized_new(array_src->elements->len);
+       g_ptr_array_set_size(array_dst->elements, array_src->elements->len);
        for (i = 0; i < array_src->elements->len; i++) {
                struct bt_ctf_field *field_copy = bt_ctf_field_copy(
                        g_ptr_array_index(array_src->elements, i));
@@ -1898,7 +1893,7 @@ int bt_ctf_field_array_copy(struct bt_ctf_field *src,
                        ret = -1;
                        goto end;
                }
-               g_ptr_array_add(array_dst->elements, field_copy);
+               g_ptr_array_index(array_dst->elements, i) = field_copy;
        }
 end:
        return ret;
@@ -1914,7 +1909,7 @@ int bt_ctf_field_sequence_copy(struct bt_ctf_field *src,
        sequence_src = container_of(src, struct bt_ctf_field_sequence, parent);
        sequence_dst = container_of(dst, struct bt_ctf_field_sequence, parent);
 
-       sequence_dst->elements = g_ptr_array_sized_new(
+       g_ptr_array_set_size(sequence_dst->elements,
                sequence_src->elements->len);
        for (i = 0; i < sequence_src->elements->len; i++) {
                struct bt_ctf_field *field_copy = bt_ctf_field_copy(
@@ -1924,7 +1919,7 @@ int bt_ctf_field_sequence_copy(struct bt_ctf_field *src,
                        ret = -1;
                        goto end;
                }
-               g_ptr_array_add(sequence_dst->elements, field_copy);
+               g_ptr_array_index(sequence_dst->elements, i) = field_copy;
        }
 end:
        return ret;

diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c
index b4eb294bf1bfe4ac0990110bf902e0cadb8db814..ce909bf4535696df0af262272d16159048519c9e 100644 (file)
--- a/formats/ctf/ir/stream.c
+++ b/formats/ctf/ir/stream.c
@@ -94,7 +94,17 @@ struct bt_ctf_stream *bt_ctf_stream_create(
        bt_ctf_stream_class_get(stream_class);
        bt_ctf_stream_class_freeze(stream_class);
        stream->events = g_ptr_array_new_with_free_func(
-               (GDestroyNotify)bt_ctf_event_put);
+               (GDestroyNotify) bt_ctf_event_put);
+       if (!stream->events) {
+               goto error_destroy;
+       }
+       if (stream_class->event_context_type) {
+               stream->event_contexts = g_ptr_array_new_with_free_func(
+                       (GDestroyNotify) bt_ctf_field_put);
+               if (!stream->event_contexts) {
+                       goto error_destroy;
+               }
+       }
 end:
        return stream;
 error_destroy:
@@ -278,6 +288,21 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream,
                goto end;
        }
 
+       /* Sample the current stream event context by copying it */
+       if (stream->event_context) {
+               /* Make sure the event context's payload is set */
+               ret = bt_ctf_field_validate(stream->event_context);
+               if (ret) {
+                       goto end;
+               }
+
+               event_context_copy = bt_ctf_field_copy(stream->event_context);
+               if (!event_context_copy) {
+                       ret = -1;
+                       goto end;
+               }
+       }
+
        timestamp = bt_ctf_clock_get_time(stream->stream_class->clock);
        ret = bt_ctf_event_set_timestamp(event, timestamp);
        if (ret) {
@@ -285,7 +310,11 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream,
        }
 
        bt_ctf_event_get(event);
+       /* Save the new event along with its associated stream event context */
        g_ptr_array_add(stream->events, event);
+       if (event_context_copy) {
+               g_ptr_array_add(stream->event_contexts, event_context_copy);
+       }
 end:
        return ret;
 }
@@ -332,6 +361,50 @@ end:
        return ret;
 }
 
+struct bt_ctf_field *bt_ctf_stream_get_event_context(
+               struct bt_ctf_stream *stream)
+{
+       struct bt_ctf_field *event_context = NULL;
+
+       if (!stream) {
+               goto end;
+       }
+
+       event_context = stream->event_context;
+       if (event_context) {
+               bt_ctf_field_get(event_context);
+       }
+end:
+       return event_context;
+}
+
+int bt_ctf_stream_set_event_context(struct bt_ctf_stream *stream,
+               struct bt_ctf_field *field)
+{
+       int ret = 0;
+       struct bt_ctf_field_type *field_type = NULL;
+
+       if (!stream || !field) {
+               ret = -1;
+               goto end;
+       }
+
+       field_type = bt_ctf_field_get_type(field);
+       if (field_type != stream->stream_class->event_context_type) {
+               ret = -1;
+               goto end;
+       }
+
+       bt_ctf_field_get(field);
+       bt_ctf_field_put(stream->event_context);
+       stream->event_context = field;
+end:
+       if (field_type) {
+               bt_ctf_field_type_put(field_type);
+       }
+       return ret;
+}
+
 int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
 {
        int ret = 0;
@@ -447,6 +520,16 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                        goto end;
                }
 
+               /* Write stream event context */
+               if (stream->event_contexts) {
+                       ret = bt_ctf_field_serialize(
+                               g_ptr_array_index(stream->event_contexts, i),
+                               &stream->pos);
+                       if (ret) {
+                               goto end;
+                       }
+               }
+
                /* Write event content */
                ret = bt_ctf_event_serialize(event, &stream->pos);
                if (ret) {
@@ -480,6 +563,9 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
        }
 
        g_ptr_array_set_size(stream->events, 0);
+       if (stream->event_contexts) {
+               g_ptr_array_set_size(stream->event_contexts, 0);
+       }
        stream->flushed_packet_count++;
 end:
        bt_ctf_field_put(integer);
@@ -525,9 +611,15 @@ void bt_ctf_stream_destroy(struct bt_ctf_ref *ref)
        if (stream->events) {
                g_ptr_array_free(stream->events, TRUE);
        }
+       if (stream->event_contexts) {
+               g_ptr_array_free(stream->event_contexts, TRUE);
+       }
        if (stream->packet_context) {
                bt_ctf_field_put(stream->packet_context);
        }
+       if (stream->event_context) {
+               bt_ctf_field_put(stream->event_context);
+       }
        g_free(stream);
 }
 

diff --git a/include/babeltrace/ctf-ir/stream-internal.h b/include/babeltrace/ctf-ir/stream-internal.h
index 0bd39ba49964b368dd78e0ca2c88fed64e9a1be3..cc421d225f3e9d625ba44c1eb506cd13e7acbcc4 100644 (file)
--- a/include/babeltrace/ctf-ir/stream-internal.h
+++ b/include/babeltrace/ctf-ir/stream-internal.h
@@ -50,6 +50,8 @@ struct bt_ctf_stream {
        struct flush_callback flush;
        /* Array of pointers to bt_ctf_event for the current packet */
        GPtrArray *events;
+       /* Array of pointers to bt_ctf_field associated with each event*/
+       GPtrArray *event_contexts;
        struct ctf_stream_pos pos;
        unsigned int flushed_packet_count;
        struct bt_ctf_field *packet_context;