Main/support/arcade/buffer.cpp

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stddef.h>
#include <limits.h>

#include "buffer.h"


////////////////////////////////////////////////////////////////////////////////
//
//  Function buffer_init
//
//  Purpose:
//
//     This function will return a struct with the values it needs before it
//     can be used with buffer_append. The default "expand_length" is
//
//  Parameters:
//
//     initial_size (IN) This parameter will preallocate the buffer with this
//     size in bytes.
//
//  Returns:
//
//     returns a struct, or NULL on error
//
//  Error Definitions:
//
//     NULL = Couldn't create the structure
//
////////////////////////////////////////////////////////////////////////////////

buffer_data * buffer_init(unsigned int initial_size) {

	buffer_data * buffer = NULL;

	// only allow max initial size of SIZE_MAX
	if (initial_size > 65535) {
		return NULL;
	}

	// malloc the space for a pointer to a buffer_data
	buffer = (buffer_data *)malloc(sizeof(buffer_data));
	if (buffer == NULL) {
		return NULL;
	}

	// fill the struct up
	buffer->expand_length = initial_size;
	buffer->capacity = initial_size;
	buffer->length = 0;

	// allocate the buffer space
	buffer->content = (char *)malloc(sizeof(char) * initial_size);
	buffer->content[0] = 0;
	if (buffer->content == NULL) {
		// can't allocate the buffer, therefore we need to clean everything up
		free(buffer);
		return NULL;
	}

	// return a pointer to our buffer_data structure
	return buffer;
}


////////////////////////////////////////////////////////////////////////////////
//
//  Function buffer_append
//
//  Purpose:
//
//     This function will take data and append it into a buffer in the struct
//     given. It will growing as required (or as allowed by realloc) by the
//     length desired in the structure element "expand_length" plus the length
//     of the data being appended. If additional expansion is not desired, you
//     can set the struct element "expand_length" to zero.
//
//  Parameters:
//
//     buffer_data (IN/OUT) This parameter is a struct (mapped below) to
//     keep track of the internal buffer and its working parameters.
//
//       typedef struct {
//           unsigned int length;        // the current length of the content in bytes
//           unsigned int capacity;      // the total capacity of "content" in bytes
//           unsigned int expand_length; // the amount to expand the buffer on resize
//           char * content;       // the target for appending data
//       } buffer_data;
//
//
//     append_data (IN) This parameter is a const char * that is the data
//     to be appended.
//
//  Returns:
//
//     This function will return the amount of bytes appended. If the
//     return value is <= 0 there was an error.
//
//  Error Definitions:
//
//     -1 = No data was given to append
//     -2 = Additional space could not be allocated for the buffer.
//
////////////////////////////////////////////////////////////////////////////////

int buffer_append(buffer_data * buffer, const char * append_data) {

	// ensure there IS something to append..
	const unsigned int append_len = strlen(append_data);
	if (append_len < 1) {
		return -1;
	}

	// is there enough space, or should we reallocate memory?
	if (buffer->length + append_len > buffer->capacity) {

		const unsigned int realloc_size =
			buffer->capacity + append_len + buffer->expand_length;

		// allocate the new buffer
		char *new_buffer = (char *)realloc(buffer->content, realloc_size);

		// resize success..
		if (new_buffer == NULL) {
			return -2;
		}

		// copy the data to append into the new content buffer
		strcat(new_buffer, append_data);

		// update the struct with the new values
		buffer->content = new_buffer;       // new buffer content
		buffer->capacity = realloc_size;    // add the amount to expand beyond our initial needs
		buffer->length = buffer->length + append_len;

	}
	else {
		// append the string
		strcat(buffer->content, append_data);
	}

	// update the buffer length
	buffer->length += append_len;

	// return the amount appended
	return append_len;
}

////////////////////////////////////////////////////////////////////////////////
//
//  Function buffer_destroy
//
//  Purpose:
//
//     This function will destroy the inner buffer and reset all of the data
//     if the struct was dynamically allocated, it is expected that you will
//     take care of freeing the data.
//
//  Parameters:
//
//     buffer_data (IN) This parameter is a struct (mapped below) to
//     keep track of the internal buffer and its working parameters.
//
//       typedef struct {
//           unsigned int length;        // the current length of the content in bytes
//           unsigned int capacity;      // the total capacity of "content" in bytes
//           unsigned int expand_length; // the amount to expand the buffer on resize
//           char * content;       // the target for appending data
//       } buffer_data;
//
//  Returns:
//
//     returns nothing
//
////////////////////////////////////////////////////////////////////////////////

void buffer_destroy(buffer_data * buffer) {

	// only work with valid data..
	if (buffer != NULL) {

		// if the content is not null, free it.
		if (buffer->content != NULL) {
			free(buffer->content);
		}

		// free the buffer
		free(buffer);
	}
}