Array

The Ambiorix Dynamic Bucket Array. More...

Collaboration diagram for Array:

Modules
	Array iterators

Data Structures
struct	_amxc_array
	The array structure. More...

Typedefs
typedef struct _amxc_array	amxc_array_t
	The array structure. More...
typedef void(*	amxc_array_it_delete_t) (amxc_array_it_t *it)
	Definition of the array item delete callback function. More...

Functions
int8_t	amxc_array_new (amxc_array_t **array, const size_t items)
	Allocates an array. More...
void	amxc_array_delete (amxc_array_t **array, const amxc_array_it_delete_t func)
	Frees the previously allocated array. More...
int	amxc_array_init (amxc_array_t *const array, const size_t items)
	Initializes an array. More...
void	amxc_array_clean (amxc_array_t *const array, amxc_array_it_delete_t func)
	Removes all items from the array. More...
int	amxc_array_grow (amxc_array_t *const array, const size_t items)
	Expands the array. More...
int	amxc_array_shrink (amxc_array_t *const array, const size_t items, amxc_array_it_delete_t func)
	Shrinks the array. More...
int	amxc_array_shift_right (amxc_array_t *const array, const size_t items, amxc_array_it_delete_t func)
	Shift all items to the right in the array. More...
int	amxc_array_shift_left (amxc_array_t *const array, const size_t items, amxc_array_it_delete_t func)
	Shift all items to the left in the array. More...
bool	amxc_array_is_empty (const amxc_array_t *const array)
	Checks that the array is empty. More...
size_t	amxc_array_size (const amxc_array_t *const array)
	Calculates the number of used items in the array. More...
amxc_array_it_t *	amxc_array_append_data (amxc_array_t *const array, void *data)
	Adds an item after the last used item in the array. More...
amxc_array_it_t *	amxc_array_prepend_data (amxc_array_t *const array, void *data)
	Adds an item before the first used item in the array. More...
amxc_array_it_t *	amxc_array_get_at (const amxc_array_t *const array, const unsigned int index)
	Gets the item iterator for the given index. More...
amxc_array_it_t *	amxc_array_set_data_at (amxc_array_t *const array, const unsigned int index, void *data)
	Sets data at the given index. More...
amxc_array_it_t *	amxc_array_get_first (const amxc_array_t *const array)
	Gets the item iterator of the first used item in the array. More...
amxc_array_it_t *	amxc_array_get_first_free (const amxc_array_t *const array)
	Gets the first free position in the array. More...
amxc_array_it_t *	amxc_array_get_last (const amxc_array_t *const array)
	Gets the item iterator of the last used item in the array. More...
amxc_array_it_t *	amxc_array_get_last_free (const amxc_array_t *const array)
	Gets the last free position in the array. More...
void *	amxc_array_take_first_data (amxc_array_t *const array)
	Takes the data pointer from the first used item in the array. More...
void *	amxc_array_take_last_data (amxc_array_t *const array)
	Takes the data pointer from the last used item in the array. More...
AMXC_INLINE size_t	amxc_array_capacity (const amxc_array_t *const array)
	Gets the capacity of the array. More...
AMXC_INLINE void *	amxc_array_get_data_at (const amxc_array_t *const array, const unsigned int index)
	Gets the data pointer of the item at the given index. More...
int	amxc_array_sort (amxc_array_t *const array, amxc_array_it_cmp_t cmp)
	Sorts the content of the array. More...

Detailed Description

The Ambiorix Dynamic Bucket Array.

A bucket is basically a pointer to a memory block (like a structure). This array implementation provides an array of pointers (aka buckets), the allocated memory for the buckets is a sequential memory block.

A bucket is considered empty when the pointer is NULL.

The array will grow dynamically when items are added to the end.

The items (or buckets) are defined using amxc_array_it_t structure. This structure contains the pointer to the data and the pointer to the beginning of the array.

Creating A Bucket Array

A bucket array can be declared on the stack or allocated in the heap. When declaring a bucket array on the stack it must be correctly initialized.

