DynamicList

All list related functions. More...

Macros
#define	DYN_SET_LIST(dyn)   dyn_set_list_len(dyn, LIST_DEFAULT)
	Initialize dyn as list with default length.
#define	DYN_LIST_LEN(dyn)   (dyn)->data.list->length
	Return list length.
#define	DYN_LIST_GET_REF(dyn, i)   &(dyn)->data.list->container[i]
	Return the reference to the ith element within a dynamic list.
#define	DYN_LIST_GET_END(dyn)   &(dyn)->data.list->container[DYN_LIST_LEN(dyn)-1]
	Return the reference to the last element within a list.
#define	DYN_LIST_GET_REF_END(dyn, i)   &(dyn)->data.list->container[DYN_LIST_LEN(dyn)-i]
	Return the reference to the ith element starting from the last.

Functions
trilean	dyn_set_list_len (dyn_c *dyn, dyn_ushort len)
	Set dynamic element to list with maximal length. More...
dyn_c *	dyn_list_push (dyn_c *list, const dyn_c *element)
	Push new element to the end of a list. More...
dyn_c *	dyn_list_push_none (dyn_c *list)
	Push NONE element to the end of a list. More...
trilean	dyn_list_pop (dyn_c *list, dyn_c *element)
	Pop the last element from the list and move it to param element. More...
trilean	dyn_list_get (const dyn_c *list, dyn_c *element, const dyn_short i)
	Copy the ith element of a list to param element. More...
dyn_c *	dyn_list_get_ref (const dyn_c *list, const dyn_short i)
	Return a reference to the ith element within list, negative values are allowed. More...
trilean	dyn_list_popi (dyn_c *list, const dyn_short i)
	Pop i elements from the end of a list. More...
void	dyn_list_free (dyn_c *list)
	Free the allocated memory of the entire list and set it to NONE. More...
trilean	dyn_list_copy (const dyn_c *list, dyn_c *copy)
	Make a deep copy of the entire list. More...
trilean	dyn_list_remove (dyn_c *list, dyn_ushort i)
	Delete the ith element from a list. More...
trilean	dyn_list_insert (dyn_c *list, dyn_c *element, const dyn_ushort i)
	Insert a new element at the ith position into a list. More...
trilean	dyn_list_resize (dyn_c *list, const dyn_ushort size)
	Change the maximal space of a list. More...
dyn_ushort	dyn_list_string_len (const dyn_c *list)
	Return the length of the string representation of a list. More...
void	dyn_list_string_add (const dyn_c *list, dyn_str str)
	Add string representation of a list to str. More...

Detailed Description

All list related functions.

Function Documentation

dyn_list_copy()

trilean dyn_list_copy	(	const dyn_c *	list,
		dyn_c *	copy
	)

Make a deep copy of the entire list.

See also

dyn_copy

Parameters

[in]	list	original
[in,out]	copy	new list

Return values

DYN_TRUE	if the element was found and coppied
DYN_FALSE	otherwise

Definition at line 308 of file dynamic_list.c.

Referenced by dyn_get_bool().

{
    dyn_ushort len = DYN_LIST_LEN(list);

    if (dyn_set_list_len(copy, len)) {
        list = list->data.list->container;
        while (len--) {
            if (!dyn_list_push(copy, list++)) {
                dyn_free(copy);
                return DYN_FALSE;
            }
        }
        return DYN_TRUE;
    }
    return DYN_FALSE;
}

dyn_list_free()

void dyn_list_free

(

dyn_c *

dyn

)

Free the allocated memory of the entire list and set it to NONE.

Parameters

[in,out]

list

input put has to be a list

Definition at line 67 of file dynamic_list.c.

Referenced by dyn_free().

{
    dyn_ushort len = DYN_LIST_LEN(dyn);

    // free all elements within the allocated container element
    dyn_c *ptr = dyn->data.list->container;
    while (len--) {
        dyn_free(ptr++);
    }

    free(dyn->data.list->container);
    free(dyn->data.list);
}

dyn_list_get()

trilean dyn_list_get	(	const dyn_c *	list,
		dyn_c *	element,
		const dyn_short	i
	)

Copy the ith element of a list to param element.

Copies the i value in the list to element. If the i value is negative, then the i value is relative to the last value (-1). If only the reference to the value in the list is required, use dyn_list_get_ref

See also

dyn_list_get_ref

Parameters

[in]	list	input has to be of type LIST
[in,out]	element	to copy to
[in]	i	position in list

Return values

DYN_TRUE	if the element was found and coppied
DYN_FALSE	otherwise

Definition at line 264 of file dynamic_list.c.

{
    dyn_free(element);

    dyn_c* ptr = dyn_list_get_ref(list, i);

    if (ptr) {
        return dyn_copy(ptr, element);
    }

    return DYN_FALSE;
}

dyn_list_get_ref()

dyn_c* dyn_list_get_ref	(	const dyn_c *	list,
		const dyn_short	i
	)

Return a reference to the ith element within list, negative values are allowed.

Returns the reference of the i value in list, if a negative position value is used, then the position is calculated from the end. And if the i position exceeds the length of the list, NULL is returned.

See also

dyn_list_get

Parameters

list	input has to be of type LIST
i	position in list

Returns

reference to the ith value

Definition at line 289 of file dynamic_list.c.

Referenced by dyn_dict_get_i_ref(), and dyn_list_get().

{
    dyn_list *ptr = list->data.list;
    if (i >= 0 && i<= ptr->length)
        return &ptr->container[i];
    else if (i < 0 && -i <= ptr->length)
        return &ptr->container[ ptr->length+i ];
    return NULL;
}

dyn_list_insert()

trilean dyn_list_insert	(	dyn_c *	list,
		dyn_c *	element,
		const dyn_ushort	i
	)

Insert a new element at the ith position into a list.

Insert a new element at position i to a list, all other elements with pos>i are shifted "to the left" befor the element gets inserted (moved).

// pseudo code
dyn_list_insert([0,1,3,4], "22", 2) == [0,1,"22",3,4]

Parameters

[in,out]	list	input has to be of type LIST
[in]	element	to be inserted
[in]	i	position

Return values

DYN_TRUE

if the required memory could be allocated

Definition at line 199 of file dynamic_list.c.

{
    dyn_ushort n = DYN_LIST_LEN(list);
    if (n >= i) {
        dyn_list_push_none(list);

        dyn_c *ptr = list->data.list->container;

        ++n;
        while(--n > i)
            dyn_move(&ptr[n-1], &ptr[n]);

        dyn_move(element, &ptr[i]);
    }
    return DYN_TRUE;
}

dyn_list_pop()

trilean dyn_list_pop	(	dyn_c *	list,
		dyn_c *	element
	)

Pop the last element from the list and move it to param element.

Pops the last element from the list and moves its content to parameter element. The length of the list decreases by one.

Parameters

[in,out]	list	input has to be of type LIST
[in,out]	element	where last dynamic value is moved to

Return values

DYN_TRUE

if worked properly

Definition at line 225 of file dynamic_list.c.

{
    dyn_list *ptr = list->data.list;

    dyn_move(&ptr->container[--ptr->length], element);

    if (ptr->space - ptr->length > LIST_DEFAULT)
        if (!dyn_list_resize(list, ptr->space - LIST_DEFAULT))
            return DYN_FALSE;

    return DYN_TRUE;
}

dyn_list_popi()

trilean dyn_list_popi	(	dyn_c *	list,
		dyn_short	i
	)

Pop i elements from the end of a list.

Parameters

[in,out]	list	input has to be of type LIST
[in]	i	number of elements to be popped

Definition at line 242 of file dynamic_list.c.

Referenced by dyn_list_remove().

{
    while(i--)
        dyn_free(&list->data.list->container[ --list->data.list->length ]);

    return DYN_TRUE;
}

dyn_list_push()

dyn_c* dyn_list_push	(	dyn_c *	list,
		const dyn_c *	element
	)

Push new element to the end of a list.

Pushes (copies) an additional element to the end of a list and increases the length value by one. If the maximal available space is reached, then new memory is allocated and the maximal space value gets increased, this additional size value is defined in LIST_DEFAULT.

Parameters

[in,out]	list	input has to be of type LIST
[in]	element	to be pushed

Returns

a reference to the element at the end of the list

Definition at line 124 of file dynamic_list.c.

Referenced by dyn_list_copy(), and dyn_set_insert().

{
    dyn_list *ptr = list->data.list;

    if (ptr->length == ptr->space)
        if (!dyn_list_resize(list, ptr->space + LIST_DEFAULT))
            return NULL;

    dyn_copy(element, &ptr->container[ ptr->length++ ]);

    return &ptr->container[ ptr->length-1 ];
}

dyn_list_push_none()

dyn_c* dyn_list_push_none

(

dyn_c *

list

)

Push NONE element to the end of a list.

Increses the length value of the list by one and returns a reference to the last NONE element of the list. This reference can be used to move a larger element to the end of a list, without copying.

Parameters

[in,out]

list

input has to be of type LIST

Returns

reference to the pushed NONE value

Definition at line 146 of file dynamic_list.c.

Referenced by dyn_list_insert().

{
    dyn_list *ptr = list->data.list;
    if (ptr->length == ptr->space)
        if (!dyn_list_resize(list, ptr->space + LIST_DEFAULT))
            return NULL;

    return &ptr->container[ ptr->length++ ];
}

dyn_list_remove()

