Simple implementation for maps

Author: PJK

src/cbor.c

@@ -98,6 +98,8 @@ cbor_item_t * cbor_load(cbor_data source,
 		.array_start = &cbor_builder_array_start_callback,
 		.indef_array_start = &cbor_builder_indef_array_start_callback,
 
+		.map_start = &cbor_builder_map_start_callback,
+
 		.tag = &cbor_builder_tag_callback,
 
 		.null = &cbor_builder_null_callback,
@@ -1221,17 +1223,58 @@ cbor_item_t * cbor_new_definite_map(size_t size)
 	*item = (cbor_item_t){
 		.refcount = 1,
 		.type = CBOR_TYPE_MAP,
-		.metadata = { .map_metadata = { .size = 0} },
-		.data = malloc(sizeof(cbor_item_t *) * size)
+		.metadata = { .map_metadata = { .size = 0, .type = _CBOR_METADATA_DEFINITE } },
+		.data = malloc(sizeof(struct cbor_pair) * size)
 	};
 	return item;
 }
 
-cbor_item_t * cbor_new_indefinite_map();
-cbor_item_t * cbor_map_add(cbor_item_t * item, struct cbor_pair pair);
-bool cbor_map_is_definite(cbor_item_t * item);
-bool cbor_map_is_indefinite(cbor_item_t * item);
-struct cbor_pair * cbor_map_handle(cbor_item_t * item);
+cbor_item_t * cbor_new_indefinite_map()
+{
+	cbor_item_t * item = malloc(sizeof(cbor_item_t));
+	*item = (cbor_item_t){
+		.refcount = 1,
+		.type = CBOR_TYPE_MAP,
+		.metadata = { .map_metadata = { .size = 0, .type = _CBOR_METADATA_INDEFINITE } },
+		.data = NULL
+	};
+	return item;
+}
+
+cbor_item_t * cbor_map_add(cbor_item_t * item, struct cbor_pair pair)
+{
+	assert(cbor_isa_map(item));
+	struct _cbor_map_metadata * metadata = (struct _cbor_map_metadata *)&item->metadata;
+	struct cbor_pair * data = cbor_map_handle(item);
+	if (cbor_map_is_definite(item)) {
+		// TODO check size - throw
+		data[metadata->size++] = pair;
+	} else {
+		// TODO exponential reallocs?
+		// TOOD check realloc
+		data = realloc(data, (metadata->size + 1) * sizeof(struct cbor_pair));
+		data[metadata->size++] = pair;
+		item->data = (unsigned char *)data;
+	}
+	return item;
+}
+
+bool cbor_map_is_definite(cbor_item_t * item)
+{
+	assert(cbor_isa_map(item));
+	return item->metadata.map_metadata.type == _CBOR_METADATA_DEFINITE;
+}
+
+bool cbor_map_is_indefinite(cbor_item_t * item)
+{
+	return !cbor_map_is_definite(item);
+}
+
+struct cbor_pair * cbor_map_handle(cbor_item_t * item)
+{
+	assert(cbor_isa_map(item));
+	return (struct cbor_pair *)item->data;
+}
 
 
 cbor_item_t * cbor_new_tag(uint64_t value)

src/cbor.h

@@ -110,6 +110,7 @@ struct _cbor_array_metadata {
 
 struct _cbor_map_metadata {
 	size_t size;
+	_cbor_dst_metadata type;
 };
 
 /* cbor_item_metadata is 2 * sizeof(size_t) + sizeof(_cbor_string_type_metadata), lets use the space */

src/cbor_internal.c

@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <string.h>
 #include <math.h>
-#include <zlib.h>
 
 // TODO asserts
 // TODO check mallocs
@@ -106,6 +105,25 @@ void _cbor_builder_append(cbor_item_t * item, struct _cbor_decoder_context * ctx
 				}
 				break;
 			}
+		case CBOR_TYPE_MAP:
+			{
+				if (cbor_map_is_definite(ctx->stack->top->item)) {
+					assert(ctx->stack->top->subitems > 0);
+					if (ctx->stack->top->subitems % 2) {
+						/* Even record, this is a key */
+						cbor_map_add(ctx->stack->top->item, (struct cbor_pair){ .key = item, .value = NULL });
+					} else {
+						// TODO this is fugly
+						cbor_map_handle(ctx->stack->top->item)[cbor_map_size(ctx->stack->top->item) - 1].value = item;
+					}
+					ctx->stack->top->subitems--;
+					if (ctx->stack->top->subitems == 0) {
+						cbor_item_t *item = ctx->stack->top->item;
+						_cbor_stack_pop(ctx->stack);
+						_cbor_builder_append(item, ctx);
+					}
+				}
+			}
 		case CBOR_TYPE_TAG:
 			{
 				assert(ctx->stack->top->subitems == 1);
@@ -291,6 +309,24 @@ enum cbor_callback_result cbor_builder_indef_array_start_callback(void * context
 	return CBOR_CALLBACK_OK;
 }
 
+enum cbor_callback_result cbor_builder_indef_map_start_callback(void * context)
+{
+	struct _cbor_decoder_context * ctx = context;
+	_cbor_stack_push(ctx->stack, cbor_new_indefinite_map(), 0);
+	return CBOR_CALLBACK_OK;
+}
+
+enum cbor_callback_result cbor_builder_map_start_callback(void * context, size_t size)
+{
+	struct _cbor_decoder_context * ctx = context;
+	if (size > 0) {
+		_cbor_stack_push(ctx->stack, cbor_new_definite_map(size), size * 2);
+	} else {
+		_cbor_builder_append(cbor_new_definite_map(size), ctx);
+	}
+	return CBOR_CALLBACK_OK;
+}
+
 enum cbor_callback_result cbor_builder_indef_break_callback(void * context)
 {
 	struct _cbor_decoder_context * ctx = context;

src/cbor_internal.h

@@ -37,6 +37,9 @@ enum cbor_callback_result cbor_builder_byte_string_start_callback(void *);
 enum cbor_callback_result cbor_builder_array_start_callback(void *, size_t);
 enum cbor_callback_result cbor_builder_indef_array_start_callback(void *);
 
+enum cbor_callback_result cbor_builder_map_start_callback(void *, size_t);
+enum cbor_callback_result cbor_builder_indef_map_start_callback(void *);
+
 enum cbor_callback_result cbor_builder_tag_callback(void *, uint64_t);
 
 enum cbor_callback_result cbor_builder_float2_callback(void *, float);

test/type_5_test.c

@@ -0,0 +1,33 @@
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <cmocka.h>
+#include <stdio.h>
+#include "cbor.h"
+#include <inttypes.h>
+#include "assertions.h"
+
+
+cbor_item_t * map;
+struct cbor_load_result res;
+
+unsigned char empty_map[] = { 0xA0 };
+static void test_empty_map(void **state)
+{
+	map = cbor_load(empty_map, 1, CBOR_FLAGS_NONE, &res);
+	assert_non_null(map);
+	assert_true(cbor_typeof(map) == CBOR_TYPE_MAP);
+	assert_true(cbor_isa_map(map));
+	assert_true(cbor_map_size(map) == 0);
+	assert_true(res.read == 1);
+	cbor_decref(&map);
+	assert_null(map);
+}
+
+
+int main(void) {
+	const UnitTest tests[] = {
+		unit_test(test_empty_map),
+	};
+	return run_tests(tests);
+}