X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fdynamic-array.c;h=81c2c3efa15ba1927a61ecc608ea07a9bd9b6f07;hp=69c9c614dd1ff4ad743f2acaee6351b54e962f7d;hb=b7fc068d873bcfc93761f418bfefe8c928c33a59;hpb=2c5ff4e47394f9588ac1a0ab50e8fbdf36727cbe diff --git a/src/common/dynamic-array.c b/src/common/dynamic-array.c index 69c9c614d..81c2c3efa 100644 --- a/src/common/dynamic-array.c +++ b/src/common/dynamic-array.c @@ -1,28 +1,50 @@ /* - * Copyright (C) 2019 - Jérémie Galarneau + * Copyright (C) 2019 Jérémie Galarneau * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License, version 2.1 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: LGPL-2.1-only * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License - * for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include LTTNG_HIDDEN void lttng_dynamic_array_init(struct lttng_dynamic_array *array, - size_t element_size) + size_t element_size, + lttng_dynamic_array_element_destructor destructor) { lttng_dynamic_buffer_init(&array->buffer); array->element_size = element_size; + array->size = 0; + array->destructor = destructor; +} + +LTTNG_HIDDEN +int lttng_dynamic_array_set_count(struct lttng_dynamic_array *array, + size_t new_element_count) +{ + int ret; + + if (!array) { + ret = -1; + goto end; + } + + if (array->destructor) { + size_t i; + + for (i = new_element_count; i < array->size; i++) { + void *element = lttng_dynamic_array_get_element( + array, i); + + array->destructor(element); + } + } + + array->size = new_element_count; + ret = lttng_dynamic_buffer_set_size(&array->buffer, + new_element_count * array->element_size); +end: + return ret; } LTTNG_HIDDEN @@ -47,14 +69,36 @@ end: } LTTNG_HIDDEN -void lttng_dynamic_array_reset(struct lttng_dynamic_array *array, - lttng_dynamic_array_element_destructor destructor) +int lttng_dynamic_array_remove_element(struct lttng_dynamic_array *array, + size_t element_index) { - if (destructor) { + void *element = lttng_dynamic_array_get_element(array, + element_index); + + if (array->destructor) { + array->destructor(element); + } + if (element_index != lttng_dynamic_array_get_count(array) - 1) { + void *next_element = lttng_dynamic_array_get_element(array, + element_index + 1); + + memmove(element, next_element, + (array->size - element_index - 1) * array->element_size); + } + array->size--; + return lttng_dynamic_buffer_set_size(&array->buffer, + array->buffer.size - array->element_size); +} + +LTTNG_HIDDEN +void lttng_dynamic_array_reset(struct lttng_dynamic_array *array) +{ + if (array->destructor) { size_t i; for (i = 0; i < lttng_dynamic_array_get_count(array); i++) { - destructor(lttng_dynamic_array_get_element(array, i)); + array->destructor(lttng_dynamic_array_get_element(array, + i)); } } @@ -62,19 +106,86 @@ void lttng_dynamic_array_reset(struct lttng_dynamic_array *array, array->size = 0; } +LTTNG_HIDDEN +void lttng_dynamic_array_clear(struct lttng_dynamic_array *array) +{ + if (array->destructor) { + size_t i; + + for (i = 0; i < lttng_dynamic_array_get_count(array); i++) { + array->destructor(lttng_dynamic_array_get_element(array, + i)); + } + } + + (void) lttng_dynamic_buffer_set_size(&array->buffer, 0); + array->size = 0; +} + LTTNG_HIDDEN void lttng_dynamic_pointer_array_init( - struct lttng_dynamic_pointer_array *array) + struct lttng_dynamic_pointer_array *array, + lttng_dynamic_pointer_array_destructor destructor) { - lttng_dynamic_array_init(&array->array, sizeof(void *)); + lttng_dynamic_array_init(&array->array, sizeof(void *), destructor); } +LTTNG_HIDDEN +int lttng_dynamic_pointer_array_remove_pointer( + struct lttng_dynamic_pointer_array *array, size_t index) +{ + int ret; + const lttng_dynamic_array_element_destructor destructor = + array->array.destructor; + + /* + * Prevent the destructor from being used by the underlying + * dynamic array. + */ + array->array.destructor = NULL; + if (destructor) { + destructor(lttng_dynamic_pointer_array_get_pointer(array, + index)); + } + ret = lttng_dynamic_array_remove_element(&array->array, index); + array->array.destructor = destructor; + return ret; +} + /* Release any memory used by the dynamic array. */ LTTNG_HIDDEN void lttng_dynamic_pointer_array_reset( - struct lttng_dynamic_pointer_array *array, - lttng_dynamic_pointer_array_destructor destructor) + struct lttng_dynamic_pointer_array *array) { + if (array->array.destructor) { + size_t i, count = lttng_dynamic_pointer_array_get_count(array); + + for (i = 0; i < count; i++) { + void *ptr = lttng_dynamic_pointer_array_get_pointer( + array, i); + array->array.destructor(ptr); + } + /* + * Prevent the destructor from being used by the underlying + * dynamic array. + */ + array->array.destructor = NULL; + } + lttng_dynamic_array_reset(&array->array); +} + +LTTNG_HIDDEN +void lttng_dynamic_pointer_array_clear( + struct lttng_dynamic_pointer_array *array) +{ + const lttng_dynamic_array_element_destructor destructor = + array->array.destructor; + + /* + * Prevent the destructor from being used by the underlying + * dynamic array. + */ + array->array.destructor = NULL; if (destructor) { size_t i, count = lttng_dynamic_pointer_array_get_count(array); @@ -84,5 +195,6 @@ void lttng_dynamic_pointer_array_reset( destructor(ptr); } } - lttng_dynamic_array_reset(&array->array, NULL); + lttng_dynamic_array_clear(&array->array); + array->array.destructor = destructor; }