• amxc_array_init - initializes a bucket array declared on the stack
• amxc_array_new - allocates a bucket array in the heap.

Adding items

Items can be added:

• at a specific index - amxc_array_set_data_at
• after the last used - amxc_array_append_data
• before the first used - amxc_array_prepend_data

Convert An Array Bucket Iterator To Data Struct

The amxc_array_it_t contains a pointer (void *) to the data. This pointer can be fetched using amxc_array_it_get_data and cast to the correct type.

Looping Over A Bucket Array

Using a simple for loop it is possible to iterate over all buckets available. To get the full size, including the empty buckets, use amxc_array_capacity. Using an index all buckets can be addressed using amxc_array_get_at

To get the number of used buckets in the array use amxc_array_size.

If you only want to loop over the used buckets (with a non NULL data pointer), use the functions amxc_array_get_first, amxc_array_it_get_next

Removing Data From The Bucket Array

Removing a pointer from a bucket is basically resetting the data pointer to NULL. The function amxc_array_it_take_data will reset the pointer of the bucket to NULL and will return the pointer.

Finding Empty Buckets

It is possible to find the empty buckets:

• amxc_array_get_first_free - returns the first empty bucket
• amxc_array_get_last_free - returns the last empty bucket
• amxc_array_it_get_next_free - returns the next empty bucket starting from a bucket
• amxc_array_it_get_previous_free - returns the previous empty bucket starting from a bucket

Typedef Documentation

amxc_array_it_delete_t

typedef void(* amxc_array_it_delete_t) (amxc_array_it_t *it)

Definition of the array item delete callback function.

A pointer to a delete function is used in the following functions: amxc_array_delete, amxc_array_clean, amxc_array_shrink, amxc_array_shift_right, amxc_array_shift_left.

When an array contains pointers to heap allocated memory blocks, that are possibly nowhere else referenced, this may lead to memory leaks. Providing a callback function to free the memory is easier and more efficient then first iterating over the array freeing up and then call one of the previously mentioned functions.

Definition at line 194 of file amxc_array.h.

amxc_array_t

typedef struct _amxc_array amxc_array_t

The array structure.

The number of available items in the allocated buffer is tracked in the items member of this structure. C does not provide any standard way to get the size of an allocated memory block.

The structure also contains the first_used and last_used members. These are mainly used to be able to add data after the last taken position or to add data before the first taken position.

Alternatively the functions inserting data after or before can iterate over the array start from the end or from the beginning, this could have some significant impact on the performance of these functions.

Although the members of this structure are publicly available it is not recommended to access them directly, use the provided functions.

Function Documentation

amxc_array_append_data()

amxc_array_it_t* amxc_array_append_data	(	amxc_array_t *const	array,
		void *	data
	)

Adds an item after the last used item in the array.

The array grows if the item can not be added to the array.

Note

This function sets the pointer in the array. It is important that the pointer is valid as long as it is used in the array. Before freeing the memory block, remove the pointer from the array.

Parameters

array	a pointer to the array structure
data	a pointer to the data that is added to the array

Returns

returns the array iterator where the data is added, or NULL when adding the item fails.

Definition at line 429 of file amxc_array.c.

                                                                               {
    amxc_array_it_t* it = NULL;
    size_t index = 0;
    when_null(array, exit);
    when_null(data, exit);
 
    if(!amxc_array_is_empty(array)) {
        index = array->last_used + 1;
    }
 
    if(index >= array->items) {
        when_failed(amxc_array_grow(array, AMXC_ARRAY_AUTO_GROW_ITEMS), exit)
    }
 
    it = amxc_array_set_data_at(array, index, data);
 
exit:
    return it;
}

amxc_array_capacity()

AMXC_INLINE size_t amxc_array_capacity

(

const amxc_array_t *const

array

)

Gets the capacity of the array.

The capacity of an array is the number of items that can be stored in the array.

Parameters

array

pointer to the array structure

Returns

