lib: standardize variant field option function names

[babeltrace.git] / src / plugins / ctf / fs-sink / fs-sink-stream.c

diff --git a/src/plugins/ctf/fs-sink/fs-sink-stream.c b/src/plugins/ctf/fs-sink/fs-sink-stream.c
index 28f70e4f99d36a5c7a6b2b091afebc11d4fb4541..93807d749a07906c5ee7cd476cad5dc614bb3cbd 100644 (file)
--- a/src/plugins/ctf/fs-sink/fs-sink-stream.c
+++ b/src/plugins/ctf/fs-sink/fs-sink-stream.c
@@ -212,6 +212,20 @@ int write_bool_field(struct fs_sink_stream *stream,
                fc->base.base.alignment, fc->base.size, BYTE_ORDER);
 }
 
+static inline
+int write_bit_array_field(struct fs_sink_stream *stream,
+               struct fs_sink_ctf_field_class_bit_array *fc,
+               const bt_field *field)
+{
+       /*
+        * CTF 1.8 has no bit array field class type, so this component
+        * translates this bit array field to an unsigned integer field.
+        */
+       return bt_ctfser_write_unsigned_int(&stream->ctfser,
+               bt_field_bit_array_get_value_as_integer(field),
+               fc->base.alignment, fc->size, BYTE_ORDER);
+}
+
 static inline
 int write_int_field(struct fs_sink_stream *stream,
                struct fs_sink_ctf_field_class_int *fc, const bt_field *field)
@@ -236,12 +250,14 @@ int write_float_field(struct fs_sink_stream *stream,
                struct fs_sink_ctf_field_class_float *fc, const bt_field *field)
 {
        int ret;
-       double val = bt_field_real_get_value(field);
+       double val;
 
        if (fc->base.size == 32) {
+               val = (double) bt_field_real_single_precision_get_value(field);
                ret = bt_ctfser_write_float32(&stream->ctfser, val,
                        fc->base.base.alignment, BYTE_ORDER);
        } else {
+               val = bt_field_real_double_precision_get_value(field);
                ret = bt_ctfser_write_float64(&stream->ctfser, val,
                        fc->base.base.alignment, BYTE_ORDER);
        }
@@ -335,13 +351,47 @@ end:
        return ret;
 }
 
+static inline
+int write_option_field(struct fs_sink_stream *stream,
+               struct fs_sink_ctf_field_class_option *fc,
+               const bt_field *field)
+{
+       int ret;
+       const bt_field *content_field =
+               bt_field_option_borrow_field_const(field);
+
+       ret = bt_ctfser_write_unsigned_int(&stream->ctfser,
+               content_field ? 1 : 0, 8, 8, BYTE_ORDER);
+       if (G_UNLIKELY(ret)) {
+               goto end;
+       }
+
+       /*
+        * CTF 1.8 has no option field class type, so this component
+        * translates the option field class to a variant field class
+        * where the options are:
+        *
+        * * An empty structure field class (field occupies 0 bits).
+        * * The optional field class itself.
+        *
+        * If `content_field` is `NULL`, do not write anything (empty
+        * structure).
+        */
+       if (content_field) {
+               ret = write_field(stream, fc->content_fc, content_field);
+       }
+
+end:
+       return ret;
+}
+
 static inline
 int write_variant_field(struct fs_sink_stream *stream,
                struct fs_sink_ctf_field_class_variant *fc,
                const bt_field *field)
 {
        uint64_t opt_index =
-               bt_field_variant_get_selected_option_field_index(field);
+               bt_field_variant_get_selected_option_index(field);
        int ret;
 
        if (fc->tag_is_before) {
@@ -371,6 +421,9 @@ int write_field(struct fs_sink_stream *stream,
        case FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL:
                ret = write_bool_field(stream, (void *) fc, field);
                break;
+       case FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY:
+               ret = write_bit_array_field(stream, (void *) fc, field);
+               break;
        case FS_SINK_CTF_FIELD_CLASS_TYPE_INT:
                ret = write_int_field(stream, (void *) fc, field);
                break;
@@ -389,11 +442,14 @@ int write_field(struct fs_sink_stream *stream,
        case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE:
                ret = write_sequence_field(stream, (void *) fc, field);
                break;
+       case FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION:
+               ret = write_option_field(stream, (void *) fc, field);
+               break;
        case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT:
                ret = write_variant_field(stream, (void *) fc, field);
                break;
        default:
-               abort();
+               bt_common_abort();
        }
 
        return ret;
@@ -414,7 +470,7 @@ int write_event_header(struct fs_sink_stream *stream,
 
        /* Time */
        if (stream->sc->default_clock_class) {
-               BT_ASSERT(cs);
+               BT_ASSERT_DBG(cs);
                ret = bt_ctfser_write_byte_aligned_unsigned_int(&stream->ctfser,
                        bt_clock_snapshot_get_value(cs), 8, 64, BYTE_ORDER);
                if (G_UNLIKELY(ret)) {
@@ -443,7 +499,7 @@ int fs_sink_stream_write_event(struct fs_sink_stream *stream,
        /* Common context */
        if (stream->sc->event_common_context_fc) {
                field = bt_event_borrow_common_context_field_const(event);
-               BT_ASSERT(field);
+               BT_ASSERT_DBG(field);
                ret = write_struct_field(stream,
                        (void *) stream->sc->event_common_context_fc,
                        field, true);
@@ -455,7 +511,7 @@ int fs_sink_stream_write_event(struct fs_sink_stream *stream,
        /* Specific context */
        if (ec->spec_context_fc) {
                field = bt_event_borrow_specific_context_field_const(event);
-               BT_ASSERT(field);
+               BT_ASSERT_DBG(field);
                ret = write_struct_field(stream, (void *) ec->spec_context_fc,
                        field, true);
                if (G_UNLIKELY(ret)) {
@@ -466,7 +522,7 @@ int fs_sink_stream_write_event(struct fs_sink_stream *stream,
        /* Specific context */
        if (ec->payload_fc) {
                field = bt_event_borrow_payload_field_const(event);
-               BT_ASSERT(field);
+               BT_ASSERT_DBG(field);
                ret = write_struct_field(stream, (void *) ec->payload_fc,
                        field, true);
                if (G_UNLIKELY(ret)) {