variant: extended API to support (optional) referenced strings and bytes

CMakeLists.txt

@@ -5,7 +5,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # C Floppy Version
 set(CFL_VERSION_MAJOR  0)
-set(CFL_VERSION_MINOR  4)
+set(CFL_VERSION_MINOR  5)
 set(CFL_VERSION_PATCH  0)
 set(CFL_VERSION_STR    "${CFL_VERSION_MAJOR}.${CFL_VERSION_MINOR}.${CFL_VERSION_PATCH}")
 

include/cfl/cfl_array.h

@@ -43,12 +43,10 @@ static inline struct cfl_variant *cfl_array_fetch_by_index(struct cfl_array *arr
     return array->entries[position];
 }
 
-int cfl_array_resizable(struct cfl_array *array, int v);
-int cfl_array_remove_by_index(struct cfl_array *array, size_t position);
-int cfl_array_remove_by_reference(struct cfl_array *array, struct cfl_variant *value);
 int cfl_array_append(struct cfl_array *array, struct cfl_variant *value);
 int cfl_array_append_string(struct cfl_array *array, char *value);
-int cfl_array_append_bytes(struct cfl_array *array, char *value, size_t length);
+int cfl_array_append_string_s(struct cfl_array *array, char *str, size_t str_len, int referenced);
+int cfl_array_append_bytes(struct cfl_array *array, char *value, size_t length, int referenced);
 int cfl_array_append_reference(struct cfl_array *array, void *value);
 int cfl_array_append_bool(struct cfl_array *array, int value);
 int cfl_array_append_int64(struct cfl_array *array, int64_t value);
@@ -58,6 +56,11 @@ int cfl_array_append_null(struct cfl_array *array);
 int cfl_array_append_array(struct cfl_array *array, struct cfl_array *value);
 int cfl_array_append_new_array(struct cfl_array *array, size_t size);
 int cfl_array_append_kvlist(struct cfl_array *array, struct cfl_kvlist *value);
+
+int cfl_array_resizable(struct cfl_array *array, int v);
+int cfl_array_remove_by_index(struct cfl_array *array, size_t position);
+int cfl_array_remove_by_reference(struct cfl_array *array, struct cfl_variant *value);
+
 int cfl_array_print(FILE *fp, struct cfl_array *array);
 
 #endif

include/cfl/cfl_kvlist.h

@@ -43,7 +43,8 @@ int cfl_kvlist_insert_string(struct cfl_kvlist *list,
 
 int cfl_kvlist_insert_bytes(struct cfl_kvlist *list,
                              char *key, char *value,
-                             size_t value_length);
+                             size_t value_length,
+                             int referenced);
 
 int cfl_kvlist_insert_reference(struct cfl_kvlist *list,
                                 char *key, void *value);