returns the capacity of the array, expressed in number of items.

Definition at line 694 of file amxc_array.h.

                                                            {
    return (array != NULL) ? array->items : 0;
}

amxc_array_clean()

void amxc_array_clean	(	amxc_array_t *const	array,
		amxc_array_it_delete_t	func
	)

Removes all items from the array.

Removes all items from the array. If a delete function is provided, it is called for each used item in the array.

Parameters

array	a pointer to the array structure
func	a pointer to a function that is called to free each used item in the array

Definition at line 261 of file amxc_array.c.

                                                                              {
    when_null(array, exit);
 
    if(func != NULL) {
        // When no delete callback function is given,
        // it is not needed to call the clean items.
        amxc_array_clean_items(array, 0, array->items, func);
    }
 
    free(array->buffer);
    array->buffer = NULL;
    array->items = 0;
    array->first_used = 0;
    array->last_used = 0;
 
exit:
    return;
}

amxc_array_delete()

void amxc_array_delete	(	amxc_array_t **	array,
		const amxc_array_it_delete_t	func
	)

Frees the previously allocated array.

Removes all items from the array, if a delete function is provided, it is called for each used item in the array.

Frees the allocated memory and sets the pointer to the array to NULL.

Note

Only call this function for arrays that are allocated on the heap using amxc_array_new

Parameters

array	a pointer to the location where the pointer to the array is stored
func	a pointer to a function that is called to free each item in the array

Definition at line 213 of file amxc_array.c.

                                                                          {
    when_null(array, exit);
    when_null(*array, exit);
 
    if(func != NULL) {
        // When no delete callback function is given,
        // it is not needed to call the clean items.
        amxc_array_clean_items(*array, 0, (*array)->items, func);
    }
 
    free((*array)->buffer);
    free(*array);
    *array = NULL;
 
exit:
    return;
}

amxc_array_get_at()

amxc_array_it_t* amxc_array_get_at	(	const amxc_array_t *const	array,
		const unsigned int	index
	)

Gets the item iterator for the given index.

Parameters

array	a pointer to the array structure
index	the position in the array for which the iterator has to be returned

Returns

returns the array iterator for the given index or NULL if the index is out of boundary.

Definition at line 504 of file amxc_array.c.

                                                             {
    amxc_array_it_t* it = NULL;
    when_null(array, exit);
    when_null(array->buffer, exit);
    when_true(index >= array->items, exit);
 
    it = &array->buffer[index];
 
exit:
    return it;
}

amxc_array_get_data_at()

AMXC_INLINE void* amxc_array_get_data_at	(	const amxc_array_t *const	array,
		const unsigned int	index
	)

Gets the data pointer of the item at the given index.

Parameters

array	pointer to the array structure
index	the index of the item

Returns

returns the data pointer of the item at the given index or NULL if no data pointer was stored in that item or when the index is out of boundery.

Definition at line 711 of file amxc_array.h.

                                                       {
    amxc_array_it_t* it = amxc_array_get_at(array, index);
    return (it != NULL) ? it->data : NULL;
}

amxc_array_get_first()

amxc_array_it_t* amxc_array_get_first

(

const amxc_array_t *const

array

)

Gets the item iterator of the first used item in the array.

Parameters

array

a pointer to the array structure

Returns

returns the array iterator for the first used item in the array or NULL if there is no used item in the array.

Definition at line 517 of file amxc_array.c.

                                                                       {
    amxc_array_it_t* it = NULL;
    when_null(array, exit);
 
    if(!amxc_array_is_empty(array)) {
        it = &array->buffer[array->first_used];
    }
 
exit:
    return it;
}

amxc_array_get_first_free()

amxc_array_it_t* amxc_array_get_first_free

(

const amxc_array_t *const

array

)

Gets the first free position in the array.

Parameters

array

a pointer to the array structure

Returns

returns the array iterator for the first free item in the array or NULL if there is no free item in the array.

