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

source/utils/array/madsl_dynamic_array.c
282 строки7 KB
nirinis
Appending of fundamental files
02 авг 2026, 18:43
02 авг 2026, 18:4317af66b
#include "..\..\..\include\utils\array\madsl_dynamic_array.h"
#include <assert.h>
#include <corecrt_memory.h>


madsl_dynamic_array* madsl_dynamic_array_init(uint16_t cell_size) {
	if (cell_size == 0) return NULL;
	madsl_dynamic_array* array = malloc(sizeof(madsl_dynamic_array));
	if (!array) return NULL;
	array->cell_size = cell_size;
	array->capacity = MADSL_DYNAMIC_ARRAY_MIN_SIZE;
	array->size = 0;
	array->data = malloc(array->capacity * array->cell_size);
	array->element_destructor = NULL;
	if (!array->data) {
		free(array);
		return NULL;
	}
	return array;
}


madsl_dynamic_array* madsl_dynamic_array_init_uc(uint16_t cell_size, size_t user_capacity) {
	if (cell_size == 0) return NULL;
	madsl_dynamic_array* array = malloc(sizeof(madsl_dynamic_array));
	if (!array) return NULL;
	array->cell_size = cell_size;
	array->capacity = user_capacity < 1 ? 1: user_capacity;
	array->size = 0;
	array->data = malloc((user_capacity < 1 ? 1: user_capacity) * array->cell_size);
	array->element_destructor = NULL;
	if (!array->data) {
		free(array);
		return NULL;
	}
	return array;
}


void madsl_dynamic_array_destroy(madsl_dynamic_array* array)
{
	if (!array) return;
	if (array->element_destructor != NULL)
	{
		madsl_dynamic_array_clear(array);
	}
	array->size = 0;
	array->capacity = 0;
	free(array->data);
}

int madsl_dynamic_array_push_back(madsl_dynamic_array* array, madsl_byte* data)
{
	if (!array || !data) return -1;

	if (array->size == array->capacity)
	{
		int result = madsl_dynamic_array_reallocate(array,2);
		if (result) return -1;
	}
	memcpy(array->data + array->size * array->cell_size, data, (size_t)array->cell_size);
	array->size++;

	return 0;
}

int madsl_dynamic_array_insert_back(madsl_dynamic_array* array, madsl_byte* data, size_t count)
{
	if (!array || !data || array->capacity == 0) return -1;

	if (array->size + count > array->capacity)
	{
		size_t ecoeff = (array->size + count - 1) / array->capacity + 1;

		int r = madsl_dynamic_array_reallocate(array,ecoeff); 
		if (r != 0) return r;
	}

	size_t dest_size = (array->capacity - array->size) * array->cell_size;
	size_t src_size = count * array->cell_size;


	assert(dest_size >= src_size);


	memcpy((array->data + array->size * array->cell_size), data, src_size);
	array->size+=count;

	return 0;
}

int madsl_dynamic_array_insert_back_a(madsl_dynamic_array* to, madsl_dynamic_array* from, size_t count)
{
	if (!to || !from || to->capacity == 0 || to->cell_size != from->cell_size || count > from->size || to == from) return -1;

	if (to->size + count > to->capacity)
	{
		size_t ecoeff = (to->size + count-1) / to->capacity + 1;
		int r = madsl_dynamic_array_reallocate(to, ecoeff);
		if (r != 0) return r;
	}

	size_t dest_size = (to->capacity - to->size) * to->cell_size;
	size_t src_size = count * to->cell_size;

	assert(dest_size >= src_size);

	memcpy((madsl_byte*)(to->data + to->size * to->cell_size), from->data, src_size);
	to->size += count;

	return 0;
}

int madsl_dynamic_array_pop_back(madsl_dynamic_array* array)
{
	if (!array) return -1;

	if (array->size == 0) return -1;
	if (array->element_destructor != NULL)
	{

		array->element_destructor(madsl_dynamic_array_get(array, array->size-1));
	}
	array->size--;
	return 0;
}

void* madsl_dynamic_array_get(madsl_dynamic_array* array, size_t index) {
	if (index >= array->size) return NULL;
	return (madsl_byte*)array->data + index * array->cell_size;
}

