Run clang-format on the whole tree

[lttng-tools.git] / src / common / actions / path.cpp

diff --git a/src/common/actions/path.cpp b/src/common/actions/path.cpp
index 0c8181896dfc612614baebf3775d5a37c250c2e7..0e8d8ec8a8a7b599dda4f3dd9aac80bcb7f475d7 100644 (file)
--- a/src/common/actions/path.cpp
+++ b/src/common/actions/path.cpp
@@ -7,13 +7,14 @@
 
 #include <lttng/action/path-internal.hpp>
 
+namespace {
 struct lttng_action_path_comm {
        uint32_t index_count;
        uint64_t indexes[];
 } LTTNG_PACKED;
+} /* namespace */
 
-struct lttng_action_path *lttng_action_path_create(
-               const uint64_t *indexes, size_t index_count)
+struct lttng_action_path *lttng_action_path_create(const uint64_t *indexes, size_t index_count)
 {
        int ret;
        size_t i;
@@ -23,7 +24,7 @@ struct lttng_action_path *lttng_action_path_create(
                goto error;
        }
 
-       path = (lttng_action_path *) zmalloc(sizeof(*path));
+       path = zmalloc<lttng_action_path>();
        if (!path) {
                goto error;
        }
@@ -31,8 +32,7 @@ struct lttng_action_path *lttng_action_path_create(
        lttng_dynamic_array_init(&path->indexes, sizeof(uint64_t), NULL);
 
        for (i = 0; i < index_count; i++) {
-               ret = lttng_dynamic_array_add_element(
-                               &path->indexes, &indexes[i]);
+               ret = lttng_dynamic_array_add_element(&path->indexes, &indexes[i]);
                if (ret) {
                        goto error;
                }
@@ -46,8 +46,8 @@ end:
        return path;
 }
 
-enum lttng_action_path_status lttng_action_path_get_index_count(
-               const struct lttng_action_path *path, size_t *index_count)
+enum lttng_action_path_status
+lttng_action_path_get_index_count(const struct lttng_action_path *path, size_t *index_count)
 {
        enum lttng_action_path_status status;
 
@@ -63,21 +63,17 @@ end:
 }
 
 enum lttng_action_path_status lttng_action_path_get_index_at_index(
-               const struct lttng_action_path *path,
-               size_t path_index,
-               uint64_t *out_index)
+       const struct lttng_action_path *path, size_t path_index, uint64_t *out_index)
 {
        enum lttng_action_path_status status;
 
-       if (!path || !out_index ||
-                       path_index >= lttng_dynamic_array_get_count(
-                               &path->indexes)) {
+       if (!path || !out_index || path_index >= lttng_dynamic_array_get_count(&path->indexes)) {
                status = LTTNG_ACTION_PATH_STATUS_INVALID;
                goto end;
        }
 
-       *out_index = *((typeof(out_index)) lttng_dynamic_array_get_element(
-                       &path->indexes, path_index));
+       *out_index =
+               *((typeof(out_index)) lttng_dynamic_array_get_element(&path->indexes, path_index));
        status = LTTNG_ACTION_PATH_STATUS_OK;
 end:
        return status;
@@ -95,45 +91,35 @@ end:
        return;
 }
 
-int lttng_action_path_copy(const struct lttng_action_path *src,
-               struct lttng_action_path *dst)
+int lttng_action_path_copy(const struct lttng_action_path *src, struct lttng_action_path **dst)
 {
        int ret;
-       size_t i, src_count;
+       struct lttng_action_path *new_path;
 
        LTTNG_ASSERT(src);
        LTTNG_ASSERT(dst);
 
-       lttng_dynamic_array_init(&dst->indexes, sizeof(uint64_t), NULL);
-       src_count = lttng_dynamic_array_get_count(&src->indexes);
-
-       for (i = 0; i < src_count; i++) {
-               const void *index = lttng_dynamic_array_get_element(
-                               &src->indexes, i);
-
-               ret = lttng_dynamic_array_add_element(&dst->indexes, index);
-               if (ret) {
-                       goto error;
-               }
+       new_path = lttng_action_path_create(
+               (uint64_t *) lttng_dynamic_array_get_element(&src->indexes, 0),
+               lttng_dynamic_array_get_count(&src->indexes));
+       if (!new_path) {
+               ret = -1;
+       } else {
+               ret = 0;
+               *dst = new_path;
        }
 
-       ret = 0;
-       goto end;
-error:
-       lttng_dynamic_array_reset(&dst->indexes);
-end:
        return ret;
 }
 
-ssize_t lttng_action_path_create_from_payload(
-               struct lttng_payload_view *view,
-               struct lttng_action_path **_action_path)
+ssize_t lttng_action_path_create_from_payload(struct lttng_payload_view *view,
+                                             struct lttng_action_path **_action_path)
 {
        ssize_t consumed_size = 0, ret = -1;
        const struct lttng_action_path_comm *header;
        struct lttng_action_path *action_path = NULL;
        const struct lttng_payload_view header_view =
-                       lttng_payload_view_from_view(view, 0, sizeof(*header));
+               lttng_payload_view_from_view(view, 0, sizeof(*header));
 
        if (!lttng_payload_view_is_valid(&header_view)) {
                goto end;
@@ -147,22 +133,17 @@ ssize_t lttng_action_path_create_from_payload(
         * single non-list action. Handle it differently since a payload view of
         * size 0 is considered invalid.
         */
-       if (header->index_count != 0)
-       {
-               const struct lttng_payload_view indexes_view =
-                               lttng_payload_view_from_view(view,
-                                               consumed_size,
-                                               header->index_count *
-                                                               sizeof(uint64_t));
+       if (header->index_count != 0) {
+               const struct lttng_payload_view indexes_view = lttng_payload_view_from_view(
+                       view, consumed_size, header->index_count * sizeof(uint64_t));
 
                if (!lttng_payload_view_is_valid(&indexes_view)) {
                        goto end;
                }
 
                consumed_size += indexes_view.buffer.size;
-               action_path = lttng_action_path_create(
-                               (const uint64_t *) indexes_view.buffer.data,
-                               header->index_count);
+               action_path = lttng_action_path_create((const uint64_t *) indexes_view.buffer.data,
+                                                      header->index_count);
                if (!action_path) {
                        goto end;
                }
@@ -180,7 +161,7 @@ end:
 }
 
 int lttng_action_path_serialize(const struct lttng_action_path *action_path,
-               struct lttng_payload *payload)
+                               struct lttng_payload *payload)
 {
        int ret;
        size_t index_count, i;
@@ -193,25 +174,21 @@ int lttng_action_path_serialize(const struct lttng_action_path *action_path,
                goto end;
        }
 
-       comm = {
-               .index_count = (uint32_t) index_count,
-       };
-       ret = lttng_dynamic_buffer_append(&payload->buffer,
-                       &comm,
-                       sizeof(struct lttng_action_path_comm));
+       comm.index_count = (uint32_t) index_count;
+       ret = lttng_dynamic_buffer_append(
+               &payload->buffer, &comm, sizeof(struct lttng_action_path_comm));
 
        for (i = 0; i < index_count; i++) {
                uint64_t path_index;
 
-               status = lttng_action_path_get_index_at_index(
-                               action_path, i, &path_index);
+               status = lttng_action_path_get_index_at_index(action_path, i, &path_index);
                if (status != LTTNG_ACTION_PATH_STATUS_OK) {
                        ret = -1;
                        goto end;
                }
 
-               ret = lttng_dynamic_buffer_append(&payload->buffer, &path_index,
-                               sizeof(path_index));
+               ret = lttng_dynamic_buffer_append(
+                       &payload->buffer, &path_index, sizeof(path_index));
                if (ret) {
                        goto end;
                }