Definition at line 529 of file amxc_array.c.

                                                                            {
    amxc_array_it_t* it = NULL;
    size_t index = 0;
    when_null(array, exit);
 
    while(index < array->items && array->buffer[index].data != NULL) {
        index++;
    }
 
    if(index < array->items) {
        it = &array->buffer[index];
    }
 
exit:
    return it;
}

amxc_array_get_last()

amxc_array_it_t* amxc_array_get_last

(

const amxc_array_t *const

array

)

Gets the item iterator of the last used item in the array.

Parameters

array

a pointer to the array structure

Returns

returns the array iterator for the last used item in the array or NULL if there is no used item in the array.

Definition at line 546 of file amxc_array.c.

                                                                      {
    amxc_array_it_t* it = NULL;
    when_null(array, exit);
 
    if(!amxc_array_is_empty(array)) {
        it = &array->buffer[array->last_used];
    }
 
exit:
    return it;
}

amxc_array_get_last_free()

amxc_array_it_t* amxc_array_get_last_free

(

const amxc_array_t *const

array

)

Gets the last free position in the array.

Parameters

array

a pointer to the array structure

Returns

returns the array iterator for the last free item in the array or NULL if there is no free item in the array.

Definition at line 558 of file amxc_array.c.

                                                                           {
    amxc_array_it_t* it = NULL;
    size_t index = 0;
    when_null(array, exit);
 
    index = array->items;
    while(index > 0 && array->buffer[index - 1].data != NULL) {
        index--;
    }
 
    if(index > 0) {
        it = &array->buffer[index - 1];
    }
 
exit:
    return it;
}

amxc_array_grow()

int amxc_array_grow	(	amxc_array_t *const	array,
		const size_t	items
	)

Expands the array.

Expands the array by the given number of items. Extra memory is allocated to be able to store the number of items requested.

Parameters

array	a pointer to the array structure
items	the number of items the array has to grow

Returns

0 on success. -1 if an error has occured.

Definition at line 280 of file amxc_array.c.

                                                                   {
    int retval = -1;
    size_t old_items = 0;
    when_null(array, exit);
 
    if(items == 0) {
        retval = 0;
        goto exit;
    }
 
    old_items = array->items;
    retval = amxc_array_realloc(array, array->items + items);
    amxc_array_initialize_items(array, old_items);
 
exit:
    return retval;
}

amxc_array_init()

int amxc_array_init	(	amxc_array_t *const	array,
		const size_t	items
	)

Initializes an array.

Initializes the array structure. Memory is allocated from the heap to be able to store the number of items requested. All the items are initialized to NULL. This function is typically called for arrays that are on the stack. Allocating and initializing an array on the heap can be done using amxc_array_new

Note

When calling this function on an already initialized array, that contains items, the array is reset and all items in the array are lost (This could potentially lead to memory leaks). Use amxc_array_clean to remove all items from the list.

Parameters

array	a pointer to the array structure.
items	the size of the array in number of items

Returns

0 on success. -1 if a NULL pointer is given.

Definition at line 231 of file amxc_array.c.

                                                                   {
    int retval = -1;
    when_null(array, exit);
 
    // initialize array data
    array->items = 0;
    array->buffer = NULL;
    array->first_used = 0;
    array->last_used = 0;
 
    // if no items need to be pre-allocated, leave
    if(items == 0) {
        retval = 0;
        goto exit;
    }
 
    // allocate the buffer
    amxc_array_realloc(array, items);
    when_null(array->buffer, exit);
 
    // set the allocated size
    array->items = items;
    amxc_array_initialize_items(array, 0);
 
    retval = 0;
 
exit:
    return retval;
}

amxc_array_is_empty()

bool amxc_array_is_empty

(

const amxc_array_t *const

array

)

Checks that the array is empty.

An array is empty if none of the items are used.

Parameters

array

a pointer to the array structure

Returns

returns true when the array contains no items that are used, false when there is at least one item used in the array.

