DynamicDictionary

Macros
#define	DYN_DICT_LEN(dyn)   dyn->data.dict->value.data.list->length
	Return number of elements within a dictionary.
#define	DYN_DICT_GET_I_REF(dyn, i)   &(dyn)->data.dict->value.data.list->container[i]
	Return a reference to the ith element stored within a dictionary.
#define	DYN_DICT_GET_I_KEY(dyn, i)   (dyn)->data.dict->key[i]
	Return a reference to the ith key stored within a dictionary.
#define	DYN_DICT_SPACE(dyn)   dyn->value.data.list->space
	Return the maximal usable number of elements of a dictionary.
#define	DYN_DICT_LENGTH(dyn)   dyn->value.data.list->length
	Return the number of elements stored within a dictionary.

Functions
trilean	dyn_set_dict (dyn_c *dyn, const dyn_ushort length)
	Set dyn to a dictionary with a max. length of elements. More...
trilean	dyn_dict_change (dyn_c *dict, const dyn_ushort i, const dyn_c *value)
	Replace the ith element in a dictionary with a new value.
dyn_c *	dyn_dict_insert (dyn_c *dict, dyn_const_str key, dyn_c *value)
	Insert a new key-value pair into the dictionary. More...
trilean	dyn_dict_remove (dyn_c *dict, dyn_const_str key)
	Remove key-value pair from dictionary. More...
dyn_c *	dyn_dict_get (const dyn_c *dict, dyn_const_str key)
	Get the reference to value stored at key. More...
trilean	dyn_dict_resize (dyn_c *dict, const dyn_ushort size)
	Set the available space for elements. More...
dyn_c *	dyn_dict_get_i_ref (const dyn_c *dict, const dyn_ushort i)
	Get the reference to ith value in dict. More...
dyn_str	dyn_dict_get_i_key (const dyn_c *dict, const dyn_ushort i)
	Get the reference to ith key in dict. More...
dyn_ushort	dyn_dict_has_key (const dyn_c *dict, dyn_const_str key)
	Check if dict has key and return its position - 1 (returns 0 if not found) More...
void	dyn_dict_empty (dyn_c *dict)
	todo More...
void	dyn_dict_free (dyn_c *dict)
	Free all allocated memory. More...
trilean	dyn_dict_copy (const dyn_c *dict, dyn_c *copy)
	Copy the entire dict.
dyn_ushort	dyn_dict_string_len (const dyn_c *dict)
	Calculate the required string length.
void	dyn_dict_string_add (const dyn_c *dict, dyn_str string)
	Add the dict-string representation to string.

Detailed Description

Function Documentation

dyn_dict_empty()

void dyn_dict_empty

(

dyn_c *

dict

)

todo

Parameters

dict	to be freed has to be of type DICT

Return values

DYN_TRUE

if the key value pair was found and removed

Definition at line 229 of file dynamic_dict.c.

Referenced by dyn_dict_free().

{
    dyn_dict* ptr = dict->data.dict;

    dyn_ushort i = DYN_DICT_LENGTH(ptr);
    while (i--) {
        free(ptr->key[i]);
        ptr->key[i] = NULL;
        dyn_free(DYN_DICT_GET_I_REF(dict, i));
    }
    ptr->value.data.list->length = 0;
}

dyn_dict_free()

void dyn_dict_free

(

dyn_c *

dict

)

Free all allocated memory.

Parameters

dict	has to be of type DICT

Definition at line 245 of file dynamic_dict.c.

Referenced by dyn_free().

{
    dyn_dict_empty(dict);
    dyn_free(&dict->data.dict->value);
    free(dict->data.dict->key);
    free(dict->data.dict);
}

dyn_dict_get()

dyn_c* dyn_dict_get	(	const dyn_c *	dict,
		dyn_const_str	key
	)

Get the reference to value stored at key.

Searches the dictionary for a certain key and removes the key value pair. The last element is moved to the freed position to spare space, such that there are no free positions within the linear dictionary representation.

Parameters

