lib, plugins: use bt_field_class_type_is() where suitable
authorPhilippe Proulx <eeppeliteloop@gmail.com>
Thu, 10 Oct 2019 21:35:13 +0000 (17:35 -0400)
committerPhilippe Proulx <eeppeliteloop@gmail.com>
Tue, 15 Oct 2019 19:59:10 +0000 (15:59 -0400)
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I0cf5c50ab1a0a526678a50a34b2401ac16094eb0
Reviewed-on: https://review.lttng.org/c/babeltrace/+/2172
Tested-by: jenkins <jenkins@lttng.org>
Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
src/lib/trace-ir/field-class.c
src/lib/trace-ir/resolve-field-path.c
src/plugins/ctf/common/msg-iter/msg-iter.c
src/plugins/ctf/fs-sink/fs-sink-ctf-meta.h
src/plugins/ctf/fs-sink/translate-ctf-ir-to-tsdl.c
src/plugins/ctf/fs-sink/translate-trace-ir-to-ctf-ir.c
src/plugins/lttng-utils/debug-info/trace-ir-data-copy.c
src/plugins/lttng-utils/debug-info/trace-ir-metadata-field-class-copy.c
src/plugins/text/details/write.c
src/plugins/text/pretty/print.c

index 62c5afa9ad1cdd0e0ae10e221e23e1954122bcf1..ee1037cb79c23d658c0e20c1783cfb6f3246b72a 100644 (file)
@@ -1478,8 +1478,8 @@ struct bt_field_class *bt_field_class_variant_create(
                        goto error;
                }
 
-               if (selector_fc->type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
-                               selector_fc->type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
+               if (bt_field_class_type_is(selector_fc->type,
+                               BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER)) {
                        fc_type = BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD;
                } else {
                        fc_type = BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD;
@@ -2115,12 +2115,9 @@ void _bt_field_class_freeze(const struct bt_field_class *c_fc)
        bt_value_freeze(fc->user_attributes);
        fc->frozen = true;
 
-       switch (fc->type) {
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       if (fc->type == BT_FIELD_CLASS_TYPE_STRUCTURE ||
+                       bt_field_class_type_is(fc->type,
+                               BT_FIELD_CLASS_TYPE_VARIANT)) {
                struct bt_field_class_named_field_class_container *container_fc =
                        (void *) fc;
                uint64_t i;
@@ -2129,11 +2126,6 @@ void _bt_field_class_freeze(const struct bt_field_class *c_fc)
                        bt_named_field_class_freeze(
                                container_fc->named_fcs->pdata[i]);
                }
-
-               break;
-       }
-       default:
-               break;
        }
 }
 
@@ -2158,12 +2150,9 @@ void bt_field_class_make_part_of_trace_class(const struct bt_field_class *c_fc)
                "Field class is already part of a trace: %!+F", fc);
        fc->part_of_trace_class = true;
 
-       switch (fc->type) {
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       if (fc->type == BT_FIELD_CLASS_TYPE_STRUCTURE ||
+                       bt_field_class_type_is(fc->type,
+                               BT_FIELD_CLASS_TYPE_VARIANT)) {
                struct bt_field_class_named_field_class_container *container_fc =
                        (void *) fc;
                uint64_t i;
@@ -2174,20 +2163,11 @@ void bt_field_class_make_part_of_trace_class(const struct bt_field_class *c_fc)
 
                        bt_field_class_make_part_of_trace_class(named_fc->fc);
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc->type,
+                       BT_FIELD_CLASS_TYPE_ARRAY)) {
                struct bt_field_class_array *array_fc = (void *) fc;
 
                bt_field_class_make_part_of_trace_class(array_fc->element_fc);
-               break;
-       }
-       default:
-               break;
        }
 }
 
index adf4c139f1e4fdd018bb998c3d6389b58dc1f339..4b08bbe8f5a191a4e3b31367be7be6e45a3daa09 100644 (file)
@@ -46,12 +46,7 @@ bool find_field_class_recursive(struct bt_field_class *fc,
                goto end;
        }
 