int madsl_dynamic_array_set(madsl_dynamic_array* array, size_t index, madsl_byte* data)
{
	if (!array || !data || index >= array->size) return -1;

	madsl_byte* offset = (madsl_byte*)array->data + index * array->cell_size;

	memcpy(offset,data, array->cell_size);

	return 0;
}

int madsl_dynamic_array_set_ex(madsl_dynamic_array* array, size_t index, madsl_byte* data)
{
	if (!array || !data) return -1;

	if (index >= array->capacity)
	{
		int result = madsl_dynamic_array_reserve(array, index+1);
		if (result < 0) return result;
	}
	if (index >= array->size)
	{
		array->size = index+1;
	}
	
	madsl_byte* offset = (madsl_byte*)array->data + index * array->cell_size;

	memcpy(offset,data, array->cell_size);

	return 0;
}


int madsl_dynamic_array_clear(madsl_dynamic_array* array)
{
	if (!array) return -1;

	if (array->element_destructor != NULL)
	{
		for (size_t i = 0; i < array->size; i++) 
		{
			array->element_destructor(madsl_dynamic_array_get(array,i));
		}
	
	}


	array->size = 0;
	memset(array->data, 0, array->capacity * array->cell_size);

	return 0;
}

int madsl_dynamic_array_reserve(madsl_dynamic_array* array, size_t new_capacity) {
	if (!array) return -1;

	if (new_capacity <= array->capacity) return -1;

	void* new_data = malloc(new_capacity * array->cell_size);
	if (!new_data) return -1;
	memcpy(new_data, array->data, array->size * array->cell_size);
	free(array->data);
	array->data = new_data;
	array->capacity = new_capacity;
	return 0;
}

int madsl_dynamic_array_shrink_to_fit(madsl_dynamic_array* array) {
	if (!array) return -1;

	if (array->size == 0) {
		free(array->data);
		array->data = NULL;
		array->capacity = 0;
		return 0;
	}

	void* new_data = malloc(array->size * array->cell_size);
	if (!new_data) return -1;
	memcpy(new_data, array->data, array->size * array->cell_size);
	free(array->data);
	array->data = new_data;
	array->capacity = array->size;
	return 0;
}

int madsl_dynamic_array_reallocate(madsl_dynamic_array* array, size_t expanding_coefficient) {
	if (!array || expanding_coefficient < 2) return -1;

	size_t new_cap = array->capacity * expanding_coefficient;
	if (new_cap < array->capacity) return -1; // overflow
	void* new_data = malloc(new_cap * array->cell_size);
	if (!new_data) return -1;
	memcpy(new_data, array->data, array->size * array->cell_size);
	free(array->data);
	array->data = new_data;
	array->capacity = new_cap;
	return 0;
}

void madsl_dynamic_array_set_destructor(madsl_dynamic_array* array, madsl_dynamic_array_element_destructor destructor)
{
	array->element_destructor = destructor;
}


void madsl_dynamic_array_map(madsl_dynamic_array* array, madsl_dynamic_array_element_handler handler, madsl_byte* user_data)
{
	if (!array || !handler) return;


	for (size_t i =0; i < array->size; i++)
	{
		madsl_byte* element = (madsl_byte*)madsl_dynamic_array_get(array, i);

		handler(element, user_data);
	}

}

int madsl_dynamic_array_contains(madsl_dynamic_array* array, madsl_byte* element) {
    for (size_t i = 0; i < array->size; i++) {
        madsl_byte* e = madsl_dynamic_array_get(array, i);
        if (memcmp(e, element, array->cell_size) == 0) return 1;
    }
    return 0;
}



madsl_dynamic_array* madsl_dynamic_array_intersection(madsl_dynamic_array* array1, madsl_dynamic_array* array2)
{
	if (!array1 || !array2 || (array1->cell_size != array2->cell_size)) return NULL;

	madsl_dynamic_array* little_array = array1->capacity <= array2->capacity ?array1: array2;
	madsl_dynamic_array* big_array = array1->capacity <= array2->capacity ?array2: array1;

	madsl_dynamic_array* result = madsl_dynamic_array_init_uc(array1->cell_size, little_array->size);

	for (size_t i = 0; i < little_array->size; i++)
	{
		madsl_byte* element = madsl_dynamic_array_get(little_array,i);

		int contains = madsl_dynamic_array_contains(big_array,element);

		if (contains) madsl_dynamic_array_push_back(result, element);

	}
	return result;
}