src/vapiLists.c

Ir para a documentação deste ficheiro.

#include <stdio.h>
#include "vapiLists.h"
#include "vapiMacro.h"

vList *
v_list_new ()
{
        vList *List = malloc (sizeof (vList));
        *List = NULL;
        return List;
}

void
v_list_append (vList * List, vpointer data)
{

        if (*List == NULL)
        {
                *List = malloc (sizeof (vListItem));
                (*List)->data = data;
                (**List).Next = NULL;
        }
        else
        {

                v_list_append ((vList *) & (**List).Next, data);
        }

}

int
v_list_count_elements_aux (vList * List, int start)
{
        start = start + 1;

        if ((**List).Next != NULL)
        {
                start = v_list_count_elements_aux ((vList *) & (**List).
                                                   Next, start);
        }

        return start;
}

int
v_list_count_elements (vList * List)
{
        if ((*List) == NULL)
        {
                return 0;
        }
        return v_list_count_elements_aux (List, 0);
}

static void
v_list_delete_item_aux (vList * List, vList * Previous,
                        vFreeFunction FreeFunction, int Delete, int Start)
{
        vList *Temp;
        if (*List == NULL)
        {
                return;
        }

        if (Start == Delete)

        {


                if ((**List).Next != NULL)
                {
                        if (Previous == NULL)
                        {
                                Temp = (vList *) & (**List).Next;
                                if (FreeFunction != NULL)
                                {
                                        FreeFunction ((*List)->data);
                                }
                                (*List)->data = (*Temp)->data;
                                (*List)->Next =
                                        (struct vListItem *) (*Temp)->Next;
                                //free(Temp);

                        }
                        else
                        {

                                (*Previous)->Next = (*List)->Next;
                                //FreeFunction ((*List)->data);
                                //free ((*List));


                        }
                }

                else
                {
                        if (FreeFunction != NULL)
                        {
                                FreeFunction ((*List)->data);
                        }
                        free (*List);
                        *List = NULL;
                }

                return;
        }
        if ((**List).Next != NULL)
        {
                Start++;
                v_list_delete_item_aux ((vList *) & (*List)->Next,
                                        (vList *) List, FreeFunction, Delete,
                                        Start);
        }


}

void
v_list_delete_item (vList * List, vFreeFunction FreeFunction, int Delete)
{
        v_list_delete_item_aux (List, NULL, FreeFunction, Delete, 0);
}

static vpointer
v_list_get_aux (vList * List, int Item, int Start)
{

        if (*List == NULL)
        {
                return NULL;
        }

        if (Start == Item)
        {
                return (*List)->data;

        }
        if (&(**List).Next != NULL)
        {
                Start++;
                return (v_list_get_aux
                        ((vList *) & (**List).Next, Item, Start));
        }
        else
        {
                return NULL;
        }
}

vpointer
v_list_get (vList * List, int Item)
{
        return (v_list_get_aux (List, Item, 0));
}



static void
v_list_insert_aux (vList * List, vList * Previous, vpointer data,
                int position, int Start)
{
        vListItem *NewItem;


        if (Start == position)
        {

                NewItem = malloc (sizeof (vListItem));
                NewItem->data = data;
                NewItem->Next = (struct vListItem *) (*Previous);
                (*Previous) = NewItem;

                return;

        }
        if (*List == NULL)
        {
                return;
        }
        else
        {
                Start++;
                v_list_insert_aux ((vList *) & (**List).Next,
                                List, data, position, Start);
        }



}
void
v_list_insert (vList * List, vpointer data, int position)
{
        int ListSize;
        
        ListSize = v_list_count_elements(List);
        /*
         * Verificação da posição dentros dos limites da lista.
         */
        if (position <0 || position >=ListSize)
        {
                return;
        }
        /*
         * O que se pretende é ir à posição anterior e 
         *  adicionar o Operation seguinte. 
         */
        v_list_insert_aux ((vList *) & (**List).Next, List, data, position, 0);
}

void
v_list_free (vList * List, vFreeFunction FreeFunction)
{
        int Count, i;

        Count = v_list_count_elements (List);

        /*
         * Caso existam items, eliminá-los.
         */
        if (Count > 0)
        {
                for (i = Count; i > 0; i--)
                {

                        v_list_delete_item (List, FreeFunction, (i - 1));

                }
        }
        free(List);
}
void
v_list_move (vList * List, int source, int destination)

{
        vpointer * Item;
        Item = v_list_get(List, source);
        
        v_list_delete_item (List, NULL, source);
        
        if (source < destination)
        {
                destination--;
        }
        
        v_list_insert(List, Item, destination);
        
}

---