-       switch (fc->type) {
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       if (bt_field_class_type_is(fc->type, BT_FIELD_CLASS_TYPE_OPTION)) {
                struct bt_field_class_option *opt_fc = (void *) fc;
                struct bt_field_path_item item = {
                        .type = BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT,
@@ -66,13 +61,9 @@ bool find_field_class_recursive(struct bt_field_class *fc,
                }
 
                bt_field_path_remove_last_item(field_path);
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (fc->type == BT_FIELD_CLASS_TYPE_STRUCTURE ||
+                       bt_field_class_type_is(fc->type,
+                               BT_FIELD_CLASS_TYPE_VARIANT)) {
                struct bt_field_class_named_field_class_container *container_fc =
                        (void *) fc;
                uint64_t i;
@@ -94,13 +85,7 @@ bool find_field_class_recursive(struct bt_field_class *fc,
 
                        bt_field_path_remove_last_item(field_path);
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc->type, BT_FIELD_CLASS_TYPE_ARRAY)) {
                struct bt_field_class_array *array_fc = (void *) fc;
                struct bt_field_path_item item = {
                        .type = BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT,
@@ -115,10 +100,6 @@ bool find_field_class_recursive(struct bt_field_class *fc,
                }
 
                bt_field_path_remove_last_item(field_path);
-               break;
-       }
-       default:
-               break;
        }
 
 end:
@@ -262,24 +243,16 @@ struct bt_field_class *borrow_child_field_class(
 {
        struct bt_field_class *child_fc = NULL;
 
-       switch (parent_fc->type) {
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       if (bt_field_class_type_is(parent_fc->type,
+                       BT_FIELD_CLASS_TYPE_OPTION)) {
                struct bt_field_class_option *opt_fc = (void *) parent_fc;
 
                BT_ASSERT(fp_item->type ==
                        BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT);
                child_fc = opt_fc->content_fc;
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (parent_fc->type == BT_FIELD_CLASS_TYPE_STRUCTURE ||
+                       bt_field_class_type_is(parent_fc->type,
+                               BT_FIELD_CLASS_TYPE_VARIANT)) {
                struct bt_field_class_named_field_class_container *container_fc =
                        (void *) parent_fc;
                struct bt_named_field_class *named_fc;
@@ -287,21 +260,13 @@ struct bt_field_class *borrow_child_field_class(
                BT_ASSERT(fp_item->type == BT_FIELD_PATH_ITEM_TYPE_INDEX);
                named_fc = container_fc->named_fcs->pdata[fp_item->index];
                child_fc = named_fc->fc;
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-       {
+       } else if (bt_field_class_type_is(parent_fc->type,
+                       BT_FIELD_CLASS_TYPE_ARRAY)) {
                struct bt_field_class_array *array_fc = (void *) parent_fc;
 
                BT_ASSERT(fp_item->type ==
                        BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT);
                child_fc = array_fc->element_fc;
-               break;
-       }
-       default:
-               break;
        }
 
        return child_fc;
@@ -329,16 +294,12 @@ bool target_field_path_in_different_scope_has_struct_fc_only(
                        bt_field_path_borrow_item_by_index_inline(
                                tgt_field_path, i);
 
-               if (fc->type == BT_FIELD_CLASS_TYPE_STATIC_ARRAY ||
-                               fc->type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD ||
-                               fc->type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD ||
-                               fc->type == BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD ||
-                               fc->type == BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD ||
-                               fc->type == BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD ||
-                               fc->type == BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD ||
-                               fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD ||
-                               fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD ||
-                               fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD) {
+               if (bt_field_class_type_is(fc->type,
+                               BT_FIELD_CLASS_TYPE_ARRAY) ||
+                               bt_field_class_type_is(fc->type,
+                                       BT_FIELD_CLASS_TYPE_OPTION) ||
+                               bt_field_class_type_is(fc->type,
+                                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                        is_valid = false;
                        goto end;
                }
@@ -453,16 +414,12 @@ bool lca_to_target_has_struct_fc_only(struct bt_field_path *src_field_path,
                        bt_field_path_borrow_item_by_index_inline(
                                tgt_field_path, tgt_i);
 
-               if (tgt_fc->type == BT_FIELD_CLASS_TYPE_STATIC_ARRAY ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD) {
+               if (bt_field_class_type_is(tgt_fc->type,
+                               BT_FIELD_CLASS_TYPE_ARRAY) ||
+                               bt_field_class_type_is(tgt_fc->type,
+                                       BT_FIELD_CLASS_TYPE_OPTION) ||
+                               bt_field_class_type_is(tgt_fc->type,
+                                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                        is_valid = false;
                        goto end;
                }
@@ -571,11 +528,8 @@ int bt_resolve_field_paths(struct bt_field_class *fc,
        BT_ASSERT(fc);
 
        /* Resolving part for dynamic array and variant field classes */
-       switch (fc->type) {
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       if (bt_field_class_type_is(fc->type,
+                       BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD)) {
                struct bt_field_class_option_with_selector_field *opt_fc = (void *) fc;
 
                BT_ASSERT(opt_fc->selector_fc);
@@ -586,11 +540,7 @@ int bt_resolve_field_paths(struct bt_field_class *fc,
                        ret = -1;
                        goto end;
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-       {
+       } else if (fc->type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD) {
                struct bt_field_class_array_dynamic *dyn_array_fc = (void *) fc;
 
                BT_ASSERT(dyn_array_fc->length_fc);
@@ -601,12 +551,8 @@ int bt_resolve_field_paths(struct bt_field_class *fc,
                        ret = -1;
                        goto end;
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc->type,
+                       BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD)) {
                struct bt_field_class_variant_with_selector_field *var_fc =
                        (void *) fc;
 
@@ -621,27 +567,15 @@ int bt_resolve_field_paths(struct bt_field_class *fc,
                        }
                }
        }
-       default:
-               break;
-       }
 
        /* Recursive part */
-       switch (fc->type) {
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       if (bt_field_class_type_is(fc->type, BT_FIELD_CLASS_TYPE_OPTION)) {
                struct bt_field_class_option *opt_fc = (void *) fc;
 
                ret = bt_resolve_field_paths(opt_fc->content_fc, ctx);
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (fc->type == BT_FIELD_CLASS_TYPE_STRUCTURE ||
+                       bt_field_class_type_is(fc->type,
+                               BT_FIELD_CLASS_TYPE_VARIANT)) {
                struct bt_field_class_named_field_class_container *container_fc =
                        (void *) fc;
                uint64_t i;
@@ -655,20 +589,11 @@ int bt_resolve_field_paths(struct bt_field_class *fc,
                                goto end;
                        }
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc->type,
+                       BT_FIELD_CLASS_TYPE_ARRAY)) {
                struct bt_field_class_array *array_fc = (void *) fc;
 
                ret = bt_resolve_field_paths(array_fc->element_fc, ctx);
-               break;
-       }
-       default:
-               break;
        }
 
 end:
index 94142ddefb4034665c3971dd08a8a7b35529b56f..fff6cc305e24bba5aed106196809e8810d173bb0 100644 (file)
@@ -1835,6 +1835,7 @@ bt_field *borrow_next_field(struct bt_msg_iter *notit)
        bt_field *next_field = NULL;
        bt_field *base_field;
        const bt_field_class *base_fc;
+       bt_field_class_type base_fc_type;
        size_t index;
 
        BT_ASSERT(!stack_empty(notit->stack));
@@ -1843,10 +1844,9 @@ bt_field *borrow_next_field(struct bt_msg_iter *notit)
        BT_ASSERT(base_field);
        base_fc = bt_field_borrow_class_const(base_field);
        BT_ASSERT(base_fc);
+       base_fc_type = bt_field_class_get_type(base_fc);
 
-       switch (bt_field_class_get_type(base_fc)) {
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       {
+       if (base_fc_type == BT_FIELD_CLASS_TYPE_STRUCTURE) {
                BT_ASSERT(index <
                        bt_field_class_structure_get_member_count(
                                bt_field_borrow_class_const(
@@ -1854,23 +1854,17 @@ bt_field *borrow_next_field(struct bt_msg_iter *notit)
                next_field =
                        bt_field_structure_borrow_member_field_by_index(
                                base_field, index);
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
+       } else if (bt_field_class_type_is(base_fc_type,
+                       BT_FIELD_CLASS_TYPE_ARRAY)) {
                BT_ASSERT(index < bt_field_array_get_length(base_field));
                next_field = bt_field_array_borrow_element_field_by_index(
                        base_field, index);
-               break;
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
+       } else if (bt_field_class_type_is(base_fc_type,
+                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                BT_ASSERT(index == 0);
                next_field = bt_field_variant_borrow_selected_option_field(
                        base_field);
-               break;
-       default:
+       } else {
                abort();
        }
 
@@ -1996,10 +1990,8 @@ update_def_clock:
        field = borrow_next_field(notit);
        BT_ASSERT(field);
        BT_ASSERT(bt_field_borrow_class_const(field) == fc->ir_fc);
-       BT_ASSERT(bt_field_get_class_type(field) ==
-                 BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
-                 bt_field_get_class_type(field) ==
-                 BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
+       BT_ASSERT(bt_field_class_type_is(bt_field_get_class_type(field),
+               BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER));
        bt_field_integer_unsigned_set_value(field, value);
        stack_top(notit->stack)->index++;
 
@@ -2041,7 +2033,7 @@ enum bt_bfcr_status bfcr_unsigned_int_char_cb(uint64_t value,
 
        string_field = stack_top(notit->stack)->base;
        BT_ASSERT(bt_field_get_class_type(string_field) ==
-                 BT_FIELD_CLASS_TYPE_STRING);
+               BT_FIELD_CLASS_TYPE_STRING);
 
        /* Append character */
        str[0] = (char) value;
@@ -2085,10 +2077,8 @@ enum bt_bfcr_status bfcr_signed_int_cb(int64_t value,
        field = borrow_next_field(notit);
        BT_ASSERT(field);
        BT_ASSERT(bt_field_borrow_class_const(field) == fc->ir_fc);
-       BT_ASSERT(bt_field_get_class_type(field) ==
-                 BT_FIELD_CLASS_TYPE_SIGNED_INTEGER ||
-                 bt_field_get_class_type(field) ==
-                 BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
+       BT_ASSERT(bt_field_class_type_is(bt_field_get_class_type(field),
+               BT_FIELD_CLASS_TYPE_SIGNED_INTEGER));
        bt_field_integer_signed_set_value(field, value);
        stack_top(notit->stack)->index++;
 
@@ -2117,8 +2107,7 @@ enum bt_bfcr_status bfcr_floating_point_cb(double value,
        bt_field_class_type type = bt_field_get_class_type(field);
        BT_ASSERT(field);
        BT_ASSERT(bt_field_borrow_class_const(field) == fc->ir_fc);
-       BT_ASSERT(type == BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL ||
-                 type == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL);
+       BT_ASSERT(bt_field_class_type_is(type, BT_FIELD_CLASS_TYPE_REAL));
 
        if (type == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) {
                bt_field_real_single_precision_set_value(field, (float) value);
@@ -2350,10 +2339,9 @@ int64_t bfcr_get_sequence_length_cb(struct ctf_field_class *fc, void *data)
         * is a sequence field.
         */
        if (!seq_fc->base.is_text) {
-               BT_ASSERT(bt_field_get_class_type(seq_field) ==
-                       BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD ||
-                       bt_field_get_class_type(seq_field) ==
-                       BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD);
+               BT_ASSERT(bt_field_class_type_is(
+                       bt_field_get_class_type(seq_field),
+                               BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY));
                ret = bt_field_array_dynamic_set_length(seq_field,
                        (uint64_t) length);
                if (ret) {
index b73c810d5338623313981ea33d6aa5018f988aad..d6db67d9cbc46ecf2a835224d0a168aa5ee6af0a 100644 (file)
@@ -221,8 +221,8 @@ void _fs_sink_ctf_field_class_int_init(struct fs_sink_ctf_field_class_int *fc,
                (unsigned int) bt_field_class_integer_get_field_value_range(
                        ir_fc),
                index_in_parent);
-       fc->is_signed = (ir_fc_type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER ||
-               ir_fc_type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
+       fc->is_signed = bt_field_class_type_is(ir_fc_type,
+               BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
 }
 
 static inline
@@ -308,7 +308,8 @@ struct fs_sink_ctf_field_class_float *fs_sink_ctf_field_class_float_create(
        _fs_sink_ctf_field_class_bit_array_init((void *) fc,
                FS_SINK_CTF_FIELD_CLASS_TYPE_FLOAT,
                ir_fc,
-               bt_field_class_get_type(ir_fc) == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL ? 32 : 64,
+               bt_field_class_get_type(ir_fc) ==
+                       BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL ? 32 : 64,
                index_in_parent);
        return fc;
 }
index a94c615e4f410040c9852d72cd74a5f1f90454c3..a975be3789c422e003d1fc2f9f9dda9c236dce3c 100644 (file)
@@ -216,11 +216,10 @@ void append_integer_field_class(struct ctx *ctx,
 {
        const bt_field_class *ir_fc = fc->base.base.ir_fc;
        bt_field_class_type type = bt_field_class_get_type(ir_fc);
-       bool is_signed = type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION ||
-               type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER;
+       bool is_signed = bt_field_class_type_is(type,
+               BT_FIELD_CLASS_TYPE_SIGNED_INTEGER);
 
-       if (type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION ||
-                       type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
+       if (bt_field_class_type_is(type, BT_FIELD_CLASS_TYPE_ENUMERATION)) {
                g_string_append(ctx->tsdl, "enum : ");
        }
 
@@ -229,8 +228,7 @@ void append_integer_field_class(struct ctx *ctx,
                bt_field_class_integer_get_preferred_display_base(ir_fc),
                NULL, NULL, false);
 
-       if (type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION ||
-                       type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
+       if (bt_field_class_type_is(type, BT_FIELD_CLASS_TYPE_ENUMERATION)) {
                uint64_t i;
 
                g_string_append(ctx->tsdl, " {\n");
@@ -334,7 +332,8 @@ void append_float_field_class(struct ctx *ctx,
 {
        unsigned int mant_dig, exp_dig;
 
-       if (bt_field_class_get_type(fc->base.base.ir_fc) == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) {
+       if (bt_field_class_get_type(fc->base.base.ir_fc) ==
+                       BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) {
                mant_dig = 24;
                exp_dig = 8;
        } else {
index 8fa624fe0bc6db074ff970051551666dc7c2ff20..6e45bebc7ff72feed5ebf9af0f9d9c5d4a91e002 100644 (file)
@@ -999,8 +999,8 @@ int translate_variant_field_class(struct ctx *ctx)
        ir_fc_type = bt_field_class_get_type(fc->base.ir_fc);
        opt_count = bt_field_class_variant_get_option_count(fc->base.ir_fc);
 
-       if (ir_fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD ||
-                       ir_fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD) {
+       if (bt_field_class_type_is(ir_fc_type,
+                       BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD)) {
                ir_selector_field_path = bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
                        fc->base.ir_fc);
                BT_ASSERT(ir_selector_field_path);
@@ -1018,8 +1018,8 @@ int translate_variant_field_class(struct ctx *ctx)
                bt_field_class_type type = bt_field_class_get_type(
                        tgt_fc->ir_fc);
 
-               if (type != BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION &&
-                               type != BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
+               if (!bt_field_class_type_is(type,
+                               BT_FIELD_CLASS_TYPE_ENUMERATION)) {
                        fc->tag_is_before = true;
                        goto validate_opts;
                }
@@ -1307,49 +1307,35 @@ static
 int translate_field_class(struct ctx *ctx)
 {
        int ret;
+       bt_field_class_type ir_fc_type =
+               bt_field_class_get_type(cur_path_stack_top(ctx)->ir_fc);
 
-       switch (bt_field_class_get_type(cur_path_stack_top(ctx)->ir_fc)) {
-       case BT_FIELD_CLASS_TYPE_BOOL:
+       if (ir_fc_type == BT_FIELD_CLASS_TYPE_BOOL) {
                ret = translate_bool_field_class(ctx);
-               break;
-       case BT_FIELD_CLASS_TYPE_BIT_ARRAY:
+       } else if (ir_fc_type == BT_FIELD_CLASS_TYPE_BIT_ARRAY) {
                ret = translate_bit_array_field_class(ctx);
-               break;
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
-       case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
-       case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
+       } else if (bt_field_class_type_is(ir_fc_type,
+                       BT_FIELD_CLASS_TYPE_INTEGER)) {
                ret = translate_integer_field_class(ctx);
-               break;
-       case BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL:
-       case BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL:
+       } else if (bt_field_class_type_is(ir_fc_type,
+                       BT_FIELD_CLASS_TYPE_REAL)) {
                ret = translate_real_field_class(ctx);
-               break;
-       case BT_FIELD_CLASS_TYPE_STRING:
+       } else if (ir_fc_type == BT_FIELD_CLASS_TYPE_STRING) {
                ret = translate_string_field_class(ctx);
-               break;
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
+       } else if (ir_fc_type == BT_FIELD_CLASS_TYPE_STRUCTURE) {
                ret = translate_structure_field_class(ctx);
-               break;
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
+       } else if (ir_fc_type == BT_FIELD_CLASS_TYPE_STATIC_ARRAY) {
                ret = translate_static_array_field_class(ctx);
-               break;
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
+       } else if (bt_field_class_type_is(ir_fc_type,
+                       BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY)) {
                ret = translate_dynamic_array_field_class(ctx);
-               break;
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
+       } else if (bt_field_class_type_is(ir_fc_type,
+                       BT_FIELD_CLASS_TYPE_OPTION)) {
                ret = translate_option_field_class(ctx);
-               break;
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
+       } else if (bt_field_class_type_is(ir_fc_type,
+                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                ret = translate_variant_field_class(ctx);
-               break;
-       default:
+       } else {
                abort();
        }
 
index ac6c08ed8b02a4808842512a0d8f4ebd145b80a4..45d8b02ecd1917e0ac14b3c19140c2676fd59505 100644 (file)
@@ -227,35 +227,28 @@ void copy_field_content(const bt_field *in_field, bt_field *out_field,
 
        BT_COMP_LOGT("Copying content of field: in-f-addr=%p, out-f-addr=%p",
                        in_field, out_field);
-       switch (in_fc_type) {
-       case BT_FIELD_CLASS_TYPE_BOOL:
+
+       if (in_fc_type == BT_FIELD_CLASS_TYPE_BOOL) {
                bt_field_bool_set_value(out_field,
                        bt_field_bool_get_value(in_field));
-               break;
-       case BT_FIELD_CLASS_TYPE_BIT_ARRAY:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_BIT_ARRAY) {
                bt_field_bit_array_set_value_as_integer(out_field,
                        bt_field_bit_array_get_value_as_integer(in_field));
-               break;
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
+       } else if (bt_field_class_type_is(in_fc_type,
+                       BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER)) {
                bt_field_integer_unsigned_set_value(out_field,
                                bt_field_integer_unsigned_get_value(in_field));
-               break;
-       case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
-       case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
+       } else if (bt_field_class_type_is(in_fc_type,
+                       BT_FIELD_CLASS_TYPE_SIGNED_INTEGER)) {
                bt_field_integer_signed_set_value(out_field,
                                bt_field_integer_signed_get_value(in_field));
-               break;
-       case BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) {
                bt_field_real_single_precision_set_value(out_field,
                                bt_field_real_single_precision_get_value(in_field));
-               break;
-       case BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL) {
                bt_field_real_double_precision_set_value(out_field,
                                bt_field_real_double_precision_get_value(in_field));
-               break;
-       case BT_FIELD_CLASS_TYPE_STRING:
-       {
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_STRING) {
                const char *str = bt_field_string_get_value(in_field);
                bt_field_string_set_value_status status =
                        bt_field_string_set_value(out_field, str);
@@ -266,10 +259,7 @@ void copy_field_content(const bt_field *in_field, bt_field *out_field,
                        bt_current_thread_clear_error();
 
                }
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       {
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_STRUCTURE) {
                uint64_t i, nb_member_struct;
                const bt_field *in_member_field;
                bt_field *out_member_field;
@@ -303,13 +293,8 @@ void copy_field_content(const bt_field *in_field, bt_field *out_field,
                        copy_field_content(in_member_field,
                                out_member_field, log_level, self_comp);
                }
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-               /* fall through */
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       {
+       } else if (bt_field_class_type_is(in_fc_type,
+                       BT_FIELD_CLASS_TYPE_ARRAY)) {
                const bt_field *in_element_field;
                bt_field *out_element_field;
                uint64_t i, array_len;
@@ -317,8 +302,8 @@ void copy_field_content(const bt_field *in_field, bt_field *out_field,
 
                array_len = bt_field_array_get_length(in_field);
 
-               if (in_fc_type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD ||
-                               in_fc_type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD) {
+               if (bt_field_class_type_is(in_fc_type,
+                               BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY)) {
                        set_len_status = bt_field_array_dynamic_set_length(
                                out_field, array_len);
                        if (set_len_status !=
@@ -340,13 +325,8 @@ void copy_field_content(const bt_field *in_field, bt_field *out_field,
                        copy_field_content(in_element_field, out_element_field,
                                log_level, self_comp);
                }
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (bt_field_class_type_is(in_fc_type,
+                       BT_FIELD_CLASS_TYPE_OPTION)) {
                const bt_field *in_option_field;
                bt_field *out_option_field;
 
@@ -362,13 +342,8 @@ void copy_field_content(const bt_field *in_field, bt_field *out_field,
                } else {
                        bt_field_option_set_has_field(out_field, BT_FALSE);
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (bt_field_class_type_is(in_fc_type,
+                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                bt_field_variant_select_option_field_by_index_status sel_opt_status;
                uint64_t in_selected_option_idx;
                const bt_field *in_option_field;
@@ -392,12 +367,10 @@ void copy_field_content(const bt_field *in_field, bt_field *out_field,
 
                copy_field_content(in_option_field, out_option_field,
                        log_level, self_comp);
-
-               break;
-       }
-       default:
+       } else {
                abort();
        }
+
        BT_COMP_LOGT("Copied content of field: in-f-addr=%p, out-f-addr=%p",
                        in_field, out_field);
 }
index 79da94e1171d3cdd12edf86d333cf0d8fe86178e..f149281ab46898fa5bc6218b9bc1189e56d8cd9d 100644 (file)
@@ -60,9 +60,7 @@ const bt_field_class *walk_field_path(struct trace_ir_metadata_maps *md_maps,
                const bt_field_path_item *fp_item =
                        bt_field_path_borrow_item_by_index_const(fp, i);
 
-               switch (fc_type) {
-               case BT_FIELD_CLASS_TYPE_STRUCTURE:
-               {
+               if (fc_type == BT_FIELD_CLASS_TYPE_STRUCTURE) {
                        const bt_field_class_structure_member *member;
 
                        BT_ASSERT(bt_field_path_item_get_type(fp_item) ==
@@ -72,23 +70,13 @@ const bt_field_class *walk_field_path(struct trace_ir_metadata_maps *md_maps,
                                bt_field_path_item_index_get_index(fp_item));
                        curr_fc = bt_field_class_structure_member_borrow_field_class_const(
                                member);
-                       break;
-               }
-               case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-               case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-               case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-               case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-               {
+               } else if (bt_field_class_type_is(fc_type, BT_FIELD_CLASS_TYPE_OPTION)) {
                        BT_ASSERT(bt_field_path_item_get_type(fp_item) ==
                                BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT);
                        curr_fc = bt_field_class_option_borrow_field_class_const(
                                curr_fc);
-                       break;
-               }
-               case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-               case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-               case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-               {
+
+               } else if (bt_field_class_type_is(fc_type, BT_FIELD_CLASS_TYPE_VARIANT)) {
                        const bt_field_class_variant_option *option;
 
                        BT_ASSERT(bt_field_path_item_get_type(fp_item) ==
@@ -99,18 +87,13 @@ const bt_field_class *walk_field_path(struct trace_ir_metadata_maps *md_maps,
                        curr_fc = bt_field_class_variant_option_borrow_field_class_const(
                                option);
                        break;
-               }
-               case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-               case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-               case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-               {
+               } else if (bt_field_class_type_is(fc_type, BT_FIELD_CLASS_TYPE_ARRAY)) {
                        BT_ASSERT(bt_field_path_item_get_type(fp_item) ==
                                BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT);
                        curr_fc = bt_field_class_array_borrow_element_field_class_const(
                                curr_fc);
                        break;
-               }
-               default:
+               } else {
                        abort();
                }
        }
@@ -717,9 +700,12 @@ bt_field_class *create_field_class_copy_internal(struct trace_ir_metadata_maps *
                        out_elem_fc, array_len);
                break;
        }
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-       {
+       default:
+               break;
+       }
+
+       if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY)) {
                const bt_field_class *in_elem_fc =
                        bt_field_class_array_borrow_element_field_class_const(
                                        in_field_class);
@@ -749,13 +735,8 @@ bt_field_class *create_field_class_copy_internal(struct trace_ir_metadata_maps *
                out_field_class = bt_field_class_array_dynamic_create(
                        md_maps->output_trace_class,
                        out_elem_fc, out_length_fc);
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_OPTION)) {
                const bt_field_class *in_content_fc =
                        bt_field_class_option_borrow_field_class_const(
                                in_field_class);
@@ -828,16 +809,12 @@ bt_field_class *create_field_class_copy_internal(struct trace_ir_metadata_maps *
                }
 
                BT_ASSERT(out_field_class);
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                bt_field_class *out_sel_fc = NULL;
 
-               if (fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD ||
-                               fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD) {
+               if (bt_field_class_type_is(fc_type,
+                               BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD)) {
                        const bt_field_class *in_sel_fc;
                        const bt_field_path *sel_fp =
                                bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
@@ -854,10 +831,6 @@ bt_field_class *create_field_class_copy_internal(struct trace_ir_metadata_maps *
 
                out_field_class = bt_field_class_variant_create(
                        md_maps->output_trace_class, out_sel_fc);
-               break;
-       }
-       default:
-               abort();
        }
 
        /*
@@ -865,6 +838,7 @@ bt_field_class *create_field_class_copy_internal(struct trace_ir_metadata_maps *
         * the resolution of field paths in variant and dynamic array field
         * classes.
         */
+       BT_ASSERT(out_field_class);
        g_hash_table_insert(md_maps->field_class_map,
                (gpointer) in_field_class, out_field_class);
 
@@ -887,6 +861,8 @@ int copy_field_class_content_internal(
                bt_field_class *out_field_class)
 {
        int ret = 0;
+       bt_field_class_type in_fc_type =
+               bt_field_class_get_type(in_field_class);
 
        /*
         * Safe to use the same value object because it's frozen at this
@@ -895,70 +871,52 @@ int copy_field_class_content_internal(
        bt_field_class_set_user_attributes(out_field_class,
                bt_field_class_borrow_user_attributes_const(in_field_class));
 
-       switch(bt_field_class_get_type(in_field_class)) {
-       case BT_FIELD_CLASS_TYPE_BOOL:
+       if (in_fc_type == BT_FIELD_CLASS_TYPE_BOOL) {
                ret = field_class_bool_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_BIT_ARRAY:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_BIT_ARRAY) {
                ret = field_class_bit_array_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER) {
                ret = field_class_unsigned_integer_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER) {
                ret = field_class_signed_integer_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
                ret = field_class_unsigned_enumeration_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
                ret = field_class_signed_enumeration_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) {
                ret = field_class_single_precision_real_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL) {
                ret = field_class_double_precision_real_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_STRING:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_STRING) {
                ret = field_class_string_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_STRUCTURE) {
                ret = field_class_structure_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
+       } else if (in_fc_type == BT_FIELD_CLASS_TYPE_STATIC_ARRAY) {
                ret = field_class_static_array_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
+       } else if (bt_field_class_type_is(in_fc_type,
+                       BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY)) {
                ret = field_class_dynamic_array_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
+       } else if (bt_field_class_type_is(in_fc_type,
+                       BT_FIELD_CLASS_TYPE_OPTION)) {
                ret = field_class_option_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
+       } else if (bt_field_class_type_is(in_fc_type,
+                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                ret = field_class_variant_copy(md_maps,
                                in_field_class, out_field_class);
-               break;
-       default:
+       } else {
                abort();
        }
 
index 47bf66fd45634ccf62d10413078b46fafd75ad55..0d9f0f7a349ce2d505456c299e5a262e1f773c87 100644 (file)
@@ -981,15 +981,7 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                color_fg_blue(ctx), type, color_reset(ctx));
 
        /* Write field class's single-line properties */
-       switch (fc_type) {
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
-       case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
-               write_sp(ctx);
-               write_int_field_class_props(ctx, fc, true);
-               break;
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
-       case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
-       {
+       if (bt_field_class_type_is(fc_type, BT_FIELD_CLASS_TYPE_ENUMERATION)) {
                uint64_t mapping_count =
                        bt_field_class_enumeration_get_mapping_count(fc);
 
@@ -999,10 +991,11 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                write_uint_prop_value(ctx, mapping_count);
                g_string_append_printf(ctx->str, " mapping%s)",
                        plural(mapping_count));
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       {
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_INTEGER)) {
+               write_sp(ctx);
+               write_int_field_class_props(ctx, fc, true);
+       } else if (fc_type == BT_FIELD_CLASS_TYPE_STRUCTURE) {
                uint64_t member_count =
                        bt_field_class_structure_get_member_count(fc);
 
@@ -1010,31 +1003,21 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                write_uint_prop_value(ctx, member_count);
                g_string_append_printf(ctx->str, " member%s)",
                        plural(member_count));
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-               if (fc_type == BT_FIELD_CLASS_TYPE_STATIC_ARRAY) {
-                       g_string_append(ctx->str, " (Length ");
-                       write_uint_prop_value(ctx,
-                               bt_field_class_array_static_get_length(fc));
-                       g_string_append_c(ctx->str, ')');
-               } else if (fc_type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD) {
-                       const bt_field_path *length_field_path =
-                               bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
-                                       fc);
-
-                       g_string_append(ctx->str, " (Length field path ");
-                       write_field_path(ctx, length_field_path);
-                       g_string_append_c(ctx->str, ')');
-               }
+       } else if (fc_type == BT_FIELD_CLASS_TYPE_STATIC_ARRAY) {
+               g_string_append(ctx->str, " (Length ");
+               write_uint_prop_value(ctx,
+                       bt_field_class_array_static_get_length(fc));
+               g_string_append_c(ctx->str, ')');
+       } else if (fc_type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD) {
+               const bt_field_path *length_field_path =
+                       bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
+                               fc);
 
-               break;
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+               g_string_append(ctx->str, " (Length field path ");
+               write_field_path(ctx, length_field_path);
+               g_string_append_c(ctx->str, ')');
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD)) {
                const bt_field_path *selector_field_path =
                        bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
                                fc);
@@ -1042,18 +1025,14 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                g_string_append(ctx->str, " (Selector field path ");
                write_field_path(ctx, selector_field_path);
                g_string_append_c(ctx->str, ')');
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                uint64_t option_count =
                        bt_field_class_variant_get_option_count(fc);
                const bt_field_path *sel_field_path = NULL;
 
-               if (fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD ||
-                               fc_type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD) {
+               if (bt_field_class_type_is(fc_type,
+                               BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD)) {
                        sel_field_path =
                                bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
                                        fc);
@@ -1071,10 +1050,6 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                }
 
                g_string_append_c(ctx->str, ')');
-               break;
-       }
-       default:
-               break;
        }
 
        incr_indent(ctx);
@@ -1086,10 +1061,7 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
        }
 
        /* Write field class's complex properties */
-       switch (fc_type) {
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
-       case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
-       {
+       if (bt_field_class_type_is(fc_type, BT_FIELD_CLASS_TYPE_ENUMERATION)) {
                uint64_t mapping_count =
                        bt_field_class_enumeration_get_mapping_count(fc);
 
@@ -1111,11 +1083,7 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                                decr_indent(ctx);
                        }
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       {
+       } else if (fc_type == BT_FIELD_CLASS_TYPE_STRUCTURE) {
                uint64_t member_count =
                        bt_field_class_structure_get_member_count(fc);
 
@@ -1170,12 +1138,7 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                                decr_indent(ctx);
                        }
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
+       } else if (bt_field_class_type_is(fc_type, BT_FIELD_CLASS_TYPE_ARRAY)) {
                if (wrote_user_attrs) {
                        write_nl(ctx);
                } else {
@@ -1186,12 +1149,8 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                write_sp(ctx);
                write_field_class(ctx,
                        bt_field_class_array_borrow_element_field_class_const(fc));
-               break;
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_OPTION)) {
                const void *ranges = NULL;
                bool selector_is_signed = false;
 
@@ -1235,12 +1194,8 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                write_sp(ctx);
                write_field_class(ctx,
                        bt_field_class_option_borrow_field_class_const(fc));
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                uint64_t option_count =
                        bt_field_class_variant_get_option_count(fc);
 
@@ -1264,11 +1219,6 @@ void write_field_class(struct details_write_ctx *ctx, const bt_field_class *fc)
                                decr_indent(ctx);
                        }
                }
-
-               break;
-       }
-       default:
-               break;
        }
 
        decr_indent(ctx);
@@ -1843,22 +1793,16 @@ void write_field(struct details_write_ctx *ctx, const bt_field *field,
        }
 
        /* Write field's value */
-       switch (fc_type) {
-       case BT_FIELD_CLASS_TYPE_BOOL:
+       if (fc_type == BT_FIELD_CLASS_TYPE_BOOL) {
                write_sp(ctx);
                write_bool_prop_value(ctx, bt_field_bool_get_value(field));
-               break;
-       case BT_FIELD_CLASS_TYPE_BIT_ARRAY:
+       } else if (fc_type == BT_FIELD_CLASS_TYPE_BIT_ARRAY) {
                format_uint(buf, bt_field_bit_array_get_value_as_integer(field),
                        16);
                write_sp(ctx);
                write_uint_str_prop_value(ctx, buf);
-               break;
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
-       case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
-       case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
-       {
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_INTEGER)) {
                unsigned int fmt_base;
                bt_field_class_integer_preferred_display_base base;
 
@@ -1882,8 +1826,8 @@ void write_field(struct details_write_ctx *ctx, const bt_field *field,
                        abort();
                }
 
-               if (fc_type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
-                               fc_type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
+               if (bt_field_class_type_is(fc_type,
+                               BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER)) {
                        format_uint(buf,
                                bt_field_integer_unsigned_get_value(field),
                                fmt_base);
@@ -1896,23 +1840,16 @@ void write_field(struct details_write_ctx *ctx, const bt_field *field,
                        write_sp(ctx);
                        write_int_str_prop_value(ctx, buf);
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL:
+       } else if (fc_type == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) {
                write_sp(ctx);
                write_float_prop_value(ctx, bt_field_real_single_precision_get_value(field));
-               break;
-       case BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL:
+       } else if (fc_type == BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL) {
                write_sp(ctx);
                write_float_prop_value(ctx, bt_field_real_double_precision_get_value(field));
-               break;
-       case BT_FIELD_CLASS_TYPE_STRING:
+       } else if (fc_type == BT_FIELD_CLASS_TYPE_STRING) {
                write_sp(ctx);
                write_str_prop_value(ctx, bt_field_string_get_value(field));
-               break;
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       {
+       } else if (fc_type == BT_FIELD_CLASS_TYPE_STRUCTURE) {
                uint64_t member_count;
 
                fc = bt_field_borrow_class_const(field);
@@ -1939,13 +1876,7 @@ void write_field(struct details_write_ctx *ctx, const bt_field *field,
                        write_sp(ctx);
                        write_none_prop_value(ctx, "Empty");
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc_type, BT_FIELD_CLASS_TYPE_ARRAY)) {
                uint64_t length = bt_field_array_get_length(field);
 
                if (length == 0) {
@@ -1970,13 +1901,8 @@ void write_field(struct details_write_ctx *ctx, const bt_field *field,
                }
 
                decr_indent(ctx);
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
-       {
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_OPTION)) {
                const bt_field *content_field =
                        bt_field_option_borrow_field_const(field);
 
@@ -1986,17 +1912,12 @@ void write_field(struct details_write_ctx *ctx, const bt_field *field,
                } else {
                        write_field(ctx, content_field, NULL);
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
+       } else if (bt_field_class_type_is(fc_type,
+                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                write_field(ctx,
                        bt_field_variant_borrow_selected_option_field_const(
                                field), NULL);
-               break;
-       default:
+       } else {
                abort();
        }
 }
index 06d303715b637b76a640b1f4e40fe74a9f9e89d8..b4800f3c5993fa228e2453ecaf5ab2fd43296da7 100644 (file)
@@ -530,8 +530,8 @@ int print_integer(struct pretty_component *pretty,
        int_fc = bt_field_borrow_class_const(field);
        BT_ASSERT(int_fc);
        ft_type = bt_field_get_class_type(field);
-       if (ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
-                       ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
+       if (bt_field_class_type_is(ft_type,
+                       BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER)) {
                v.u = bt_field_integer_unsigned_get_value(field);
        } else {
                v.s = bt_field_integer_signed_get_value(field);
@@ -560,8 +560,8 @@ int print_integer(struct pretty_component *pretty,
        }
        case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL:
        {
-               if (ft_type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER ||
-                               ft_type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
+               if (bt_field_class_type_is(ft_type,
+                               BT_FIELD_CLASS_TYPE_SIGNED_INTEGER)) {
                        int len;
 
                        len = bt_field_class_integer_get_field_value_range(
@@ -580,8 +580,8 @@ int print_integer(struct pretty_component *pretty,
                break;
        }
        case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL:
-               if (ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
-                               ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
+               if (bt_field_class_type_is(ft_type,
+                               BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER)) {
                        bt_common_g_string_append_printf(pretty->string, "%" PRIu64, v.u);
                } else {
                        bt_common_g_string_append_printf(pretty->string, "%" PRId64, v.s);
@@ -977,9 +977,7 @@ int print_field(struct pretty_component *pretty,
        bt_field_class_type class_id;
 
        class_id = bt_field_get_class_type(field);
-       switch (class_id) {
-       case BT_FIELD_CLASS_TYPE_BOOL:
-       {
+       if (class_id == BT_FIELD_CLASS_TYPE_BOOL) {
                bt_bool v;
                const char *text;
 
@@ -997,9 +995,7 @@ int print_field(struct pretty_component *pretty,
                        bt_common_g_string_append(pretty->string, COLOR_RST);
                }
                return 0;
-       }
-       case BT_FIELD_CLASS_TYPE_BIT_ARRAY:
-       {
+       } else if (class_id == BT_FIELD_CLASS_TYPE_BIT_ARRAY) {
                uint64_t v = bt_field_bit_array_get_value_as_integer(field);
 
                if (pretty->use_colors) {
@@ -1012,17 +1008,18 @@ int print_field(struct pretty_component *pretty,
                        bt_common_g_string_append(pretty->string, COLOR_RST);
                }
                return 0;
-       }
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
-       case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
+       } else if (bt_field_class_type_is(class_id,
+                       BT_FIELD_CLASS_TYPE_ENUMERATION)) {
+               return print_enum(pretty, field);
+       } else if (bt_field_class_type_is(class_id,
+                       BT_FIELD_CLASS_TYPE_INTEGER)) {
                return print_integer(pretty, field);
-       case BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL:
-       case BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL:
-       {
+       } else if (bt_field_class_type_is(class_id,
+                       BT_FIELD_CLASS_TYPE_REAL)) {
                double v;
 
                if (class_id == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) {
-                       v = (float) bt_field_real_single_precision_get_value(field);
+                       v = bt_field_real_single_precision_get_value(field);
                } else {
                        v = bt_field_real_double_precision_get_value(field);
                }
@@ -1035,12 +1032,7 @@ int print_field(struct pretty_component *pretty,
                        bt_common_g_string_append(pretty->string, COLOR_RST);
                }
                return 0;
-       }
-       case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
-       case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
-               return print_enum(pretty, field);
-       case BT_FIELD_CLASS_TYPE_STRING:
-       {
+       } else if (class_id == BT_FIELD_CLASS_TYPE_STRING) {
                const char *str;
 
                str = bt_field_string_get_value(field);
@@ -1056,24 +1048,20 @@ int print_field(struct pretty_component *pretty,
                        bt_common_g_string_append(pretty->string, COLOR_RST);
                }
                return 0;
-       }
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
+       } else if (class_id == BT_FIELD_CLASS_TYPE_STRUCTURE) {
                return print_struct(pretty, field, print_names);
-       case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
+       } else if (bt_field_class_type_is(class_id,
+                       BT_FIELD_CLASS_TYPE_OPTION)) {
                return print_option(pretty, field, print_names);
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD:
+       } else if (bt_field_class_type_is(class_id,
+                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                return print_variant(pretty, field, print_names);
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
+       } else if (class_id == BT_FIELD_CLASS_TYPE_STATIC_ARRAY) {
                return print_array(pretty, field, print_names);
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD:
+       } else if (bt_field_class_type_is(class_id,
+                       BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY)) {
                return print_sequence(pretty, field, print_names);
-       default:
+       } else {
                // TODO: log instead
                fprintf(pretty->err, "[error] Unknown type id: %d\n", (int) class_id);
                return -1;
This page took 0.04412 seconds and 4 git commands to generate.