@@ -78,12 +79,14 @@ int cfl_kvlist_print(FILE *fp, struct cfl_kvlist *list);
 
 int cfl_kvlist_insert_string_s(struct cfl_kvlist *list,
                                char *key, size_t key_size,
-                               char *value, size_t value_size);
+                               char *value, size_t value_size,
+                               int referenced);
 
 int cfl_kvlist_insert_bytes_s(struct cfl_kvlist *list,
                               char *key, size_t key_size,
                               char *value,
-                              size_t value_length);
+                              size_t value_length,
+                              int referenced);
 
 int cfl_kvlist_insert_reference_s(struct cfl_kvlist *list,
                                   char *key, size_t key_size,

include/cfl/cfl_variant.h

@@ -24,16 +24,16 @@
 #include <string.h>
 #include <inttypes.h>
 
-#define CFL_VARIANT_STRING     1
-#define CFL_VARIANT_BOOL       2
-#define CFL_VARIANT_INT        3
+#define CFL_VARIANT_BOOL       1
+#define CFL_VARIANT_INT        2
+#define CFL_VARIANT_UINT       3
 #define CFL_VARIANT_DOUBLE     4
-#define CFL_VARIANT_ARRAY      5
-#define CFL_VARIANT_KVLIST     6
-#define CFL_VARIANT_BYTES      7
-#define CFL_VARIANT_REFERENCE  8
-#define CFL_VARIANT_UINT       9
-#define CFL_VARIANT_NULL      10
+#define CFL_VARIANT_NULL       5
+#define CFL_VARIANT_REFERENCE  6
+#define CFL_VARIANT_STRING     7
+#define CFL_VARIANT_BYTES      8
+#define CFL_VARIANT_ARRAY      9
+#define CFL_VARIANT_KVLIST    10
 
 struct cfl_array;
 struct cfl_kvlist;
@@ -42,6 +42,18 @@ struct cfl_variant {
     int type;
     size_t size;
 
+    /*
+     * indicate if 'data' is being referenced for 'as_string' and 'as_bytes':
+     *
+     * CFL_TRUE:  data is being referenced
+     * CFL_FALSE: data is owned by the variant
+     *
+     * Referenced data uses less memory, when the variant is not referenced we use
+     * a copy of the original data.
+     */
+    uint8_t referenced;
+
+    /* the data */
     union {
         cfl_sds_t as_string;
         cfl_sds_t as_bytes;
@@ -57,8 +69,8 @@ struct cfl_variant {
 
 int cfl_variant_print(FILE *fp, struct cfl_variant *val);
 struct cfl_variant *cfl_variant_create_from_string(char *value);
-struct cfl_variant *cfl_variant_create_from_string_s(char *value, size_t value_length);
-struct cfl_variant *cfl_variant_create_from_bytes(char *value, size_t length);
+struct cfl_variant *cfl_variant_create_from_string_s(char *value, size_t value_length, int referenced);
+struct cfl_variant *cfl_variant_create_from_bytes(char *value, size_t length, int referenced);
 struct cfl_variant *cfl_variant_create_from_bool(int value);
 struct cfl_variant *cfl_variant_create_from_int64(int64_t value);
 struct cfl_variant *cfl_variant_create_from_uint64(uint64_t value);
@@ -71,4 +83,7 @@ struct cfl_variant *cfl_variant_create();
 
 void cfl_variant_destroy(struct cfl_variant *instance);
 
+void cfl_variant_size_set(struct cfl_variant *var, size_t size);
+size_t cfl_variant_size_get(struct cfl_variant *var);
+
 #endif

src/cfl_array.c

@@ -129,6 +129,15 @@ int cfl_array_append(struct cfl_array *array,
          * it controls the input data.
          */
         if (array->resizable) {
+
+            /*
+             * if the array size is zero (created as an array of 0 slots),
+             * change the size to 1 so the resize can work properly
+             */
+            if (array->slot_count == 0) {
+                array->slot_count = 1;
+            }
+
             /* set new number of slots and total size */
             new_slot_count = (array->slot_count * 2);
             new_size = (new_slot_count * sizeof(void *));
@@ -145,13 +154,17 @@ int cfl_array_append(struct cfl_array *array,
             return -1;
         }
     }
-    array->entries[array->entry_count++] = value;
 
+    /* this is just a double check to make sure the slot is really available */
+    if (array->entry_count >= array->slot_count) {
+        return -1;
+    }
+
+    array->entries[array->entry_count++] = value;
     return 0;
 }
 
-int cfl_array_append_string(struct cfl_array *array,
-                            char *value)
+int cfl_array_append_string(struct cfl_array *array, char *value)
 {
     struct cfl_variant *value_instance;
     int                 result;
@@ -165,7 +178,25 @@ int cfl_array_append_string(struct cfl_array *array,
     result = cfl_array_append(array, value_instance);
     if (result) {
         cfl_variant_destroy(value_instance);
+        return -2;
+    }
+
+    return 0;
+}
 
+int cfl_array_append_string_s(struct cfl_array *array, char *str, size_t str_len, int referenced)
+{
+    struct cfl_variant *value_instance;
+    int                 result;
+
+    value_instance = cfl_variant_create_from_string_s(str, str_len, referenced);
+    if (value_instance == NULL) {
+        return -1;
+    }
+
+    result = cfl_array_append(array, value_instance);
+    if (result) {
+        cfl_variant_destroy(value_instance);
         return -2;
     }
 
@@ -174,13 +205,13 @@ int cfl_array_append_string(struct cfl_array *array,
 
 int cfl_array_append_bytes(struct cfl_array *array,
                            char *value,
-                           size_t length)
+                           size_t length,
+                           int referenced)
 {
     struct cfl_variant *value_instance;
     int                 result;
 
-    value_instance = cfl_variant_create_from_bytes(value, length);
-
+    value_instance = cfl_variant_create_from_bytes(value, length, referenced);
     if (value_instance == NULL) {
         return -1;
     }

src/cfl_kvlist.c

@@ -60,52 +60,15 @@ void cfl_kvlist_destroy(struct cfl_kvlist *list)
     free(list);
 }
 
-/*
-int cfl_kvlist_insert(struct cfl_kvlist *list,
-                      char *key, void *value,
-                      size_t value_length,
-                      int value_type)
-{
-    struct cfl_kvpair *pair;
-
-    pair = malloc(sizeof(struct cfl_kvpair));
-
-    if (pair == NULL) {
-        cfl_errno();
-
-        return -1;
-    }
-
-    pair->key = cfl_sds_create(key);
-
-    if (pair->key == NULL) {
-        free(pair);
-
-        return -2;
-    }
-
-    pair->val = cfl_variant_create(value, value_length, value_type);
-
-    if (pair->val == NULL) {
-        cfl_sds_destroy(pair->key);
-        free(pair);
-
-        return -3;
-    }
-
-    cfl_list_add(&pair->_head, &list->list);
-
-    return 0;
-}
-*/
-
 int cfl_kvlist_insert_string_s(struct cfl_kvlist *list,
-                               char *key, size_t key_size, char *value, size_t value_size)
+                               char *key, size_t key_size,
+                               char *value, size_t value_size,
+                               int referenced)
 {
     struct cfl_variant *value_instance;
     int                 result;
 
-    value_instance = cfl_variant_create_from_string_s(value, value_size);
+    value_instance = cfl_variant_create_from_string_s(value, value_size, referenced);
     if (value_instance == NULL) {
         return -1;
     }
@@ -123,13 +86,12 @@ int cfl_kvlist_insert_string_s(struct cfl_kvlist *list,
 int cfl_kvlist_insert_bytes_s(struct cfl_kvlist *list,
                               char *key, size_t key_size,
                               char *value,
-                              size_t length)
+                              size_t length, int referenced)
 {
     struct cfl_variant *value_instance;
     int                 result;
 
-    value_instance = cfl_variant_create_from_bytes(value, length);
-
+    value_instance = cfl_variant_create_from_bytes(value, length, referenced);
     if (value_instance == NULL) {
         return -1;
     }
@@ -138,7 +100,6 @@ int cfl_kvlist_insert_bytes_s(struct cfl_kvlist *list,
 
     if (result) {
         cfl_variant_destroy(value_instance);
-
         return -2;
     }
 
@@ -390,14 +351,14 @@ int cfl_kvlist_insert_string(struct cfl_kvlist *list,
     key_len = strlen(key);
     val_len = strlen(value);
 
-    return cfl_kvlist_insert_string_s(list, key, key_len, value, val_len);
+    return cfl_kvlist_insert_string_s(list, key, key_len, value, val_len, CFL_FALSE);
 }
 
 int cfl_kvlist_insert_bytes(struct cfl_kvlist *list,
-                             char *key, char *value,
-                             size_t length)
+                            char *key, char *value,
+                            size_t length, int referenced)
 {
-    return cfl_kvlist_insert_bytes_s(list, key, strlen(key), value, length);
+    return cfl_kvlist_insert_bytes_s(list, key, strlen(key), value, length, referenced);
 }
 
 int cfl_kvlist_insert_reference(struct cfl_kvlist *list,