dict	has to be of type DICT
key	of the key-value pair to remove

Returns

reference to the value stored under the given key, if exists, otherwise NULL

Definition at line 264 of file dynamic_dict.c.

{
    dyn_ushort pos = dyn_dict_has_key(dict, key);

    if (pos)
        return DYN_DICT_GET_I_REF(dict, --pos);

    return NULL;
}

dyn_dict_get_i_key()

dyn_str dyn_dict_get_i_key	(	const dyn_c *	dict,
		const dyn_ushort	i
	)

Get the reference to ith key in dict.

This function is only used to offer an interface, such that values of the library can also be accsessed externally. Internally it is recommended to use the macro DYN_DICT_GET_I_KEY

Parameters

dyn	has to be of type DICT
i	position of the key

Returns

reference to the ith key (C-string)

Definition at line 183 of file dynamic_dict.c.

{
    return dict->data.dict->key[i];
}

dyn_dict_get_i_ref()

dyn_c* dyn_dict_get_i_ref	(	const dyn_c *	dict,
		const dyn_ushort	i
	)

Get the reference to ith value in dict.

This function is only used to offer an interface, such that values of the library can also be accsessed externally. Internally it is recommended to use the macro DYN_DICT_GET_I_REF

Parameters

dict	has to be of type DICT
i	position of the dynamic value

Returns

reference to the ith value in dyn

Definition at line 168 of file dynamic_dict.c.

{
    return dyn_list_get_ref(&dict->data.dict->value, i);
}

dyn_dict_has_key()

dyn_ushort dyn_dict_has_key	(	const dyn_c *	dict,
		dyn_const_str	key
	)

Check if dict has key and return its position - 1 (returns 0 if not found)

Searches the dictionary for a certain key, if this key could be found, then its position plus 1 is returned, to indicate that the key was found, even if it is on position 0, otherwise 0 is returned. Thus, the returned value has to be decreased by one if it is larger than 0.

Parameters

dict	to be searched has to be of type DICT
key	C-string to search for

Return values

0	if the key was not found
position+1	otherwise

Definition at line 145 of file dynamic_dict.c.

Referenced by dyn_dict_get(), dyn_dict_insert(), and dyn_dict_remove().

{
    dyn_char** s_key = dict->data.dict->key;
    dyn_ushort length = DYN_DICT_LENGTH(dict->data.dict);
    dyn_ushort i;
    for (i=0; i<length; ++i, ++s_key) {
        if (!dyn_strcmp(*s_key, key))
            return i+1;
    }

    return 0;
}

dyn_dict_insert()

dyn_c* dyn_dict_insert	(	dyn_c *	dict,
		dyn_const_str	key,
		dyn_c *	value
	)

Insert a new key-value pair into the dictionary.

If the key is already contained within the dictionary, then the current value is overwritten, if not then the new value is added to the end of the list as well as a new key. If the maximal space is exceeded, then new memory is attached as defined in DICT_DEFAULT.

Parameters

[in,out]	dict	has to be of type DICT
[in]	key
[in]	value	to be coppied

Returns

reference to the newly inserted value, if insertion was not possible, NULL is returned

Definition at line 65 of file dynamic_dict.c.

Referenced by dyn_dict_copy().

{
    dyn_dict* ptr = dict->data.dict;
    dyn_ushort space = DYN_DICT_SPACE(ptr);
    dyn_ushort i = dyn_dict_has_key(dict, key);
    if (i--)
        goto GOTO__CHANGE; //return dyn_dict_change(dyn, i-1, value);

    if (DYN_DICT_LENGTH(ptr) == space) {
        dyn_dict_resize(dict, space + DICT_DEFAULT);
        /*if (dyn_list_resize(&dyn->data.dict->value, space)) {
            dyn->data.dict->key = (dyn_str*) realloc(dyn->data.dict->key, space * sizeof(dyn_str*));
            if (dyn->data.dict->key) {
                for (i=space - DICT_DEFAULT; i<space; ++i)
                    dyn->data.dict->key[i] = NULL;
            }
        }*/
    }

    i = DYN_DICT_LENGTH(ptr);
    ptr->key[i] = (dyn_str) malloc(dyn_strlen(key)+1);
    if (ptr->key[i]) {
        dyn_strcpy(ptr->key[i], key);
        DYN_DICT_LENGTH(ptr)++;

GOTO__CHANGE:
        dyn_dict_change(dict, i, value);
        return dyn_dict_get_i_ref(dict, i);
    }

    return NULL;
}

dyn_dict_remove()

trilean dyn_dict_remove	(	dyn_c *	dict,
		dyn_const_str	key
	)

Remove key-value pair from dictionary.

Searches the dictionary for a certain key and removes the key value pair. The last element is moved to the freed position to spare space, such that there are no free positions within the linear dictionary representation.

Parameters

dict	has to be of type DICT
key	of the key-value pair to remove

Return values

DYN_TRUE	if the key value pair was found and removed
DYN_FALSE	otherwise

Definition at line 199 of file dynamic_dict.c.

{
    dyn_dict* ptr = dict->data.dict;
    dyn_ushort i = dyn_dict_has_key(dict, key);

    if(i) {
        free(ptr->key[--i]);
        ptr->key[i] = NULL;
        dyn_free(DYN_DICT_GET_I_REF(dict, i));
        ptr->value.data.list->length--;

        // if not last element
        if (i != ptr->value.data.list->length && ptr->value.data.list->length) {
            ptr->key[i] = ptr->key[ptr->value.data.list->length];
            ptr->key[ptr->value.data.list->length] = NULL;
            dyn_move(DYN_DICT_GET_I_REF(dict, ptr->value.data.list->length),
                     DYN_DICT_GET_I_REF(dict, i));
        }

        return DYN_TRUE;
    }

    return DYN_FALSE;
}

dyn_dict_resize()

trilean dyn_dict_resize	(	dyn_c *	dict,
		dyn_ushort	size
	)

Set the available space for elements.

Increase or decrease the size of the dictionary to a new size, removed elements have to be of type NONE.

Parameters

[in,out]	dict	has to be of type DICT
[in]	size	new

Return values

DYN_TRUE	if operation could be performed
DYN_FALSE	otherwise

Definition at line 108 of file dynamic_dict.c.

Referenced by dyn_dict_insert().

{
    dyn_dict* ptr = dict->data.dict;

    dyn_ushort space = DYN_DICT_SPACE(ptr);

    if (size > space)
        if (dyn_list_resize(&ptr->value, size)) {
            ptr->key = (dyn_str*) realloc(ptr->key, size * sizeof(dyn_str*));
            if (ptr->key) {
                for (; space<size; ++space)
                    ptr->key[space] = NULL;
                return DYN_TRUE;
            }
        }

    return DYN_FALSE;
}

dyn_set_dict()

trilean dyn_set_dict	(	dyn_c *	dyn,
		dyn_ushort	length
	)

Set dyn to a dictionary with a max. length of elements.

Parameters

[in,out]	dyn	element which is initialized as a dictionary
[in]	length	of preallocated memory

Return values

DYN_TRUE	if memory for the DICT could be allocated
DYN_FALSE	otherwise

Definition at line 25 of file dynamic_dict.c.

Referenced by dyn_dict_copy().

{
    dyn_free(dyn);

    dyn_dict *dict = (dyn_dict*) malloc(sizeof(dyn_dict));

    if (dict) {
        DYN_INIT(&dict->value);
        if (dyn_set_list_len(&dict->value, length)) {
            dict->key = (dyn_str*) malloc(length * sizeof(dyn_str*));
            if (dict->key) {
                dyn_ushort i;
                for (i=0; i<length; ++i)
                    dict->key[i] = NULL;

                dyn->type = DICT;
                dyn->data.dict = dict;
                return DYN_TRUE;
            }
            dyn_free(&dict->value);
        }
        free(dict);
    }

    return DYN_FALSE;
}