Always evaluate BT_ASSERT(); add BT_ASSERT_DBG() for debug mode only

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

diff --git a/src/plugins/ctf/fs-sink/fs-sink.c b/src/plugins/ctf/fs-sink/fs-sink.c
index a0c0e5bbe930768ff9879f8d5e70beff59d88bb1..532e542c13c12e9327d3810f09277f51f17f0ffc 100644 (file)
--- a/src/plugins/ctf/fs-sink/fs-sink.c
+++ b/src/plugins/ctf/fs-sink/fs-sink.c
@@ -31,6 +31,7 @@
 #include <glib.h>
 #include "common/assert.h"
 #include "ctfser/ctfser.h"
+#include "plugins/common/param-validation/param-validation.h"
 
 #include "fs-sink.h"
 #include "fs-sink-trace.h"
@@ -64,51 +65,47 @@ end:
        return status;
 }
 
+static struct bt_param_validation_map_value_entry_descr fs_sink_params_descr[] = {
+       { "path", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_MANDATORY, { .type = BT_VALUE_TYPE_STRING } },
+       { "assume-single-trace", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
+       { "ignore-discarded-events", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
+       { "ignore-discarded-packets", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
+       { "quiet", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
+       BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
+};
+
 static
 bt_component_class_initialize_method_status
-configure_component(struct fs_sink_comp *fs_sink,
-               const bt_value *params)
+configure_component(struct fs_sink_comp *fs_sink, const bt_value *params)
 {
-       bt_component_class_initialize_method_status status =
-               BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
+       bt_component_class_initialize_method_status status;
        const bt_value *value;
+       enum bt_param_validation_status validation_status;
+       gchar *validation_error;
 
-       value = bt_value_map_borrow_entry_value_const(params, "path");
-       if (!value) {
-               BT_COMP_LOGE_STR("Missing mandatory `path` parameter.");
+       validation_status = bt_param_validation_validate(params,
+               fs_sink_params_descr, &validation_error);
+       if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) {
                status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
                goto end;
-       }
-
-       if (!bt_value_is_string(value)) {
-               BT_COMP_LOGE_STR("`path` parameter: expecting a string.");
-               status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
+       } else if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) {
+               status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
                goto end;
        }
 
+       value = bt_value_map_borrow_entry_value_const(params, "path");
        g_string_assign(fs_sink->output_dir_path,
                bt_value_string_get(value));
+
        value = bt_value_map_borrow_entry_value_const(params,
                "assume-single-trace");
        if (value) {
-               if (!bt_value_is_bool(value)) {
-                       BT_COMP_LOGE_STR("`assume-single-trace` parameter: expecting a boolean.");
-                       status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
-                       goto end;
-               }
-
                fs_sink->assume_single_trace = (bool) bt_value_bool_get(value);
        }
 
        value = bt_value_map_borrow_entry_value_const(params,
                "ignore-discarded-events");
        if (value) {
-               if (!bt_value_is_bool(value)) {
-                       BT_COMP_LOGE_STR("`ignore-discarded-events` parameter: expecting a boolean.");
-                       status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
-                       goto end;
-               }
-
                fs_sink->ignore_discarded_events =
                        (bool) bt_value_bool_get(value);
        }
@@ -116,12 +113,6 @@ configure_component(struct fs_sink_comp *fs_sink,
        value = bt_value_map_borrow_entry_value_const(params,
                "ignore-discarded-packets");
        if (value) {
-               if (!bt_value_is_bool(value)) {
-                       BT_COMP_LOGE_STR("`ignore-discarded-packets` parameter: expecting a boolean.");
-                       status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
-                       goto end;
-               }
-
                fs_sink->ignore_discarded_packets =
                        (bool) bt_value_bool_get(value);
        }
@@ -129,16 +120,13 @@ configure_component(struct fs_sink_comp *fs_sink,
        value = bt_value_map_borrow_entry_value_const(params,
                "quiet");
        if (value) {
-               if (!bt_value_is_bool(value)) {
-                       BT_COMP_LOGE_STR("`quiet` parameter: expecting a boolean.");
-                       status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
-                       goto end;
-               }
-
                fs_sink->quiet = (bool) bt_value_bool_get(value);
        }
 
+       status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
+
 end:
+       g_free(validation_error);
        return status;
 }
 
@@ -308,7 +296,7 @@ bt_component_class_sink_consume_method_status handle_event_msg(
                goto end;
        }
 
-       BT_ASSERT(ec);
+       BT_ASSERT_DBG(ec);
 
        if (stream->sc->default_clock_class) {
                cs = bt_message_event_borrow_default_clock_snapshot_const(
@@ -350,7 +338,7 @@ bt_component_class_sink_consume_method_status handle_event_msg(
                }
        }
 
-       BT_ASSERT(stream->packet_state.is_open);
+       BT_ASSERT_DBG(stream->packet_state.is_open);
        ret = fs_sink_stream_write_event(stream, cs, ir_event, ec);
        if (G_UNLIKELY(ret)) {
                status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
@@ -999,8 +987,8 @@ bt_component_class_sink_consume_method_status ctf_fs_sink_consume(
 
        fs_sink = bt_self_component_get_data(
                        bt_self_component_sink_as_self_component(self_comp));
-       BT_ASSERT(fs_sink);
-       BT_ASSERT(fs_sink->upstream_iter);
+       BT_ASSERT_DBG(fs_sink);
+       BT_ASSERT_DBG(fs_sink->upstream_iter);
 
        /* Consume messages */
        next_status = bt_self_component_port_input_message_iterator_next(
@@ -1018,7 +1006,7 @@ bt_component_class_sink_consume_method_status ctf_fs_sink_consume(
                for (i = 0; i < msg_count; i++) {
                        const bt_message *msg = msgs[i];
 
-                       BT_ASSERT(msg);
+                       BT_ASSERT_DBG(msg);
 
                        switch (bt_message_get_type(msg)) {
                        case BT_MESSAGE_TYPE_EVENT: