PengZheng commented on code in PR #727:
URL: https://github.com/apache/celix/pull/727#discussion_r1487909520
##########
libs/utils/src/array_list.c:
##########
@@ -56,47 +158,171 @@ static void
celix_arrayList_callRemovedCallback(celix_array_list_t *list, int in
}
static celix_status_t celix_arrayList_ensureCapacity(celix_array_list_t* list,
int capacity) {
- celix_status_t status = CELIX_SUCCESS;
celix_array_list_entry_t *newList;
list->modCount++;
size_t oldCapacity = list->capacity;
if (capacity > oldCapacity) {
size_t newCapacity = (oldCapacity * 3) / 2 + 1;
- if (newCapacity < capacity) {
- newCapacity = capacity;
- }
newList = realloc(list->elementData, sizeof(celix_array_list_entry_t)
* newCapacity);
- if (newList != NULL) {
- list->capacity = newCapacity;
- list->elementData = newList;
+ if (!newList) {
Review Comment:
This illustrates the correct usage pattern of `realloc`. Almost all (if not
all) other usages in Celix suffer from memory leaks when `realloc` fails. I'll
create an issue for there incorrect usages.
##########
libs/utils/src/array_list.c:
##########
@@ -16,34 +16,136 @@
* specific language governing permissions and limitations
* under the License.
*/
-/**
- * array_list.c
- *
- * \date Aug 4, 2010
- * \author <a href="mailto:dev@celix.apache.org";>Apache Celix Project
Team</a>
- * \copyright Apache License, Version 2.0
- */
-#include <stdlib.h>
+#include <assert.h>
+#include <stdint.h>
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
#include "celix_array_list.h"
-#include "array_list_private.h"
#include "celix_build_assert.h"
+#include "celix_err.h"
+#include "celix_stdlib_cleanup.h"
+#include "celix_utils.h"
+
+struct celix_array_list {
+ celix_array_list_element_type_t elementType;
+ celix_array_list_entry_t* elementData;
+ size_t size;
+ size_t capacity;
+ unsigned int modCount;
Review Comment:
There seems no essential usage of this filed.
##########
libs/utils/src/array_list.c:
##########
@@ -16,34 +16,136 @@
* specific language governing permissions and limitations
* under the License.
*/
-/**
- * array_list.c
- *
- * \date Aug 4, 2010
- * \author <a href="mailto:dev@celix.apache.org";>Apache Celix Project
Team</a>
- * \copyright Apache License, Version 2.0
- */
-#include <stdlib.h>
+#include <assert.h>
+#include <stdint.h>
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
#include "celix_array_list.h"
-#include "array_list_private.h"
#include "celix_build_assert.h"
+#include "celix_err.h"
+#include "celix_stdlib_cleanup.h"
+#include "celix_utils.h"
+
+struct celix_array_list {
+ celix_array_list_element_type_t elementType;
+ celix_array_list_entry_t* elementData;
+ size_t size;
+ size_t capacity;
+ unsigned int modCount;
+ celix_arrayList_equals_fp equalsCallback;
+ celix_array_list_compare_entries_fp compareCallback;
+ void (*simpleRemovedCallback)(void* value);
+ void* removedCallbackData;
+ void (*removedCallback)(void* data, celix_array_list_entry_t entry);
+};
+
+static bool celix_arrayList_undefinedEquals(celix_array_list_entry_t a,
celix_array_list_entry_t b) {
+ return memcmp(&a.voidPtrVal, &b.voidPtrVal, sizeof(a)) == 0;
+}
+
+static int celix_arrayList_comparePtrEntries(celix_array_list_entry_t a,
celix_array_list_entry_t b) {
+ uintptr_t ptrA = (uintptr_t)a.voidPtrVal;
+ uintptr_t ptrB = (uintptr_t)b.voidPtrVal;
+ return (int)(ptrA - ptrB);
Review Comment:
When ptrA-ptrB == 0xFFFFFFFF00000000 (lower 32-bits all zero), what is the
return value?
##########
libs/utils/src/array_list.c:
##########
@@ -120,111 +350,210 @@ static celix_array_list_entry_t
arrayList_getEntry(const celix_array_list_t *lis
return entry;
}
-void* celix_arrayList_get(const celix_array_list_t *list, int index) {
+void* celix_arrayList_get(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_POINTER ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).voidPtrVal;
}
-int celix_arrayList_getInt(const celix_array_list_t* list, int index) { return
arrayList_getEntry(list, index).intVal; }
+const char* celix_arrayList_getString(const celix_array_list_t* list, int
index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING_REF ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
+ return arrayList_getEntry(list, index).stringVal;
+}
+
+int celix_arrayList_getInt(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_INT ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
+ return arrayList_getEntry(list, index).intVal;
+}
long int celix_arrayList_getLong(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_LONG ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).longVal;
}
unsigned int celix_arrayList_getUInt(const celix_array_list_t* list, int
index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UINT ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).uintVal;
}
unsigned long int celix_arrayList_getULong(const celix_array_list_t* list, int
index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_ULONG ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).ulongVal;
}
float celix_arrayList_getFloat(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_FLOAT ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).floatVal;
}
double celix_arrayList_getDouble(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_DOUBLE ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).doubleVal;
}
bool celix_arrayList_getBool(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_BOOL ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).boolVal;
}
size_t celix_arrayList_getSize(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_SIZE ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).sizeVal;
}
-static celix_status_t celix_arrayList_addEntry(celix_array_list_t *list,
celix_array_list_entry_t entry) {
+const celix_version_t* celix_arrayList_getVersion(const celix_array_list_t*
list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_VERSION);
+ return arrayList_getEntry(list, index).versionVal;
+}
+
+static celix_status_t celix_arrayList_addEntry(celix_array_list_t* list,
celix_array_list_entry_t entry) {
celix_status_t status = celix_arrayList_ensureCapacity(list,
(int)list->size + 1);
if (status == CELIX_SUCCESS) {
list->elementData[list->size++] = entry;
}
return status;
}
-celix_status_t celix_arrayList_add(celix_array_list_t *list, void * element) {
+celix_status_t celix_arrayList_add(celix_array_list_t* list, void* element) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_POINTER ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
celix_array_list_entry_t entry;
memset(&entry, 0, sizeof(entry));
entry.voidPtrVal = element;
return celix_arrayList_addEntry(list, entry);
}
-celix_status_t celix_arrayList_addInt(celix_array_list_t *list, int val) {
+celix_status_t celix_arrayList_addString(celix_array_list_t* list, const char*
val) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING_REF ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
+ celix_array_list_entry_t entry;
+ memset(&entry, 0, sizeof(entry));
+ if (list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING && val) {
+ entry.stringVal = celix_utils_strdup(val);
+ if (entry.stringVal == NULL) {
+ return CELIX_ENOMEM;
+ }
+ } else {
+ entry.stringVal = val;
+ }
+ return celix_arrayList_addEntry(list, entry);
+}
+
+celix_status_t celix_arrayList_assignString(celix_array_list_t* list, char*
value) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING);
+ celix_array_list_entry_t entry;
+ memset(&entry, 0, sizeof(entry));
+ entry.stringVal = value;
+ return celix_arrayList_addEntry(list, entry);
Review Comment:
`value` (copy of `value` for addXXX) is leaked if `celix_arrayList_addEntry`
fails.
This remark also applies to
`celix_arrayList_assignVersion`/`celix_arrayList_addString`/`celix_arrayList_addVersion`.
##########
libs/utils/src/array_list.c:
##########
@@ -337,31 +702,69 @@ static int celix_arrayList_compareEntries(const void*
voidA, const void* voidB,
return compare(*a, *b);
}
-void celix_arrayList_sortEntries(celix_array_list_t *list,
celix_array_list_compare_entries_fp compare) {
-#if defined(__APPLE__)
- qsort_r(list->elementData, list->size, sizeof(celix_array_list_entry_t),
compare, celix_arrayList_compareEntries);
-#else
- qsort_r(list->elementData, list->size, sizeof(celix_array_list_entry_t),
celix_arrayList_compareEntries, compare);
-#endif
+void celix_arrayList_sort(celix_array_list_t *list) {
+ if (list->compareCallback) {
+ celix_arrayList_sortEntries(list, list->compareCallback);
+ }
}
-#if defined(__APPLE__)
-static int celix_arrayList_compare(void *arg, const void * a, const void *b) {
-#else
-static int celix_arrayList_compare(const void * a, const void *b, void *arg) {
-#endif
- const celix_array_list_entry_t *aEntry = a;
- const celix_array_list_entry_t *bEntry = b;
+bool celix_arrayList_equals(const celix_array_list_t* listA, const
celix_array_list_t* listB) {
+ if (listA == listB) {
+ return true;
+ }
+ if (!listA || !listB) {
+ return false;
+ }
+ if (listA->size != listB->size) {
+ return false;
+ }
+ if (listA->equalsCallback != listB->equalsCallback) {
+ return false;
+ }
+ for (int i = 0; i < listA->size; ++i) {
+ if (!listA->equalsCallback(listA->elementData[i],
listB->elementData[i])) {
+ return false;
+ }
+ }
+ return true;
+}
- celix_arrayList_sort_fp sort = arg;
+celix_array_list_t* celix_arrayList_copy(const celix_array_list_t* list) {
+ celix_array_list_create_options_t opts =
CELIX_EMPTY_ARRAY_LIST_CREATE_OPTIONS;
+ opts.elementType = list->elementType;
+ opts.equalsCallback = list->equalsCallback;
+ opts.compareCallback = list->compareCallback;
+ opts.removedCallback = list->removedCallback;
+ opts.removedCallbackData = list->removedCallbackData;
+ opts.simpleRemovedCallback = list->simpleRemovedCallback;
+ celix_autoptr(celix_array_list_t) copy =
celix_arrayList_createWithOptions(&opts);
+ if (!copy) {
+ return NULL;
+ }
+
+ for (int i = 0; i < celix_arrayList_size(list); ++i) {
+ celix_array_list_entry_t entry = list->elementData[i];
+ celix_status_t status;
+ if (copy->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING) {
+ status = celix_arrayList_addString(copy, entry.stringVal);
+ } else if (copy->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_VERSION)
{
+ status = celix_arrayList_addVersion(copy, entry.versionVal);
+ } else {
+ status = celix_arrayList_addEntry(copy, entry);
Review Comment:
If `CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED` is not only intended for
backward compatibility but also for support user-provided type, then
shallow-copy is not sufficient. If it is only used for compatibility and future
extension without modification is not allowed, then the current implementation
is OK.
##########
libs/utils/src/array_list.c:
##########
@@ -16,34 +16,136 @@
* specific language governing permissions and limitations
* under the License.
*/
-/**
- * array_list.c
- *
- * \date Aug 4, 2010
- * \author <a href="mailto:dev@celix.apache.org";>Apache Celix Project
Team</a>
- * \copyright Apache License, Version 2.0
- */
-#include <stdlib.h>
+#include <assert.h>
+#include <stdint.h>
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
#include "celix_array_list.h"
-#include "array_list_private.h"
#include "celix_build_assert.h"
+#include "celix_err.h"
+#include "celix_stdlib_cleanup.h"
+#include "celix_utils.h"
+
+struct celix_array_list {
+ celix_array_list_element_type_t elementType;
+ celix_array_list_entry_t* elementData;
+ size_t size;
+ size_t capacity;
+ unsigned int modCount;
+ celix_arrayList_equals_fp equalsCallback;
+ celix_array_list_compare_entries_fp compareCallback;
+ void (*simpleRemovedCallback)(void* value);
+ void* removedCallbackData;
+ void (*removedCallback)(void* data, celix_array_list_entry_t entry);
+};
+
+static bool celix_arrayList_undefinedEquals(celix_array_list_entry_t a,
celix_array_list_entry_t b) {
+ return memcmp(&a.voidPtrVal, &b.voidPtrVal, sizeof(a)) == 0;
+}
+
+static int celix_arrayList_comparePtrEntries(celix_array_list_entry_t a,
celix_array_list_entry_t b) {
+ uintptr_t ptrA = (uintptr_t)a.voidPtrVal;
+ uintptr_t ptrB = (uintptr_t)b.voidPtrVal;
+ return (int)(ptrA - ptrB);
Review Comment:
There is no need of subtraction and cast. Returning +1/0/-1 for ptrA >=<
ptrB should be enough and correct.
##########
libs/utils/src/array_list.c:
##########
@@ -56,47 +158,171 @@ static void
celix_arrayList_callRemovedCallback(celix_array_list_t *list, int in
}
static celix_status_t celix_arrayList_ensureCapacity(celix_array_list_t* list,
int capacity) {
- celix_status_t status = CELIX_SUCCESS;
celix_array_list_entry_t *newList;
list->modCount++;
size_t oldCapacity = list->capacity;
if (capacity > oldCapacity) {
size_t newCapacity = (oldCapacity * 3) / 2 + 1;
- if (newCapacity < capacity) {
- newCapacity = capacity;
- }
newList = realloc(list->elementData, sizeof(celix_array_list_entry_t)
* newCapacity);
- if (newList != NULL) {
- list->capacity = newCapacity;
- list->elementData = newList;
+ if (!newList) {
+ celix_err_push("Failed to reallocate memory for elementData");
+ return CELIX_ENOMEM;
}
- status = newList == NULL ? CELIX_ENOMEM : CELIX_SUCCESS;
+ list->capacity = newCapacity;
+ list->elementData = newList;
+ }
+ return CELIX_SUCCESS;
+}
+
+static void celix_arrayList_setTypeSpecificCallbacks(celix_array_list_t* list)
{
+ switch (list->elementType) {
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_POINTER:
+ list->equalsCallback = celix_arrayList_PtrEquals;
+ list->compareCallback = celix_arrayList_comparePtrEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING:
+ list->simpleRemovedCallback = free;
+ list->equalsCallback = celix_arrayList_stringEquals;
+ list->compareCallback = celix_arrayList_compareStringEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING_REF:
+ list->equalsCallback = celix_arrayList_stringEquals;
+ list->compareCallback = celix_arrayList_compareStringEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_INT:
+ list->equalsCallback = celix_arrayList_intEquals;
+ list->compareCallback = celix_arrayList_compareIntEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_LONG:
+ list->equalsCallback = celix_arrayList_longEquals;
+ list->compareCallback = celix_arrayList_compareLongEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_UINT:
+ list->equalsCallback = celix_arrayList_uintEquals;
+ list->compareCallback = celix_arrayList_compareUIntEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_ULONG:
+ list->equalsCallback = celix_arrayList_ulongEquals;
+ list->compareCallback = celix_arrayList_compareULongEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_FLOAT:
+ list->equalsCallback = celix_arrayList_floatEquals;
+ list->compareCallback = celix_arrayList_compareFloatEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_DOUBLE:
+ list->equalsCallback = celix_arrayList_doubleEquals;
+ list->compareCallback = celix_arrayList_compareDoubleEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_BOOL:
+ list->equalsCallback = celix_arrayList_boolEquals;
+ list->compareCallback = celix_arrayList_compareBoolEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_SIZE:
+ list->equalsCallback = celix_arrayList_sizeEquals;
+ list->compareCallback = celix_arrayList_compareSizeEntries;
+ break;
+ case CELIX_ARRAY_LIST_ELEMENT_TYPE_VERSION:
+ list->simpleRemovedCallback = celix_arrayList_destroyVersion;
+ list->equalsCallback = celix_arrayList_versionEquals;
+ list->compareCallback = celix_arrayList_compareVersionEntries;
+ break;
+ default:
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
+ list->equalsCallback = celix_arrayList_undefinedEquals;
+ break;
}
- return status;
}
celix_array_list_t* celix_arrayList_createWithOptions(const
celix_array_list_create_options_t* opts) {
- celix_array_list_t *list = calloc(1, sizeof(*list));
- if (list != NULL) {
- list->capacity = 10;
- list->elementData = malloc(sizeof(celix_array_list_entry_t) *
list->capacity);
- list->equals = opts->equalsCallback == NULL ?
celix_arrayList_defaultEquals : opts->equalsCallback;
+ celix_autofree celix_array_list_t *list = calloc(1, sizeof(*list));
+ if (!list) {
+ celix_err_push("Failed to allocate memory for list");
+ return NULL;
+ }
+
+ list->capacity = 10;
+ list->elementData = malloc(sizeof(celix_array_list_entry_t) *
list->capacity);
Review Comment:
`calloc` shoudl be used instead. `malloc` suffers from multiplication
overflow, while `calloc` does not.
##########
libs/utils/gtest/src/ArrayListTestSuite.cc:
##########
@@ -261,4 +527,84 @@ TEST_F(ArrayListTestSuite, TestReturnStatusAddFunctions) {
TEST_F(ArrayListTestSuite, AutoCleanupTest) {
celix_autoptr(celix_array_list_t) list = celix_arrayList_create();
EXPECT_NE(nullptr, list);
-}
\ No newline at end of file
+}
+
+TEST_F(ArrayListTestSuite, AddNullTest) {
+ // Given an undefined type, string, string ref and version list
+ celix_autoptr(celix_array_list_t) list = celix_arrayList_create();
+ celix_autoptr(celix_array_list_t) stringList =
celix_arrayList_createStringArray();
+ celix_autoptr(celix_array_list_t) stringRefList =
celix_arrayList_createStringRefArray();
+ celix_autoptr(celix_array_list_t) versionList =
celix_arrayList_createVersionArray();
+
+ // When adding a null value to the lists
+ celix_arrayList_add(list, nullptr);
+ celix_arrayList_addString(stringList, nullptr);
+ celix_arrayList_addString(stringRefList, nullptr);
+ celix_arrayList_addVersion(versionList, nullptr);
Review Comment:
I'm not sure whether `nullptr` should be allowed at all. Note that in JSON,
`null` is neither an object or a string. By allowing `nullptr`, the caller is
responsible for null-checking, which will lead to lots of boilerplate codes.
##########
libs/utils/src/array_list.c:
##########
@@ -120,111 +350,210 @@ static celix_array_list_entry_t
arrayList_getEntry(const celix_array_list_t *lis
return entry;
}
-void* celix_arrayList_get(const celix_array_list_t *list, int index) {
+void* celix_arrayList_get(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_POINTER ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).voidPtrVal;
}
-int celix_arrayList_getInt(const celix_array_list_t* list, int index) { return
arrayList_getEntry(list, index).intVal; }
+const char* celix_arrayList_getString(const celix_array_list_t* list, int
index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING_REF ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
+ return arrayList_getEntry(list, index).stringVal;
+}
+
+int celix_arrayList_getInt(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_INT ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
+ return arrayList_getEntry(list, index).intVal;
+}
long int celix_arrayList_getLong(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_LONG ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).longVal;
}
unsigned int celix_arrayList_getUInt(const celix_array_list_t* list, int
index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UINT ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).uintVal;
}
unsigned long int celix_arrayList_getULong(const celix_array_list_t* list, int
index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_ULONG ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).ulongVal;
}
float celix_arrayList_getFloat(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_FLOAT ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).floatVal;
}
double celix_arrayList_getDouble(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_DOUBLE ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).doubleVal;
}
bool celix_arrayList_getBool(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_BOOL ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).boolVal;
}
size_t celix_arrayList_getSize(const celix_array_list_t* list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_SIZE ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
return arrayList_getEntry(list, index).sizeVal;
}
-static celix_status_t celix_arrayList_addEntry(celix_array_list_t *list,
celix_array_list_entry_t entry) {
+const celix_version_t* celix_arrayList_getVersion(const celix_array_list_t*
list, int index) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_VERSION);
+ return arrayList_getEntry(list, index).versionVal;
+}
+
+static celix_status_t celix_arrayList_addEntry(celix_array_list_t* list,
celix_array_list_entry_t entry) {
celix_status_t status = celix_arrayList_ensureCapacity(list,
(int)list->size + 1);
if (status == CELIX_SUCCESS) {
list->elementData[list->size++] = entry;
}
return status;
}
-celix_status_t celix_arrayList_add(celix_array_list_t *list, void * element) {
+celix_status_t celix_arrayList_add(celix_array_list_t* list, void* element) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_POINTER ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
celix_array_list_entry_t entry;
memset(&entry, 0, sizeof(entry));
entry.voidPtrVal = element;
return celix_arrayList_addEntry(list, entry);
}
-celix_status_t celix_arrayList_addInt(celix_array_list_t *list, int val) {
+celix_status_t celix_arrayList_addString(celix_array_list_t* list, const char*
val) {
+ assert(list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING_REF ||
+ list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_UNDEFINED);
+ celix_array_list_entry_t entry;
+ memset(&entry, 0, sizeof(entry));
+ if (list->elementType == CELIX_ARRAY_LIST_ELEMENT_TYPE_STRING && val) {
Review Comment:
IIRC, `nullptr` is not allowed in `celix_properties` but is allowed here.
This remark also applies to versionArray.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: dev-unsubscr...@celix.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