Definition at line 399 of file amxc_array.c.

                                                          {
    bool retval = true;
    when_null(array, exit);
 
    if(array->last_used != 0) {
        retval = false;
    }
 
    if((array->buffer != NULL) && (array->buffer[0].data != NULL)) {
        retval = false;
    }
 
exit:
    return retval;
}

amxc_array_new()

int8_t amxc_array_new	(	amxc_array_t **	array,
		const size_t	items
	)

Allocates an array.

Allocates and initializes memory to store an array. This function allocates memory from the heap, if an array is on the stack, it can be initialized using the function amxc_array_init

The size of the array is not fixed and can be changed with the functions amxc_array_grow or amxc_array_shrink

The size of the array is expressed in number of items that can be stored in the array. All items in the allocated array are set to NULL.

Note

The allocated memory must be freed when not used anymore, use amxc_array_delete to free the memory

Parameters

array	a pointer to the location where the pointer to the new array can be stored
items	the size of the array in number of items

Returns

-1 if an error occurred. 0 on success

Definition at line 179 of file amxc_array.c.

                                                                {
    int8_t retval = -1;
    when_null(array, exit);
 
    /* allocate the array structure */
    *array = (amxc_array_t*) calloc(1, sizeof(amxc_array_t));
    when_null(*array, exit);
 
    /* set the number of items in the array */
    (*array)->items = items;
    (*array)->first_used = 0;
    (*array)->last_used = 0;
 
    /* if no items need to be pre-allocated, leave */
    if(items == 0) {
        retval = 0;
        goto exit;
    }
 
    /* allocate the buffer */
    amxc_array_realloc(*array, items);
    if((*array)->buffer == NULL) {
        free(*array);
        *array = NULL;
        goto exit;
    }
    amxc_array_initialize_items(*array, 0);
 
    retval = 0;
 
exit:
    return retval;
}

amxc_array_prepend_data()

amxc_array_it_t* amxc_array_prepend_data	(	amxc_array_t *const	array,
		void *	data
	)

Adds an item before the first used item in the array.

The array grows if the item can not be added to the array.

Note

This function sets the pointer in the array. It is important that the pointer is valid as long as it is used in the array. Before freeing the memory block, remove the pointer from the array.

Parameters

array	a pointer to the array structure
data	a pointer to the data that is added to the array

Returns

returns the array iterator where the data is added, or NULL when adding the item fails.

Definition at line 449 of file amxc_array.c.

                                                                                {
    amxc_array_it_t* it = NULL;
    size_t index = 0;
    bool grow = false;
    when_null(array, exit);
    when_null(data, exit);
 
    grow = ((!amxc_array_is_empty(array) && array->first_used == 0) ||
            (array->buffer == NULL));
 
    if(grow) {
        when_failed(amxc_array_grow(array, AMXC_ARRAY_AUTO_GROW_ITEMS), exit);
        amxc_array_shift_right(array, AMXC_ARRAY_AUTO_GROW_ITEMS, NULL);
    }
 
    if(!amxc_array_is_empty(array)) {
        index = array->first_used - 1;
    }
 
    it = amxc_array_set_data_at(array, index, data);
 
exit:
    return it;
}

amxc_array_set_data_at()

amxc_array_it_t* amxc_array_set_data_at	(	amxc_array_t *const	array,
		const unsigned int	index,
		void *	data
	)

Sets data at the given index.

Note

This function sets the pointer in the array. It is important that the pointer is valid as long as it is used in the array. Before freeing the memory block, remove the pointer from the array.

Parameters

array	a pointer to the array structure
index	position in the array where the data has to be set
data	pointer to the data that has to be set in the array

Returns

returns the array iterator for the given index or NULL if the index is out of boundary.

