source/utils/array/madsl_chunk_array.c - master - nirinis/MalachiteDSL

source/utils/array/madsl_chunk_array.c
149 строк3 KB
nirinis
Appending of fundamental files
02 авг 2026, 18:43
02 авг 2026, 18:4317af66b
#include "..\..\..\include\utils\array\madsl_chunk_array.h"
#include <string.h>


typedef struct 
{
	madsl_byte* begin;
	madsl_byte* end;
} madsl_array_chunk;

void madsl_array_chunk_destroy(madsl_array_chunk* sv)
{
	free((void*)sv->begin);
	sv->begin = NULL;
	sv->end = NULL;
}

static void chunk_destructor_wrapper(void* ptr) {
	madsl_array_chunk_destroy((madsl_array_chunk*)ptr);
}

static madsl_array_chunk madsl_array_chunk_init(uint16_t cell_size)
{
	madsl_array_chunk chunk;
	chunk.begin = malloc(MADSL_DEFAULT_CHUNK_SIZE * cell_size);
	chunk.end = chunk.begin + MADSL_DEFAULT_CHUNK_SIZE * cell_size;

	return chunk;
}

static int madsl_chunk_array_push_chunk(madsl_chunk_array* array)
{
	madsl_array_chunk temp = madsl_array_chunk_init(array->cell_size);

	if (temp.begin == NULL)
	{
		return -1;
	}

	madsl_dynamic_array_push_back(array->chunks, (madsl_byte*)&temp);
	return 0;
}





madsl_chunk_array* madsl_chunk_array_init(uint16_t cell_size)
{
    if (cell_size == 0) return NULL;
    madsl_chunk_array* array = malloc(sizeof(madsl_chunk_array));
	array->chunks = madsl_dynamic_array_init(sizeof(madsl_array_chunk));

	array->size = 0;
    array->cell_size = cell_size;
	madsl_dynamic_array_set_destructor(array->chunks, chunk_destructor_wrapper);

	return array;
}


void madsl_chunk_array_destroy(madsl_chunk_array* array)
{
    if (!array) return;

    madsl_chunk_array_clear(array);

    madsl_dynamic_array_destroy(array->chunks);

    array->element_destructor = NULL;
    array->size = 0;
    array->cell_size = 0;
}


int madsl_chunk_array_push_back(madsl_chunk_array* array, void* element)
{
    if (array == NULL || element == NULL || array->chunks->size == 0 )
	{
	    if (madsl_chunk_array_push_chunk(array) == -1)
	    {
	    	return -1;
	    }
	}   

    size_t current_chunk_index = array->chunks->size-1;

	size_t current_size = array->size;

	size_t new_chunk_index = (array->size+1) / (MADSL_DEFAULT_CHUNK_SIZE);

    if (current_chunk_index != new_chunk_index) 
    {
        if (madsl_chunk_array_push_chunk(array) == -1)
	    {
	    	return -1;
	    }
    }
    
    madsl_array_chunk* chunk = madsl_dynamic_array_get(array->chunks,new_chunk_index);

    size_t free_last_index_in_chunk = array->size % MADSL_DEFAULT_CHUNK_SIZE;

    memcpy(chunk->begin + free_last_index_in_chunk*array->cell_size, element, array->cell_size);
    array->size++;
}

void* madsl_chunk_array_get(madsl_chunk_array* array, size_t index)
{
    if (array == NULL || index >= array->size) return NULL;

    size_t chunk_index = index / (MADSL_DEFAULT_CHUNK_SIZE);

    madsl_array_chunk* chunk = madsl_dynamic_array_get(array->chunks,chunk_index);

    return chunk->begin + chunk_index*array->cell_size;
}


int madsl_chunk_array_clear(madsl_chunk_array* array)
{
    if (array == NULL) return -1;
    //elements
    if (array->element_destructor != NULL)
    {
        for (size_t i = 0; i < array->size; i++)
        {
            array->element_destructor(madsl_chunk_array_get(array,i));
        }

    }
    //chunks

    madsl_dynamic_array_clear(array->chunks);   //Chunk's destructor must be called itself

    array->size = 0;

}


void madsl_chunk_array_map(madsl_chunk_array* array, madsl_chunk_array_element_handler handler, madsl_byte* user_data)
{
    if (handler == NULL) return;

    for (size_t i = 0; i < array->size; i++)
    {
        handler(madsl_chunk_array_get(array,i), user_data);
    }
}