ctf.fs: bt_ctf_notif_iter_create(): assert() that all medops exist

[babeltrace.git] / formats / ctf / ir / fields.c

diff --git a/formats/ctf/ir/fields.c b/formats/ctf/ir/fields.c
index 1a2a2c7f5d95b8a8cae94b9d7dc312bf205abc74..0ad52a020dc05a79095c506ca13941e016187190 100644 (file)
--- a/formats/ctf/ir/fields.c
+++ b/formats/ctf/ir/fields.c
@@ -866,15 +866,14 @@ end:
        return container;
 }
 
-const char *bt_ctf_field_enumeration_get_mapping_name(
-       struct bt_ctf_field *field)
+struct bt_ctf_field_type_enumeration_mapping_iterator *
+bt_ctf_field_enumeration_get_mappings(struct bt_ctf_field *field)
 {
        int ret;
-       const char *name = NULL;
        struct bt_ctf_field *container = NULL;
        struct bt_ctf_field_type *container_type = NULL;
        struct bt_ctf_field_type_integer *integer_type = NULL;
-       struct bt_ctf_field_type_enumeration *enumeration_type = NULL;
+       struct bt_ctf_field_type_enumeration_mapping_iterator *iter = NULL;
 
        container = bt_ctf_field_enumeration_get_container(field);
        if (!container) {
@@ -888,29 +887,27 @@ const char *bt_ctf_field_enumeration_get_mapping_name(
 
        integer_type = container_of(container_type,
                struct bt_ctf_field_type_integer, parent);
-       enumeration_type = container_of(field->type,
-               struct bt_ctf_field_type_enumeration, parent);
 
        if (!integer_type->declaration.signedness) {
                uint64_t value;
+
                ret = bt_ctf_field_unsigned_integer_get_value(container,
                      &value);
                if (ret) {
                        goto error_put_container_type;
                }
-
-               name = bt_ctf_field_type_enumeration_get_mapping_name_unsigned(
-                       enumeration_type, value);
+               iter = bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value(
+                               field->type, value);
        } else {
                int64_t value;
+
                ret = bt_ctf_field_signed_integer_get_value(container,
                      &value);
                if (ret) {
                        goto error_put_container_type;
                }
-
-               name = bt_ctf_field_type_enumeration_get_mapping_name_signed(
-                       enumeration_type, value);
+               iter = bt_ctf_field_type_enumeration_find_mappings_by_signed_value(
+                               field->type, value);
        }
 
 error_put_container_type:
@@ -918,7 +915,7 @@ error_put_container_type:
 error_put_container:
        bt_put(container);
 end:
-       return name;
+       return iter;
 }
 
 int bt_ctf_field_signed_integer_get_value(struct bt_ctf_field *field,
@@ -1906,6 +1903,10 @@ int bt_ctf_field_integer_serialize(struct bt_ctf_field *field,
        struct bt_ctf_field_integer *integer = container_of(field,
                struct bt_ctf_field_integer, parent);
 
+       if (!bt_ctf_field_generic_is_set(field)) {
+               ret = -1;
+               goto end;
+       }
 retry:
        ret = ctf_integer_write(&pos->parent, &integer->definition.p);
        if (ret == -EFAULT) {
@@ -1941,6 +1942,10 @@ int bt_ctf_field_floating_point_serialize(struct bt_ctf_field *field,
        struct bt_ctf_field_floating_point *floating_point = container_of(field,
                struct bt_ctf_field_floating_point, parent);
 
+       if (!bt_ctf_field_generic_is_set(field)) {
+               ret = -1;
+               goto end;
+       }
 retry:
        ret = ctf_float_write(&pos->parent, &floating_point->definition.p);
        if (ret == -EFAULT) {
@@ -1982,20 +1987,20 @@ int bt_ctf_field_structure_serialize(struct bt_ctf_field *field,
        }
 
        for (i = 0; i < structure->fields->len; i++) {
-               struct bt_ctf_field *field = g_ptr_array_index(
+               struct bt_ctf_field *member = g_ptr_array_index(
                        structure->fields, i);
 
-               ret = bt_ctf_field_serialize(field, pos);
+               ret = bt_ctf_field_serialize(member, pos);
                if (ret) {
                        const char *name;
-                       struct bt_ctf_field_type *field_type =
+                       struct bt_ctf_field_type *structure_type =
                                        bt_ctf_field_get_type(field);
 
-                       (void) bt_ctf_field_type_structure_get_field(field_type,
-                                       &name, NULL, i);
+                       (void) bt_ctf_field_type_structure_get_field(
+                                       structure_type, &name, NULL, i);
                        fprintf(stderr, "Field %s failed to serialize\n",
                                        name ? name : "NULL");
-                       bt_put(field_type);
+                       bt_put(structure_type);
                        break;
                }
        }