Definition at line 474 of file amxc_array.c.

                                                    {
    amxc_array_it_t* it = amxc_array_get_at(array, index);
    when_null(it, exit);
 
    if(data != NULL) {
        if(amxc_array_is_empty(array)) {
            array->last_used = index;
            array->first_used = index;
        } else {
            array->last_used = (array->last_used < index) ? index : array->last_used;
            array->first_used = (array->first_used > index) ? index : array->first_used;
        }
        it->data = data;
    } else {
        void* tmp = it->data;
        it->data = data;
        if((tmp != NULL) && (index == array->last_used)) {
            array->last_used = amxc_array_calculate_last_used(array, array->last_used);
        }
        if((tmp != NULL) && (index == array->first_used)) {
            array->first_used = amxc_array_calculate_first_used(array, array->first_used);
        }
    }
 
exit:
    return it;
}

amxc_array_shift_left()

int amxc_array_shift_left	(	amxc_array_t *const	array,
		const size_t	items,
		amxc_array_it_delete_t	func
	)

Shift all items to the left in the array.

Moves all items in the array to the left with the given number of items. Items that are moved out of the array are removed from the array. A function can be provided that is called for each used item that is removed from the array.

E.g. Shifting the array to the left by 3 items, moves the item on index 3 to index 0, the item on index 4 to index 1, ...

The items at the end of the array are reinitialized to NULL.

Parameters

array	a pointer to the array structure
items	the number of items that needs to be shifted
func	a pointer to a function that is called to free each used item in the array, that is moved out of the array.

Returns

0 on success. -1 if an error has occured

Definition at line 361 of file amxc_array.c.

                                                       {
    int retval = -1;
    amxc_array_it_t* src = NULL;
    amxc_array_it_t* dst = NULL;
    size_t len = 0;
    when_null(array, exit);
    when_true(items > array->items, exit);
 
    if(!items) {
        retval = 0;
        goto exit;
    }
 
    if(items == array->items) {
        amxc_array_clean_items(array, 0, array->items, func);
        retval = 0;
        array->last_used = 0;
        array->first_used = 0;
        goto exit;
    }
 
    src = &array->buffer[items];
    dst = array->buffer;
    len = (array->items - items) * sizeof(amxc_array_it_t);
 
    memmove(dst, src, len);
    amxc_array_clean_items(array, array->items - items, items, func);
    array->first_used = amxc_array_calculate_first_used(array, 0);
    array->last_used = amxc_array_calculate_last_used(array, array->items - items);
 
    retval = 0;
 
exit:
    return retval;
}

amxc_array_shift_right()

int amxc_array_shift_right	(	amxc_array_t *const	array,
		const size_t	items,
		amxc_array_it_delete_t	func
	)

Shift all items to the right in the array.

Moves all items in the array to the right with the given number of items. Items that are moved out of the array are removed from the array. A function can be provided that is called for each used item that is removed from the array.

E.g. Shifting the array to the right by 3 items, moves the item on index 0 to index 3, the item on index 1 to index 4, ...

The items in the beginning of the array are reinitialized to NULL.

Parameters

array	a pointer to the array structure
items	the number of items that needs to be shifted
func	a pointer to a function that is called to free each used item in the array, that is moved out of the array.

Returns

0 on success. -1 if an error has occured

Definition at line 323 of file amxc_array.c.

                                                        {
    int retval = -1;
    amxc_array_it_t* src = NULL;
    amxc_array_it_t* dst = NULL;
    size_t len = 0;
    when_null(array, exit);
    when_true(items > array->items, exit);
 
    if(!items) {
        retval = 0;
        goto exit;
    }
 
    if(items == array->items) {
        amxc_array_clean_items(array, 0, array->items, func);
        array->last_used = 0;
        array->first_used = 0;
        retval = 0;
        goto exit;
    }
 
    src = array->buffer;
    dst = &array->buffer[items];
    len = (array->items - items) * sizeof(amxc_array_it_t);
 
    memmove(dst, src, len);
    amxc_array_clean_items(array, 0, items, func);
    array->first_used = amxc_array_calculate_first_used(array, items);
    array->last_used = amxc_array_calculate_last_used(array, array->items - 1);
 
    retval = 0;
 
exit:
    return retval;
}

amxc_array_shrink()