trilean dyn_list_remove	(	dyn_c *	list,
		dyn_ushort	i
	)

Delete the ith element from a list.

Delete an element from the list at position i, successive elements are moved to close this gap. This function can be interpeted as the opposite to dyp_list_insert

// pseudo code
dyn_list_remove([0,1,2,3,4], 2) == [0,1,3,4]

Parameters

[in,out]	list	input has to be of type LIST
[in]	i	position to remove

Return values

DYN_TRUE	if the required memory could be allocated
DYN_FALSE	otherwise

Definition at line 172 of file dynamic_list.c.

{
    dyn_list *ptr = list->data.list;
    if (ptr->length > i) {
        for(; i<ptr->length-1; ++i) {
            dyn_move(&ptr->container[i+1], &ptr->container[i]);
        }
        dyn_list_popi(list, 1);
    }
    return DYN_TRUE;
}

dyn_list_resize()

trilean dyn_list_resize	(	dyn_c *	list,
		dyn_ushort	size
	)

Change the maximal space of a list.

Resize the maximal usable space, if the size decreases then the removed elements have to be removed previously.

Parameters

[in,out]	list	input put has to be a list
[in]	size	new maximal available space

Return values

DYN_TRUE	if the required memory could be allocated
DYN_FALSE	otherwise

Definition at line 91 of file dynamic_list.c.

Referenced by dyn_dict_resize(), dyn_list_push(), and dyn_list_push_none().

{
    dyn_list *ptr = list->data.list;

    dyn_c* new_list = (dyn_c*) realloc(ptr->container, size * sizeof(dyn_c));

    if (new_list) {
        ptr->container = new_list;

        if (ptr->space < size) {
            dyn_ushort i = ptr->length;
            for(; i<size; ++i)
                DYN_INIT(&ptr->container[i]);
        }

        ptr->space = size;
        return DYN_TRUE;
    }

    return DYN_FALSE;
}

dyn_list_string_add()

void dyn_list_string_add	(	const dyn_c *	list,
		dyn_str	str
	)

Add string representation of a list to str.

Generates a string representation of the list and all included element, segregated by commas, and attaches it to the end of the string.

Parameters

[in]	list	input has to be of type LIST
[in,out]	str	with added list representation

Definition at line 351 of file dynamic_list.c.

Referenced by dyn_get_bool().

{
    dyn_strcat(str, "[");
    dyn_ushort len = DYN_LIST_LEN(list);

    if (len == 0) {
        dyn_strcat(str, "]");
        return;
    }

    dyn_ushort i;
    for (i=0; i<len; i++) {
        dyn_string_add(DYN_LIST_GET_REF(list, i), str);
        dyn_strcat(str, ",");
    }
    str[dyn_strlen(str)-1] = ']';
}

dyn_list_string_len()

dyn_ushort dyn_list_string_len

(

const dyn_c *

list

)

Return the length of the string representation of a list.

The length of the list string representation is calculated by the length of all included elemens plus 2 brackets and the number of commas.

Parameters

list	input has to be of type LIST

Returns

length of string

Definition at line 333 of file dynamic_list.c.

Referenced by dyn_get_bool().

{
    dyn_ushort size = DYN_LIST_LEN(list)+1;
    dyn_ushort len = 2 + size;

    while (--size)
        len += dyn_string_len(DYN_LIST_GET_REF(list, size-1));

    return len;
}

dyn_set_list_len()

trilean dyn_set_list_len	(	dyn_c *	dyn,
		dyn_ushort	len
	)

Set dynamic element to list with maximal length.

Takes in any kind of dynamic paramter, frees all allocated memory and allocates a new array of dynamic elemens with a length defined in paramter len. The len paramter us used to denote the max space available space, initially the lenght of a list is marked as empty. Every application of of dyn_list_push increases the internal counter of dyn->data.list->len, until the max value dyn->data.list->space is reached, if so, new memory is allocated automatically. Every popped value by applying dyn_list_pop decreases the internal counter.

Parameters

[in,out]	dyn	input any, output LIST
[in]	len

Return values

DYN_TRUE	if the required memory could be allocated
DYN_FALSE	otherwise

Definition at line 37 of file dynamic_list.c.

Referenced by dyn_list_copy(), dyn_set_dict(), and dyn_set_set_len().

{
    dyn_free(dyn);

    dyn_list *list = (dyn_list*) malloc(sizeof(dyn_list));

    if (list) {

        list->container = (dyn_c*) malloc(len * sizeof(dyn_c));

        if (list->container) {
            list->space = len;
            list->length = 0;

            // Initialize all elements in list with NONE
            while (len--)
                DYN_INIT(&list->container[len]);

            dyn->type = LIST;
            dyn->data.list = list;
            return DYN_TRUE;
        }
        free(list);
    }
    return DYN_FALSE;
}