#include <stdlib.h>
#include <string.h>
-#include <errno.h>
static keyval_method_collection_t method = {
};
keyval_array_t *
-keyval_array_new(keyval_array_t *kva, const char *key, const int type, const void **array_val, const unsigned int len)
+keyval_array_new(keyval_array_t *kva, const char *key, const int type,
+ const void **array_val, const unsigned int len)
{
int must_free_obj;
must_free_obj = kva ? 0 : 1;
- if(!kva) {
+ if (!kva) {
kva = calloc(1, sizeof(keyval_array_t));
- if(unlikely(NULL==kva)) {
- errno = ENOMEM;
+ if (unlikely(NULL == kva)) {
+ set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
return NULL;
}
}
- // keyval setting
+ /* keyval setting */
keyval_t *kv = keyval_new((keyval_t *)kva, key, type, NULL, 0);
- if(unlikely(NULL==kv))
- {
- errno = ENOMEM;
+ if (unlikely(NULL == kv)) {
+ set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
return NULL;
}
kva->len = len;
- // Set array value, if exist
- if(kva->array_val) {
- errno=EINVAL;
- if(must_free_obj) keyval_array_free(kva, 1);
+ /* Set array value, if exist */
+ if (kva->array_val) {
+ set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
+ if (must_free_obj)
+ keyval_array_free(kva, 1);
return NULL;
}
kva->array_val = calloc(len, sizeof(void *));
- if(!(kva->array_val)) {
- errno = ENOMEM;
+ if (!(kva->array_val)) {
+ set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
keyval_array_free(kva, 1);
return NULL;
}
- // array_element_size
+ /* array_element_size */
kva->array_element_size = calloc(len, sizeof(size_t));
- if(!(kva->array_element_size)) {
- errno = ENOMEM;
+ if (!(kva->array_element_size)) {
+ set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
keyval_array_free(kva, 1);
return NULL;
}
- // If avaliable, copy array val
- if(array_val
+ /* If available, copy array val */
+ if (array_val
&& keyval_type_is_measurable(type)
&& keyval_type_get_measure_size_func(type)) {
- // array_val have original data array. copy it!
+ /* array_val have original data array. copy it! */
- if(keyval_array_copy_array((keyval_array_t*)kv,
- (void**)array_val,
+ if (keyval_array_copy_array((keyval_array_t *)kv,
+ (void **)array_val,
len,
keyval_type_get_measure_size_func(type))
) {
}
}
- // Set methods
+ /* Set methods */
kv->method = &method;
return kva;
void
keyval_array_free(keyval_array_t *kva, int do_free_object)
{
- if(!kva) return;
+ if (!kva)
+ return;
- // free keyval_array elements
+ /* free keyval_array elements */
free(kva->array_element_size);
int i;
- for(i=0; i<kva->len; i++) {
- if(kva->array_val[i]) free(kva->array_val[i]);
+ for (i = 0; i < kva->len; i++) {
+ if (kva->array_val[i])
+ free(kva->array_val[i]);
}
free(kva->array_val);
-
- // free parent
+
+ /* free parent */
keyval_free((keyval_t *)kva, 0);
- // free object
- if(do_free_object) free(kva);
+ /* free object */
+ if (do_free_object)
+ free(kva);
}
-int
+int
keyval_array_compare(keyval_array_t *kva1, keyval_array_t *kva2)
{
keyval_t *kv1, *kv2;
- if(!kva1 || !kva2) return -1;
+ if (!kva1 || !kva2)
+ return -1;
kv1 = (keyval_t *)kva1;
kv2 = (keyval_t *)kva2;
- if(0 != strcmp(kv1->key, kv2->key)) return 1;
- if(kv1->type != kv2->type) return 1;
- if(kva1->len != kva2->len) return 1;
+ if (0 != strcmp(kv1->key, kv2->key))
+ return 1;
+ if (kv1->type != kv2->type)
+ return 1;
+ if (kva1->len != kva2->len)
+ return 1;
int i;
- for(i=0; i<kva1->len; i++) {
- if(kva1->array_val[i] == NULL && kva2->array_val[i] == NULL) continue;
- if(kva1->array_val[i] == NULL || kva2->array_val[i] == NULL) return 1;
- if(0 != memcmp(kva1->array_val[i], kva2->array_val[i], kva1->array_element_size[i])) return 1;
+ for (i = 0; i < kva1->len; i++) {
+ if (kva1->array_val[i] == NULL && kva2->array_val[i] == NULL)
+ continue;
+ if (kva1->array_val[i] == NULL || kva2->array_val[i] == NULL)
+ return 1;
+ if (0 != memcmp(kva1->array_val[i], kva2->array_val[i],
+ kva1->array_element_size[i]))
+ return 1;
}
return 0;
}
int
-keyval_array_copy_array(keyval_array_t *kva, void **array_val, unsigned int array_len, size_t (*measure_val_len)(void * val))
+keyval_array_copy_array(keyval_array_t *kva, void **array_val,
+ unsigned int array_len, size_t (*measure_val_len)(void *val))
{
keyval_t *kv = (keyval_t *)kva;
-
- // Get measure_size function of the value type
- keyval_type_measure_size_func_t measure_size = keyval_type_get_measure_size_func(kv->type);
- if(!measure_size) return -1;
-
- // Copy each array item
int i;
- for(i=0; i < array_len; i++) {
+
+ /* Get measure_size function of the value type */
+ keyval_type_measure_size_func_t measure_size =
+ keyval_type_get_measure_size_func(kv->type);
+ if (!measure_size)
+ return -1;
+
+ /* Copy each array item */
+ for (i = 0; i < array_len; i++) {
kva->array_val[i] = malloc(measure_size(array_val[i]));
- if(!(kva->array_val[i])) {
- errno = ENOMEM;
+ if (!(kva->array_val[i])) {
+ set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
goto cleanup_exit;
}
- memcpy(kva->array_val[i], array_val[i], measure_size(array_val[i]));
+ memcpy(kva->array_val[i], array_val[i],
+ measure_size(array_val[i]));
kva->array_element_size[i] = measure_size(array_val[i]);
}
return 0;
cleanup_exit:
- for(i=0; i<array_len; i++) {
- if(kva->array_val[i]) {
+ for (i = 0; i < array_len; i++) {
+ if (kva->array_val[i]) {
free(kva->array_val[i]);
kva->array_val[i] = NULL;
}
int
keyval_array_is_idx_valid(keyval_array_t *kva, int idx)
{
- //keyval_t *kv = (keyval_t *)kva;
- if(kva && kva->len > idx && 0 <= idx) return 1;
+ if (kva && kva->len > idx && 0 <= idx)
+ return 1;
return 0;
}
int
keyval_array_set_element(keyval_array_t *kva, int idx, void *val, size_t size)
{
- if(kva->array_val[idx]) { // An element is already exist in the idx!
- if(!val) { // val==NULL means 'Free this element!'
+ /* An element is already exist in the idx! */
+ if (kva->array_val[idx]) {
+ /* val==NULL means 'Free this element!' */
+ if (!val) {
free(kva->array_val[idx]);
kva->array_val[idx] = NULL;
kva->array_element_size[idx] = 0;
+ } else {
+ /* Error case! */
+ return BUNDLE_ERROR_INVALID_PARAMETER;
}
- else {
- // Error case!
- errno = EINVAL;
- return -1;
- }
- }
- else {
- // Normal case. Copy value into the array.
+ } else {
+ /* Normal case. Copy value into the array. */
kva->array_val[idx] = malloc(size);
- if(!(kva->array_val[idx])) {
- errno = ENOMEM;
- return -1;
- }
- if(val) {
- memcpy(kva->array_val[idx], val, size); // val
- kva->array_element_size[idx] = size; // size
+ if (!(kva->array_val[idx]))
+ return BUNDLE_ERROR_OUT_OF_MEMORY;
+ if (val) {
+ memcpy(kva->array_val[idx], val, size);
+ kva->array_element_size[idx] = size;
}
}
- return 0;
+ return BUNDLE_ERROR_NONE;
}
int
keyval_array_get_data(keyval_array_t *kva, int *type,
void ***array_val, unsigned int *len, size_t **array_element_size)
{
- if(!kva) return -EINVAL;
+ if (!kva)
+ return BUNDLE_ERROR_INVALID_PARAMETER;
keyval_t *kv = (keyval_t *)kva;
- if(!keyval_type_is_array(kv->type)) return -EINVAL;
-
- // Return values
- if(type) *type = kv->type;
- if(array_val) *array_val = kva->array_val;
- if(len) *len = kva->len;
- if(array_element_size) *array_element_size = kva->array_element_size;
-
- return 0;
+ if (!keyval_type_is_array(kv->type))
+ return BUNDLE_ERROR_INVALID_PARAMETER;
+
+ /* Return values */
+ if (type)
+ *type = kv->type;
+ if (array_val)
+ *array_val = kva->array_val;
+ if (len)
+ *len = kva->len;
+ if (array_element_size)
+ *array_element_size = kva->array_element_size;
+
+ return BUNDLE_ERROR_NONE;
}
size_t
{
size_t sum_array_element_size = 0;
int i;
- for(i=0; i < kva->len; i++) {
+ for (i = 0; i < kva->len; i++) {
sum_array_element_size += kva->array_element_size[i];
}
size_t encoded_size
- = sizeof(size_t) // total size
- + sizeof(int) // type
- + sizeof(size_t) // keysize
- + strlen(((keyval_t *)kva)->key) + 1 // key (+ null byte)
- + sizeof(int) // len
- + kva->len * sizeof(size_t) // array_element_size
+ = sizeof(size_t) /* total size */
+ + sizeof(int) /* type */
+ + sizeof(size_t) /* keysize */
+ + strlen(((keyval_t *)kva)->key) + 1 /* key (+ null byte) */
+ + sizeof(int) /* len */
+ + kva->len * sizeof(size_t) /* array_element_size */
+ sum_array_element_size;
return encoded_size;
keyval_t *kv = (keyval_t *)kva;
int i;
- // Calculate memory size for kva
+ /* Calculate memory size for kva */
static const size_t sz_type = sizeof(int);
static const size_t sz_keysize = sizeof(size_t);
size_t sz_key = strlen(kv->key) + 1;
static const unsigned int sz_len = sizeof(int);
size_t sz_array_element_size = kva->len * sizeof(size_t);
size_t sz_array_val = 0;
- for(i=0; i < kva->len; i++) {
+ for (i = 0; i < kva->len; i++) {
sz_array_val += kva->array_element_size[i];
}
- // Allocate memory
+ /* Allocate memory */
*byte_len = keyval_array_get_encoded_size(kva);
*byte = calloc(1, *byte_len);
- if(!*byte) return 0;
-
- // Copy data
+ if (!*byte)
+ return 0;
+
+ /* Copy data */
unsigned char *p = *byte;
memcpy(p, byte_len, sizeof(size_t)); p += sizeof(size_t);
memcpy(p, &sz_key, sz_keysize); p += sz_keysize;
memcpy(p, kv->key, sz_key); p += sz_key;
memcpy(p, &(kva->len), sz_len); p += sz_len;
- memcpy(p, kva->array_element_size, sz_array_element_size); p += sz_array_element_size;
- for(i=0; i < kva->len; i++) {
+ memcpy(p, kva->array_element_size, sz_array_element_size);
+ p += sz_array_element_size;
+ for (i = 0; i < kva->len; i++) {
memcpy(p, kva->array_val[i], kva->array_element_size[i]);
p += kva->array_element_size[i];
}
unsigned char *p = byte;
- // Get data
+ /* Get data */
size_t byte_len = *((size_t *)p); p += sz_byte_len;
int type = *((int *)p); p += sz_type;
size_t keysize = *((size_t *)p); p += sz_keysize;
*kva = keyval_array_new(NULL, key, type, NULL, len);
int i;
size_t elem_size = 0;
- for(i=0; i < len; i++) {
+ for (i = 0; i < len; i++) {
elem_size += i ? array_element_size[i-1] : 0;
- if(keyval_array_set_element(*kva, i, (void *)(array_val+elem_size), array_element_size[i])) {
+ if (keyval_array_set_element(*kva, i,
+ (void *)(array_val+elem_size),
+ array_element_size[i])) {
keyval_array_free(*kva, 1);
*kva = NULL;
return 0;
projects / platform / core / base / bundle.git / blobdiff