int amxc_array_shrink	(	amxc_array_t *const	array,
		const size_t	items,
		amxc_array_it_delete_t	func
	)

Shrinks the array.

Shrinks the array by the given number of items. Memory is freed. If a delete function is provided it is called for each used item that is removed from the array.

Parameters

array	a pointer to the array structure
items	the number of items the array has to shrink
func	pointer to a function that is called to free each used item in the array

Returns

0 on success. -1 if an error has occured

Definition at line 298 of file amxc_array.c.

                                                   {
    int retval = -1;
    when_null(array, exit);
    when_true(items > array->items, exit); // out of range
 
    if(items == array->items) {
        amxc_array_clean(array, func);
 
        retval = 0;
        goto exit;
    }
 
    amxc_array_clean_items(array, array->items - items, items, func);
    retval = amxc_array_realloc(array, array->items - items);
    array->last_used = amxc_array_calculate_last_used(array, array->items - 1);
    if(array->first_used > array->items - 1) {
        array->first_used = 0;
    }
 
exit:
    return retval;
}

amxc_array_size()

size_t amxc_array_size

(

const amxc_array_t *const

array

)

Calculates the number of used items in the array.

Loops over all items in the array and counts the used items. The size of the array is expressed in used items.

Note

Use amxc_array_is_empty to check if an array is empty, do not use this function to check if there are used items in the array. This function is looping over the complete array and counts the used items. For large arrays this could have some noticeable performance impact.

Parameters

array

a pointer to the array structure

Returns

returns the number of used items in the array

Definition at line 415 of file amxc_array.c.

                                                        {
    size_t retval = 0;
    when_null(array, exit);
 
    for(size_t index = 0; index < array->items; index++) {
        if(array->buffer[index].data != NULL) {
            retval++;
        }
    }
 
exit:
    return retval;
}

amxc_array_sort()

int amxc_array_sort	(	amxc_array_t *const	array,
		amxc_array_it_cmp_t	cmp
	)

Sorts the content of the array.

The smallest items according to the compare functions are at the beginning of the array, empty buckets are at the end.

Parameters

array	the array that will be sorted
cmp	array iterator content compare function

Returns

0 when the array is sorted. TODO -1 if sorting fails?

Definition at line 596 of file amxc_array.c.

                                                                        {
    int retval = -1;
    size_t i = 0;
    when_null(array, exit);
    when_null(cmp, exit);
 
    if(array->last_used == 0) {
        retval = 0;
        goto exit;
    }
    i = array->last_used;
    do {
        i--;
        if(array->buffer[i].data == NULL) {
            amxc_array_it_swap(&array->buffer[i],
                               &array->buffer[array->last_used]);
            array->last_used--;
        }
    } while(i != 0);
 
    retval = amxc_array_sort_internal(array, cmp, 0, array->last_used);
 
exit:
    return retval;
}

amxc_array_take_first_data()

void* amxc_array_take_first_data

(

amxc_array_t *const

array

)

Takes the data pointer from the first used item in the array.

Parameters

array

a pointer to the array structure

Returns

returns the data pointer of the first used item in the array or NULL if there is no used item in the array.

Definition at line 576 of file amxc_array.c.

                                                            {
    void* data = NULL;
    amxc_array_it_t* it = amxc_array_get_first(array);
    if(it != NULL) {
        data = it->data;
        amxc_array_set_data_at(array, amxc_array_it_index(it), NULL);
    }
    return data;
}

amxc_array_take_last_data()

void* amxc_array_take_last_data

(

amxc_array_t *const

array

)

Takes the data pointer from the last used item in the array.

Parameters

array

a pointer to the array structure

Returns

returns the data pointer of the last used item in the array or NULL if there is no used item in the array.

Definition at line 586 of file amxc_array.c.

                                                           {
    void* data = NULL;
    amxc_array_it_t* it = amxc_array_get_last(array);
    if(it != NULL) {
        data = it->data;
        amxc_array_set_data_at(array, amxc_array_it_index(it), NULL);
    }
    return data;
}