lib: rename option/var. "selector" to "selector field"
[babeltrace.git] / src / plugins / lttng-utils / debug-info / trace-ir-data-copy.c
index 8516a989ba1b4eadca687fb14f75de8cc52076aa..ac6c08ed8b02a4808842512a0d8f4ebd145b80a4 100644 (file)
@@ -26,7 +26,7 @@
 #define BT_COMP_LOG_SELF_COMP self_comp
 #define BT_LOG_OUTPUT_LEVEL log_level
 #define BT_LOG_TAG "PLUGIN/FLT.LTTNG-UTILS.DEBUG-INFO/TRACE-IR-DATA-COPY"
-#include "plugins/comp-logging.h"
+#include "logging/comp-logging.h"
 
 #include <inttypes.h>
 #include <stdint.h>
@@ -39,19 +39,73 @@ BT_HIDDEN
 void copy_trace_content(const bt_trace *in_trace, bt_trace *out_trace,
                bt_logging_level log_level, bt_self_component *self_comp)
 {
-       bt_trace_status status;
+       bt_trace_set_name_status status;
        const char *trace_name;
+       uint64_t i, env_field_count;
 
        BT_COMP_LOGD("Copying content of trace: in-t-addr=%p, out-t-addr=%p",
                        in_trace, out_trace);
-
        trace_name = bt_trace_get_name(in_trace);
        /* Copy the trace name. */
        if (trace_name) {
                status = bt_trace_set_name(out_trace, trace_name);
-               if (status != BT_TRACE_STATUS_OK) {
+               if (status != BT_TRACE_SET_NAME_STATUS_OK) {
                        BT_COMP_LOGE("Cannot set trace's name: trace-addr=%p, name=\"%s\"",
-                                       out_trace, trace_name);
+                               out_trace, trace_name);
+                       bt_current_thread_clear_error();
+                       goto end;
+               }
+       }
+
+       /*
+        * Safe to use the same value object because it's frozen at this
+        * point.
+        */
+       bt_trace_set_user_attributes(out_trace,
+               bt_trace_borrow_user_attributes_const(in_trace));
+
+       /*
+        * Do not copy the trace UUID as it may be modified and should
+        * no longer have the same UUID.
+        */
+
+       /*
+        * Go over all the entries in the environment section of the
+        * trace and copy the content to the new trace.
+        */
+       env_field_count = bt_trace_get_environment_entry_count(in_trace);
+       for (i = 0; i < env_field_count; i++) {
+               const char *value_name;
+               const bt_value *value = NULL;
+               bt_trace_set_environment_entry_status set_env_status;
+
+               bt_trace_borrow_environment_entry_by_index_const(
+                       in_trace, i, &value_name, &value);
+
+               BT_COMP_LOGD("Copying trace environnement entry: "
+                       "index=%" PRId64 ", value-addr=%p, value-name=%s",
+                       i, value, value_name);
+
+               BT_ASSERT(value_name);
+               BT_ASSERT(value);
+
+               if (bt_value_is_signed_integer(value)) {
+                       set_env_status = bt_trace_set_environment_entry_integer(
+                               out_trace, value_name,
+                               bt_value_integer_signed_get( value));
+               } else if (bt_value_is_string(value)) {
+                       set_env_status = bt_trace_set_environment_entry_string(
+                               out_trace, value_name,
+                               bt_value_string_get(value));
+               } else {
+                       abort();
+               }
+
+               if (set_env_status != BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_OK) {
+                       BT_COMP_LOGE("Cannot copy trace's environment: "
+                               "trace-addr=%p, name=\"%s\"",
+                               out_trace, trace_name);
+                       bt_current_thread_clear_error();
                        goto end;
                }
        }
@@ -67,7 +121,7 @@ void copy_stream_content(const bt_stream *in_stream, bt_stream *out_stream,
                bt_logging_level log_level, bt_self_component *self_comp)
 {
        const char *stream_name;
-       bt_stream_status status;
+       bt_stream_set_name_status status;
 
        BT_COMP_LOGD("Copying content of stream: in-s-addr=%p, out-s-addr=%p",
                        in_stream, out_stream);
@@ -75,13 +129,19 @@ void copy_stream_content(const bt_stream *in_stream, bt_stream *out_stream,
        stream_name = bt_stream_get_name(in_stream);
        if (stream_name) {
                status = bt_stream_set_name(out_stream, stream_name);
-               if (status != BT_STREAM_STATUS_OK) {
+               if (status != BT_STREAM_SET_NAME_STATUS_OK) {
                        BT_COMP_LOGE("Cannot set stream's name: stream-addr=%p, "
                                "name=%s", out_stream, stream_name);
                        goto end;
                }
        }
 
+       /*
+        * Safe to use the same value object because it's frozen at this
+        * point.
+        */
+       bt_stream_set_user_attributes(out_stream,
+               bt_stream_borrow_user_attributes_const(in_stream));
        BT_COMP_LOGD("Copied content of stream: in-s-addr=%p, out-s-addr=%p",
                        in_stream, out_stream);
 end:
@@ -168,28 +228,43 @@ 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:
+               bt_field_bool_set_value(out_field,
+                       bt_field_bool_get_value(in_field));
+               break;
+       case 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:
-               bt_field_unsigned_integer_set_value(out_field,
-                               bt_field_unsigned_integer_get_value(in_field));
+               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:
-               bt_field_signed_integer_set_value(out_field,
-                               bt_field_signed_integer_get_value(in_field));
+               bt_field_integer_signed_set_value(out_field,
+                               bt_field_integer_signed_get_value(in_field));
                break;
-       case BT_FIELD_CLASS_TYPE_REAL:
-               bt_field_real_set_value(out_field,
-                               bt_field_real_get_value(in_field));
+       case 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:
+               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:
        {
                const char *str = bt_field_string_get_value(in_field);
-               bt_field_status status = bt_field_string_set_value(out_field, str);
-               if (status != BT_FIELD_STATUS_OK) {
+               bt_field_string_set_value_status status =
+                       bt_field_string_set_value(out_field, str);
+               if (status != BT_FIELD_STRING_SET_VALUE_STATUS_OK) {
                        BT_COMP_LOGE("Cannot set string field's value: "
                                "str-field-addr=%p, str=%s" PRId64,
                                out_field, str);
+                       bt_current_thread_clear_error();
+
                }
                break;
        }
@@ -220,65 +295,96 @@ void copy_field_content(const bt_field *in_field, bt_field *out_field,
                                        member);
                        in_member_field =
                                bt_field_structure_borrow_member_field_by_name_const(
-                                               in_field, in_member_name);
+                                       in_field, in_member_name);
                        out_member_field =
                                bt_field_structure_borrow_member_field_by_name(
-                                               out_field, in_member_name);
+                                       out_field, in_member_name);
 
                        copy_field_content(in_member_field,
                                out_member_field, log_level, self_comp);
                }
                break;
        }
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
+       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:
        {
                const bt_field *in_element_field;
                bt_field *out_element_field;
                uint64_t i, array_len;
-               bt_field_status status;
+               bt_field_array_dynamic_set_length_status set_len_status;
 
                array_len = bt_field_array_get_length(in_field);
 
-               if (in_fc_type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY) {
-                       status = bt_field_dynamic_array_set_length(out_field,
-                                       array_len);
-                       if (status != BT_FIELD_STATUS_OK) {
+               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) {
+                       set_len_status = bt_field_array_dynamic_set_length(
+                               out_field, array_len);
+                       if (set_len_status !=
+                                       BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_OK) {
                                BT_COMP_LOGE("Cannot set dynamic array field's "
                                        "length field: field-addr=%p, "
                                        "length=%" PRIu64, out_field, array_len);
+                               bt_current_thread_clear_error();
                        }
                }
 
                for (i = 0; i < array_len; i++) {
                        in_element_field =
                                bt_field_array_borrow_element_field_by_index_const(
-                                               in_field, i);
+                                       in_field, i);
                        out_element_field =
                                bt_field_array_borrow_element_field_by_index(
-                                               out_field, i);
+                                       out_field, i);
                        copy_field_content(in_element_field, out_element_field,
                                log_level, self_comp);
                }
                break;
        }
