chillbuff.h

Go to the documentation of this file.

/*
   Copyright 2019 Raphael Beck
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
 
#ifndef CHILLBUFF_H
#define CHILLBUFF_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
 
/* The following are the chillbuff exit codes returned from the various chillbuff functions. */
 
#define CHILLBUFF_SUCCESS 0
 
#define CHILLBUFF_OUT_OF_MEM 100
 
#define CHILLBUFF_NULL_ARG 200
 
#define CHILLBUFF_INVALID_ARG 300
 
#define CHILLBUFF_OVERFLOW 400
 
static void (*_chillbuff_error_callback)(const char*) = NULL;
 
typedef enum chillbuff_growth_method
{
    CHILLBUFF_GROW_DUPLICATIVE = 0,
 
    CHILLBUFF_GROW_TRIPLICATIVE = 1,
 
    CHILLBUFF_GROW_LINEAR = 2,
 
    CHILLBUFF_GROW_EXPONENTIAL = 3
} chillbuff_growth_method;
 
typedef struct chillbuff
{
    void* array;
 
    size_t length;
 
    size_t capacity;
 
    size_t element_size;
 
    chillbuff_growth_method growth_method;
} chillbuff;
 
static inline void _chillbuff_printerr(const char* error, const char* origin)
{
    const size_t error_length = 64 + strlen(error) + strlen(origin);
    char* error_msg = (char*)chillbuff_malloc(error_length * sizeof(char)); // cast malloc because of compat with C++ D:
    if (error_msg != NULL)
    {
        snprintf(error_msg, error_length, "\nCHILLBUFF ERROR: (%s) %s\n", origin, error);
        if (_chillbuff_error_callback != NULL)
        {
            _chillbuff_error_callback(error_msg);
        }
        free(error_msg);
    }
}
 
static inline int chillbuff_set_error_callback(void (*error_callback)(const char*))
{
    if (error_callback == NULL)
    {
        _chillbuff_printerr("The passed error callback is empty; Operation cancelled!", __func__);
        return CHILLBUFF_NULL_ARG;
    }
 
    _chillbuff_error_callback = error_callback;
    return CHILLBUFF_SUCCESS;
}
 
static inline void chillbuff_unset_error_callback()
{
    _chillbuff_error_callback = NULL;
}
 
static inline int chillbuff_init(chillbuff* buff, const size_t initial_capacity, const size_t element_size, const chillbuff_growth_method growth_method)
{
    if (buff == NULL)
    {
        _chillbuff_printerr("Tried to init a NULL chillbuff instance; wouldn't end well. Cancelled...", __func__);
        return CHILLBUFF_NULL_ARG;
    }
 
    if (element_size == 0)
    {
        _chillbuff_printerr("Storing elements of size \"0\" makes no sense...", __func__);
        return CHILLBUFF_INVALID_ARG;
    }
 
    if (growth_method < 0 || growth_method > 3)
    {
        _chillbuff_printerr("Invalid grow method! Please use the appropriate chillbuff_growth_method enum!", __func__);
        return CHILLBUFF_INVALID_ARG;
    }
 
    buff->length = 0;
    buff->element_size = element_size;
    buff->growth_method = growth_method;
    buff->capacity = initial_capacity == 0 ? 16 : initial_capacity;
    buff->array = chillbuff_calloc(buff->capacity, buff->element_size);
 
    if (buff->array == NULL)
    {
        _chillbuff_printerr("OUT OF MEMORY!", __func__);
        return CHILLBUFF_OUT_OF_MEM;
    }
 
    return CHILLBUFF_SUCCESS;
}
 
static inline void chillbuff_free(chillbuff* buff)
{
    if (buff == NULL)
    {
        return;
    }
 
    memset(buff->array, '\0', buff->length);
    free(buff->array);
    buff->array = NULL;
    buff->length = buff->capacity = buff->element_size = 0;
}
 
static inline void chillbuff_clear(chillbuff* buff)
{
    if (buff == NULL)
    {
        return;
    }
 
    memset(buff->array, '\0', buff->capacity);
    buff->length = 0;
}
 
static int chillbuff_push_back(chillbuff* buff, const void* elements, const size_t elements_count)
{
    if (buff == NULL)
    {
        _chillbuff_printerr("Tried to append to a NULL chillbuff instance!", __func__);
        return CHILLBUFF_NULL_ARG;
    }
 
    if (elements == NULL)
    {
        _chillbuff_printerr("Tried to append NULL element(s) to a chillbuff instance!", __func__);
        return CHILLBUFF_NULL_ARG;
    }
 
    if (elements_count == 0)
    {
        _chillbuff_printerr("The passed \"elements_count\" argument is zero; nothing to append!", __func__);
        return CHILLBUFF_INVALID_ARG;
    }
 
    for (size_t i = 0; i < elements_count; i++)
    {
        if (buff->length == buff->capacity)
        {
            size_t new_capacity;
 
            switch (buff->growth_method)
            {
                default:
                    _chillbuff_printerr("Invalid grow method! Please use the appropriate chillbuff_growth_method enum!", __func__);
                    return CHILLBUFF_INVALID_ARG;
                case CHILLBUFF_GROW_DUPLICATIVE:
                    new_capacity = (buff->capacity * 2);
                    break;
                case CHILLBUFF_GROW_TRIPLICATIVE:
                    new_capacity = (buff->capacity * 3);
                    break;
                case CHILLBUFF_GROW_LINEAR:
                    new_capacity = (buff->capacity + buff->element_size);
                    break;
                case CHILLBUFF_GROW_EXPONENTIAL:
                    new_capacity = (buff->capacity * buff->capacity);
                    break;
            }
 
            if (new_capacity <= buff->capacity || new_capacity >= UINT64_MAX / buff->element_size)
            {
                _chillbuff_printerr("Couldn't push back due to buffer OVERFLOW!", __func__);
                return CHILLBUFF_OVERFLOW;
            }
 
            void* new_array = chillbuff_realloc(buff->array, new_capacity * buff->element_size);
            if (new_array == NULL)
            {
                _chillbuff_printerr("Couldn't resize chillbuff underlying array; OUT OF MEMORY!", __func__);
                return CHILLBUFF_OUT_OF_MEM;
            }
 
            memset((char*)new_array + (buff->element_size * buff->length), '\0', (new_capacity - buff->length) * buff->element_size);
            buff->array = new_array;
            buff->capacity = new_capacity;
        }
 
        memcpy((char*)buff->array + (buff->element_size * buff->length++), (char*)elements + (i * buff->element_size), buff->element_size);
    }
 
    return CHILLBUFF_SUCCESS;
}
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#endif // CHILLBUFF_H