src/common/dynamic-array.c

   1 /*
   2  * Copyright (C) 2019 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License, version 2.1 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
  11  * for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this program; if not, write to the Free Software Foundation,
  15  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  16  */
  17
  18 #include <common/dynamic-array.h>
  19
  20 LTTNG_HIDDEN
  21 void lttng_dynamic_array_init(struct lttng_dynamic_array *array,
  22                 size_t element_size,
  23                 lttng_dynamic_array_element_destructor destructor)
  24 {
  25         lttng_dynamic_buffer_init(&array->buffer);
  26         array->element_size = element_size;
  27         array->size = 0;
  28         array->destructor = destructor;
  29 }
  30
  31 LTTNG_HIDDEN
  32 int lttng_dynamic_array_add_element(struct lttng_dynamic_array *array,
  33                 const void *element)
  34 {
  35         int ret;
  36
  37         if (!array || !element) {
  38                 ret = -1;
  39                 goto end;
  40         }
  41
  42         ret = lttng_dynamic_buffer_append(&array->buffer, element,
  43                         array->element_size);
  44         if (ret) {
  45                 goto end;
  46         }
  47         array->size++;
  48 end:
  49         return ret;
  50 }
  51
  52 LTTNG_HIDDEN
  53 int lttng_dynamic_array_remove_element(struct lttng_dynamic_array *array,
  54                 size_t element_index)
  55 {
  56         void *element = lttng_dynamic_array_get_element(array,
  57                         element_index);
  58
  59         if (array->destructor) {
  60                 array->destructor(element);
  61         }
  62         if (element_index != lttng_dynamic_array_get_count(array) - 1) {
  63                 void *next_element = lttng_dynamic_array_get_element(array,
  64                                 element_index + 1);
  65
  66                 memmove(element, next_element,
  67                                 (array->size - element_index - 1) * array->element_size);
  68         }
  69         array->size--;
  70         return lttng_dynamic_buffer_set_size(&array->buffer,
  71                         array->buffer.size - array->element_size);
  72 }
  73
  74 LTTNG_HIDDEN
  75 void lttng_dynamic_array_reset(struct lttng_dynamic_array *array)
  76 {
  77         if (array->destructor) {
  78                 size_t i;
  79
  80                 for (i = 0; i < lttng_dynamic_array_get_count(array); i++) {
  81                         array->destructor(lttng_dynamic_array_get_element(array,
  82                                         i));
  83                 }
  84         }
  85
  86         lttng_dynamic_buffer_reset(&array->buffer);
  87         array->size = 0;
  88 }
  89
  90 LTTNG_HIDDEN
  91 void lttng_dynamic_array_clear(struct lttng_dynamic_array *array)
  92 {
  93         if (array->destructor) {
  94                 size_t i;
  95
  96                 for (i = 0; i < lttng_dynamic_array_get_count(array); i++) {
  97                         array->destructor(lttng_dynamic_array_get_element(array,
  98                                         i));
  99                 }
 100         }
 101
 102         lttng_dynamic_buffer_set_size(&array->buffer, 0);
 103         array->size = 0;
 104 }
 105
 106 LTTNG_HIDDEN
 107 void lttng_dynamic_pointer_array_init(
 108                 struct lttng_dynamic_pointer_array *array,
 109                 lttng_dynamic_pointer_array_destructor destructor)
 110 {
 111         lttng_dynamic_array_init(&array->array, sizeof(void *), destructor);
 112 }
 113
 114 LTTNG_HIDDEN
 115 int lttng_dynamic_pointer_array_remove_pointer(
 116                 struct lttng_dynamic_pointer_array *array, size_t index)
 117 {
 118         int ret;
 119         const lttng_dynamic_array_element_destructor destructor =
 120                         array->array.destructor;
 121
 122         /*
 123          * Prevent the destructor from being used by the underlying
 124          * dynamic array.
 125          */
 126         array->array.destructor = NULL;
 127         if (destructor) {
 128                 destructor(lttng_dynamic_pointer_array_get_pointer(array,
 129                                 index));
 130         }
 131         ret = lttng_dynamic_array_remove_element(&array->array, index);
 132         array->array.destructor = destructor;
 133         return ret;
 134 }
 135
 136 /* Release any memory used by the dynamic array. */
 137 LTTNG_HIDDEN
 138 void lttng_dynamic_pointer_array_reset(
 139                 struct lttng_dynamic_pointer_array *array)
 140 {
 141         if (array->array.destructor) {
 142                 size_t i, count = lttng_dynamic_pointer_array_get_count(array);
 143
 144                 for (i = 0; i < count; i++) {
 145                         void *ptr = lttng_dynamic_pointer_array_get_pointer(
 146                                         array, i);
 147                         array->array.destructor(ptr);
 148                 }
 149                 /*
 150                  * Prevent the destructor from being used by the underlying
 151                  * dynamic array.
 152                  */
 153                 array->array.destructor = NULL;
 154         }
 155         lttng_dynamic_array_reset(&array->array);
 156 }
 157
 158 LTTNG_HIDDEN
 159 void lttng_dynamic_pointer_array_clear(
 160                 struct lttng_dynamic_pointer_array *array)
 161 {
 162         const lttng_dynamic_array_element_destructor destructor =
 163                         array->array.destructor;
 164
 165         /*
 166          * Prevent the destructor from being used by the underlying
 167          * dynamic array.
 168          */
 169         array->array.destructor = NULL;
 170         if (destructor) {
 171                 size_t i, count = lttng_dynamic_pointer_array_get_count(array);
 172
 173                 for (i = 0; i < count; i++) {
 174                         void *ptr = lttng_dynamic_pointer_array_get_pointer(
 175                                         array, i);
 176                         destructor(ptr);
 177                 }
 178         }
 179         lttng_dynamic_array_clear(&array->array);
 180         array->array.destructor = destructor;
 181 }