-       case BT_FIELD_CLASS_TYPE_VARIANT:
+       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:
+       {
+               const bt_field *in_option_field;
+               bt_field *out_option_field;
+
+               in_option_field = bt_field_option_borrow_field_const(in_field);
+
+               if (in_option_field) {
+                       bt_field_option_set_has_field(out_field, BT_TRUE);
+                       out_option_field = bt_field_option_borrow_field(
+                               out_field);
+                       BT_ASSERT(out_option_field);
+                       copy_field_content(in_option_field, out_option_field,
+                               log_level, self_comp);
+               } 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:
        {
-               bt_field_status status;
+               bt_field_variant_select_option_field_by_index_status sel_opt_status;
                uint64_t in_selected_option_idx;
                const bt_field *in_option_field;
                bt_field *out_option_field;
 
                in_selected_option_idx =
                        bt_field_variant_get_selected_option_field_index(
-                                       in_field);
-               status = bt_field_variant_select_option_field(out_field,
-                               in_selected_option_idx);
-               if (status != BT_FIELD_STATUS_OK) {
+                               in_field);
+               sel_opt_status = bt_field_variant_select_option_field_by_index(out_field,
+                       in_selected_option_idx);
+               if (sel_opt_status !=
+                               BT_FIELD_VARIANT_SELECT_OPTION_FIELD_STATUS_OK) {
                        BT_COMP_LOGE("Cannot select variant field's option field: "
                                "var-field-addr=%p, opt-index=%" PRId64,
                                out_field, in_selected_option_idx);
+                       bt_current_thread_clear_error();
                }
 
                in_option_field = bt_field_variant_borrow_selected_option_field_const(in_field);
This page took 0.026558 seconds and 4 git commands to generate.