Add serialization and deserialization functions to circular buffer

lib/circ_buff.c

@@ -303,6 +303,50 @@ int circ_buf_read(cbuf_handle_t cbuf, size_t position, char* data) {
 	return r;
 }
 
+int circ_buf_serialize(cbuf_handle_t cbuf, char** serialized) {
+	char* temp = (char*) malloc(circ_buf_element_size(cbuf) * sizeof(char));
+	const char separator[2] = "\r";
+	uint8_t char_sum = circ_buf_size(cbuf) - 1;
+	uint8_t i;
+
+	for (i = 0; i < circ_buf_size(cbuf); ++i) {
+		circ_buf_read(cbuf, i, temp);
+		char_sum += strlen(temp);
+	}
+
+	(*serialized) = (char*) malloc((char_sum + 1) * sizeof(char));
+	strcpy((*serialized), "");
+
+	for (i = 0; i < circ_buf_size(cbuf) - 1; ++i) {
+		circ_buf_read(cbuf, i, temp);
+		strcat((*serialized), temp);
+		strcat((*serialized), separator);
+	}
+
+	circ_buf_read(cbuf, i, temp);
+	strcat((*serialized), temp);
+
+	free(temp);
+
+	return strlen((*serialized));
+}
+
+int circ_buf_deserialize(cbuf_handle_t cbuf, const char* serialized) {
+	char *str = calloc(strlen(serialized) + 1, sizeof(char));
+	strcpy(str, serialized);
+	const char separator[2] = "\r";
+	char* token;
+
+	token = strtok(str, separator);
+
+	while (token != NULL) {
+		circ_buf_put(cbuf, token);
+		token = strtok(NULL, separator);
+	}
+
+	return circ_buf_size(cbuf);
+}
+
 bool circ_buf_empty(cbuf_handle_t cbuf) {
 	assert(cbuf);
 

lib/circ_buff.h

@@ -50,6 +50,12 @@ int circ_buf_get(cbuf_handle_t cbuf, char* data);
 // Reads a value from the buffer. Does NOT retrieve, size is not reduced!
 int circ_buf_read(cbuf_handle_t cbuf, size_t position, char* data);
 
+// Serializes the whole buffer to a single string
+int circ_buf_serialize(cbuf_handle_t cbuf, char** serialized);
+
+// De-serializes a string to a buffer
+int circ_buf_deserialize(cbuf_handle_t cbuf, const char* serialized);
+
 // Checks if the buffer is empty.
 bool circ_buf_empty(cbuf_handle_t cbuf);
 

test/test_circ_buff.c

@@ -11,8 +11,8 @@
 
 int compar(const void* entry1, const void* entry2) {
 	char **pstr1 = (char**)entry1, **pstr2 = (char**)entry2;
-	char *str1 = calloc(strlen(*pstr1)+1, sizeof(char)),
-		*str2 = calloc(strlen(*pstr2)+1, sizeof(char));
+	char *str1 = calloc(strlen(*pstr1) + 1, sizeof(char)),
+		*str2 = calloc(strlen(*pstr2) + 1, sizeof(char));
 	strcpy(str1, *pstr1);
 	strcpy(str2, *pstr2);
 
@@ -25,6 +25,9 @@ int compar(const void* entry1, const void* entry2) {
 	rest = strtok(NULL, "");
 	int num2 = atoi(rest);
 
+	free(str1);
+	free(str2);
+
 	return num1 - num2;
 }
 
@@ -158,17 +161,17 @@ void test_circ_buf_get(void) {
 	free(temp);
 
 	char* actual = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
-	char* test_against = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
+	char* expected = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
 
 	for(uint8_t i = 0; i < (BUFFER_SIZE - 2); ++i) {
 		circ_buf_get(circ_buf, actual);
-		snprintf(test_against, BUFFER_ELEMENT_SIZE, "string_%d", i);
+		snprintf(expected, BUFFER_ELEMENT_SIZE, "string_%d", i);
 
-		TEST_ASSERT_EQUAL_STRING_LEN(test_against, actual, BUFFER_ELEMENT_SIZE);
+		TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, BUFFER_ELEMENT_SIZE);
 	}
 
 	free(actual);
-	free(test_against);
+	free(expected);
 
 	circ_buf_free(circ_buf);
 	free_buffer(buffer);
@@ -193,18 +196,77 @@ void test_circ_buf_read(void) {
 	free(temp);
 
 	char* actual = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
-	char* test_against = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
+	char* expected = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
 
 	for(uint8_t i = 0; i < (BUFFER_SIZE - 2); ++i) {
 		circ_buf_read(circ_buf, i, actual);
-		snprintf(test_against, BUFFER_ELEMENT_SIZE, "string_%d", i);
+		snprintf(expected, BUFFER_ELEMENT_SIZE, "string_%d", i);
 
-		TEST_ASSERT_EQUAL_STRING_LEN(test_against, actual, BUFFER_ELEMENT_SIZE);
+		TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, BUFFER_ELEMENT_SIZE);
 		TEST_ASSERT_EQUAL_INT8(BUFFER_SIZE - 2, circ_buf_size(circ_buf));
 	}
 
 	free(actual);
-	free(test_against);
+	free(expected);
+
+	circ_buf_free(circ_buf);
+	free_buffer(buffer);
+	free(buffer);
+}
+
+void test_circ_buf_serialize(void) {
+	char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *));
+	for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) {
+		buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
+	}
+
+	cbuf_handle_t circ_buf = circ_buf_init(buffer, BUFFER_SIZE, BUFFER_ELEMENT_SIZE);
+	char* temp = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
+
+	for(uint8_t i = 0; i < (BUFFER_SIZE - 2); ++i) {
+		snprintf(temp, BUFFER_ELEMENT_SIZE, "string_%d", i);
+
+		circ_buf_put(circ_buf, temp);
+	}
+
+	free(temp);
+
+	char* serialized;
+	uint8_t serialized_length = circ_buf_serialize(circ_buf, &serialized);
+	TEST_ASSERT_EQUAL_UINT8(53, serialized_length);
+
+	char* expected = "string_0\rstring_1\rstring_2\rstring_3\rstring_4\rstring_5";
+	TEST_ASSERT_EQUAL_STRING_LEN(expected, serialized, 53);
+
+	circ_buf_free(circ_buf);
+	free_buffer(buffer);
+	free(buffer);
+}
+
+void test_circ_buf_deserialize(void) {
+	char** buffer = (char **) malloc(BUFFER_SIZE * sizeof(char *));
+	for (uint8_t buff_el = 0; buff_el < BUFFER_SIZE; ++buff_el) {
+		buffer[buff_el] = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
+	}
+
+	cbuf_handle_t circ_buf = circ_buf_init(buffer, BUFFER_SIZE, BUFFER_ELEMENT_SIZE);
+
+	char* serialized = "string_0\rstring_1\rstring_2\rstring_3\rstring_4\rstring_5";
+	uint8_t deserialized_size = circ_buf_deserialize(circ_buf, serialized);
+	TEST_ASSERT_EQUAL_UINT8(6, deserialized_size);
+
+	char* actual = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
+	char* expected = (char *) malloc(BUFFER_ELEMENT_SIZE * sizeof(char));
+
+	for(uint8_t i = 0; i < (BUFFER_SIZE - 2); ++i) {
+		circ_buf_get(circ_buf, actual);
+		snprintf(expected, BUFFER_ELEMENT_SIZE, "string_%d", i);
+
+		TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, BUFFER_ELEMENT_SIZE);
+	}
+
+	free(actual);
+	free(expected);
 
 	circ_buf_free(circ_buf);
 	free_buffer(buffer);