1.engine

src/containers/darray.h

#pragma once

#include "defines.h"

enum{

    DARRAY_CAPACITY,

    DARRAY_LENGTH,

    DARRAY_STRIDE,

    DARRAY_FIELD_LENGTH

};

KAPI void* _darray_create(u64 length,u64 stride);

KAPI void _darray_destroy(void* array);

 

KAPI u64 _darray_field_get(void* array,u64 field);

KAPI void _darray_field_set(void* array,u64 field,u64 value);

 

KAPI void* _darray_resize(void* array);

KAPI void* _darray_push(void* array,const void* value_ptr);

KAPI void _darray_pop(void* array,void* dest);

KAPI void* _darray_pop_at(void* array,u64 index,void* dest);

KAPI void* _darray_insert_at(void* array,u64 index,void* value_ptr);

#define DARRAY_DEFAULT_CAPACITY 1

#define DARRAY_RESIZE_FACTOR 2

#define darray_create(type) \

    _darray_create(DARRAY_DEFAULT_CAPACITY, sizeof(type))

#define darray_reserve(type,capacity) \

    _darray_create(capacity,sizeof(type))

#define darray_destroy(array) _darray_destroy(array);

#define darray_push(array, value)   \

    {                                \

                                        \

        typeof(value) temp = value; \

        array = _darray_push(array,&temp);\

    }  

 

#define darray_pop(array,value_ptr) \

    _darray_pop(array,value_ptr)

 

#define darray_insert_at(array,index,value) \

    {   \

        typeof(value) temp = value; \

        array = _darray_insert_at(array,index,&temp);\

    }

 

#define darray_pop_at(array,index,value_ptr) \

    _darray_pop_at(array,index,value_ptr)

#define darray_clear(array) \

    _darray_field_set(array,UARRAY_LENGTH,0)

#define darray_capacity(array) \

    _darray_field_get(array,DARRAY_CAPACITY)

#define darray_length(array) \

    _darray_field_get(array,DARRAY_LENGTH)

#define darray_stride(array) \

    _darray_field_get(array,DARRAY_STRIDE)

#define darray_length_set(array,value) \

    _darray_field_set(array,DARRAY_LENGTH,value)

2.darray.c

#include "containers/darray.h"

#include "core/kmemory.h"

#include "core/logger.h"

void* _darray_create(u64 length,u64 stride){

    u64 header_size = DARRAY_FIELD_LENGTH * sizeof(u64);

    u64 array_size = length * stride;

    u64* new_array = kallocate(header_size + array_size,MEMORY_TAG_DARRAY);

    kset_memory(new_array,0,header_size +array_size);

    new_array[DARRAY_CAPACITY] = length;

    new_array[DARRAY_LENGTH] = 0;

    new_array[DARRAY_STRIDE] = stride;

    return (void*)(new_array + DARRAY_FIELD_LENGTH);

}

void _darray_destroy(void* array){

    u64* header = (u64*)array - DARRAY_FIELD_LENGTH;

    u64 header_size = DARRAY_FIELD_LENGTH * sizeof(u64);

    u64 total_size = header_size + header[DARRAY_CAPACITY] * header[DARRAY_STRIDE];

    kfree(header,total_size,MEMORY_TAG_DARRAY);

}

 

u64 _darray_field_get(void* array,u64 field){

    u64* header = (u64*)array - DARRAY_FIELD_LENGTH;

    return header[field];

}

void _darray_field_set(void* array,u64 field,u64 value)

{

    u64* header = (u64*)array - DARRAY_FIELD_LENGTH;

    header[field] = value;

}

void* _darray_resize(void* array)

{

    u64 length = darray_length(array);

    u64 stride = darray_stride(array);

    void* temp = _darray_create(

        (DARRAY_RESIZE_FACTOR * darray_capacity(array)),

        stride

 

    );

    kcopy_memory(temp,array,length * stride);

    _darray_field_set(temp,DARRAY_LENGTH,length);

    _darray_destroy(array);

    return temp;

}

void* _darray_push(void* array,const void* value_ptr)

{

    u64 length = darray_length(array);

    u64 stride = darray_stride(array);

    if(length >= darray_capacity(array))

    {

        array = _darray_resize(array);

 

    }

    u64 addr = (u64)array;

    addr += (length * stride);

    kcopy_memory((void*)addr,value_ptr,stride);

    _darray_field_set(array,DARRAY_LENGTH,length + 1);

    return array;

}

void _darray_pop(void* array,void* dest)

{

    u64 length = darray_length(array);

    u64 stride  = darray_stride(array);

    u64 addr = (u64)array;

    addr += ((length - 1) * stride);

    kcopy_memory(dest,(void*)addr,stride);

    _darray_field_set(array,DARRAY_LENGTH,length - 1);

}

void* _darray_pop_at(void* array,u64 index,void* dest){

    u64 length = darray_length(array);

    u64 stride = darray_stride(array);

    if(index >= length)

    {

        KERROR("Index outside the bounds of this array! length: %i,index: %index",length,index);

        return array;

    }

    u64 addr = (u64)array;

    kcopy_memory(dest,(void*)(addr+(index*stride)),stride);

 

    if(index >= length-1){

        kcopy_memory(

            (void*)(addr+(index*stride)),

            (void*)(addr +(index + 1)*stride),

            stride * (length - index));

 

    }

 

    _darray_field_set(array,DARRAY_LENGTH,length - 1);

    return array;

 

}

void* _darray_insert_at(void* array,u64 index,void* value_ptr)

{

    u64 length = darray_length(array);

    u64 stride = darray_stride(array);

    if(index >= length){

        KERROR("Index outside the bounds of this array length: %i,index: %index",length,index);

        return array;

    }

    if(length >= darray_capacity(array))

    {

        array = _darray_resize(array);

    }

    u64 addr = (u64)array;

 

    if(index != length - 1)

    {

        kcopy_memory(

            (void*)(addr + ((index+1)*stride)),

            (void*)(addr +(index * stride)),

            stride *(length - index)

        );

 

    }

    kcopy_memory((void*)(addr+(index * stride)),value_ptr,stride);

    _darray_field_set(array,DARRAY_LENGTH,length + 1);

    return array;

 

}