#include<stdio.h>
#include<stdlib.h>
#include "dllist.h"
// Function that compares two objects. Returns 1 if equal, 0 if not.
int
comparator(void *a, void *b)
{
if((int *)a == (void *)b)
return 1;
else;
return 0;
}
//Function that print a object
int
print(void *a)
{
}
//Function that free object
int
free_o(void *a)
{
}
int
main()
{
printf("This is a demo to show how to use dllist header.\n"); printf("---------------------\n"); printf("We add 1,2,3 int ponters to the list\n");
dllist *list;
int a=1,b=2,c=3,d=4;
dlnode *node;
list = list_new(&comparator, &print, &free_o);
list_add(list, &a);
list_add(list, &b);
list_add(list, &c);
list_print(list);
printf("Lets add one element at the end of the list.\n"); list_add_end(list, &d);
list_print(list);
printf("Now we will search for element with number 2.\n"); node = list_search(list, &b);
print(node->data);
printf("With the node we retrived from search, lets remove it from the list.\n"); list_delnode(list, node);
list_print(list);
printf("At next, we will pop the first element from the list and print the content.\n"); node = list_pop(list);
list_print(list);
return 0;
}
#ifndef list_h
#define list_h
typedef int (*dl_comparator)(void *, void *);
typedef int (*dl_print)(void *);
typedef int (*dl_freefunc)(void *);
typedef struct dlnode
{
struct dlnode *next;
struct dlnode *prev;
void *data;
}dlnode;
typedef struct dllist
{
dlnode *start;
dlnode *end;
dl_comparator comp;
dl_print print;
dl_freefunc free_func;
}dllist;
dllist *list_new(dl_comparator, dl_print, dl_freefunc);
int list_add(dllist *, void *);
int list_add_end(dllist *, void *);
dlnode *list_search(dllist *, void *);
int list_remove(dllist *, void *);
void *list_pop(dllist *);
void *list_pop_end(dllist *);
void list_free(dllist *);
void list_print(dllist *);
void *list_delnode(dllist *, dlnode *);
int list_addafternode(dlnode *, void *);
int list_addbeforenode(dlnode *, void *);
#endif
#include<stdio.h>
#include<stdlib.h>
#include "dllist.h"
dllist *
list_new(dl_comparator comp, dl_print print, dl_freefunc ff)
{
dllist *list;
if(comp && print && ff)
{
list
= malloc(sizeof(dllist
)); list->comp = comp;
list->print = print;
list->free_func = ff;
list->start = NULL;
list->end = NULL;
return list;
}
return NULL;
}
int
list_add(dllist *list, void *data)
{
dlnode *node;
dlnode *tmp;
if(!(list && data))
return 0;
node
= malloc(sizeof(dlnode
)); if(node == NULL)
return 0;
node->data = data;
if(list->start == NULL)
{
list->start = node;
list->end = node;
node->next = NULL;
node->prev = NULL;
return 1;
}
tmp = list->start;
list->start = node;
node->next = tmp;
node->prev = NULL;
tmp->prev = node;
return 1;
}
int
list_add_end(dllist *list, void *data)
{
dlnode *node;
dlnode *tmp;
if(!(list && data))
return 0;
node
= malloc(sizeof(dlnode
)); if(node == NULL)
return 0;
node->data = data;
if(list->start == NULL)
{
list->start = node;
list->end = node;
node->next = NULL;
node->prev = NULL;
return 1;
}
tmp = list->end;
list->end= node;
node->next = NULL;
node->prev = tmp;
tmp->next = node;
return 1;
}
dlnode *
list_search(dllist *list, void *data)
{
dlnode *node;
if(!list)
return NULL;
if(!(list->start))
return NULL;
if(!data)
return NULL;
node = list->start;
while(node != NULL)
{
if(list->comp(data, node->data))
return node;
node = node->next;
}
return NULL;
}
int
list_remove(dllist *list, void *data)
{
dlnode *node;
if(!list)
return 0;
if(!(list->start))
return 0;
if(!data)
return 0;
node = list->start;
while(node != NULL)
{
if(list->comp(data, node->data))
{
if(node->prev)
{
if(node->next)
node->prev->next = node->next;
else
node->prev->next = NULL;
}
if(node->next)
{
if(node->prev)
node->next->prev = node->prev;
else
node->next->prev = NULL;
}
if(list->start == node)
{
list->start = node->next;
if(!(node->next))
list->end = node->next;
}
else if(list->end == node)
{
list->end = NULL;
list->start = NULL;
}
list->free_func(node->data);
node = NULL;
return 1;
}
node = node->next;
}
return 0;
}
void *
list_pop(dllist *list)
{
dlnode *node;
void *data;
node = list->start;
node->next->prev = NULL;
data = node->data;
list->start = list->start->next;
node = NULL;
return data;
}
void *
list_pop_end(dllist *list)
{
dlnode *node;
void *data;
node = list->end;
node->prev->next = NULL;
data = node->data;
list->end = node->prev;
node = NULL;
return data;
}
void
list_free(dllist *list)
{
dlnode *node;
dlnode *tmp;
node = list->start;
while(node)
{
list->free_func(node->data);
tmp = node;
node = node->next;
tmp = NULL;
}
list = NULL;
}
void *
list_delnode(dllist *list, dlnode *node)
{
void *data;
if(!node)
return NULL;
if(node->prev)
{
if(node->next)
node->prev->next = node->next;
else
node->prev->next = NULL;
}
if(node->next)
{
if(node->prev)
node->next->prev = node->prev;
else
node->next->prev = NULL;
}
if(list->start == node)
{
list->start = node->next;
if(!(node->next))
list->end = node->next;
}
else if(list->end == node)
{
list->end = NULL;
list->start = NULL;
}
data = node->data;
node = NULL;
return data;
}
int
list_addafternode(dlnode *node, void *data)
{
dlnode *new_node;
new_node
= malloc(sizeof(new_node
)); if(!new_node)
return 0;
new_node->data = data;
new_node->next = node->next;
new_node->prev = node;
node->next = new_node;
return 1;
}
int
list_addbeforenode(dlnode *node, void *data)
{
dlnode *new_node;
new_node
= malloc(sizeof(new_node
)); if(!new_node)
return 0;
new_node->data = data;
new_node->next = node->next;
new_node->prev = node;
node->next = new_node;
return 1;
}
void
list_print(dllist *list)
{
int i = 0;
dlnode *node;
if(list)
if(list->start)
node = list->start;
else
return;
else
return;
while(node)
{
list->print(node->data);
node = node->next;
i++;
}
return;
}
#include<stdio.h>
#include<stdlib.h>

#include "dllist.h"

// Function that compares two objects. Returns 1 if equal, 0 if not. 
int 
comparator(void *a, void *b)
{
  if((int *)a == (void *)b)
    return 1;
  else;
    return 0;
}

//Function that print a object
int 
print(void *a)
{
  printf("%d\n", *((int *)a));
}

//Function that free object
int
free_o(void *a)
{
  free(a);
}

int
main()
{
  printf("This is a demo to show how to use dllist header.\n");
  printf("---------------------\n");
  printf("We add 1,2,3 int ponters to the list\n");
    
  dllist *list;
  int a=1,b=2,c=3,d=4;
  dlnode *node;
  
  list = list_new(&comparator, &print, &free_o);
  
  list_add(list, &a);
  list_add(list, &b);
  list_add(list, &c);

  list_print(list);

  printf("Lets add one element at the end of the list.\n");
  list_add_end(list, &d);
  list_print(list);
  
  printf("Now we will search for element with number 2.\n");
  node = list_search(list, &b); 
  print(node->data);

  printf("With the node we retrived from search, lets remove it from the list.\n");
  list_delnode(list, node);
  list_print(list);

  printf("At next, we will pop the first element from the list and print the content.\n");
  node = list_pop(list);
  list_print(list);
  
  return 0;
}

#ifndef list_h
#define list_h

typedef int (*dl_comparator)(void *, void *);
typedef int (*dl_print)(void *);
typedef int (*dl_freefunc)(void *);

typedef struct dlnode
{
    struct dlnode *next;
    struct dlnode *prev;
    void *data;
}dlnode;

typedef struct dllist
{
    dlnode *start;
    dlnode *end;
    dl_comparator comp;
    dl_print print;
    dl_freefunc free_func;
}dllist;

dllist  *list_new(dl_comparator, dl_print, dl_freefunc);
int     list_add(dllist *, void *);
int     list_add_end(dllist *, void *);
dlnode  *list_search(dllist *, void *);
int     list_remove(dllist *, void *);
void    *list_pop(dllist *);
void    *list_pop_end(dllist *);
void    list_free(dllist *);
void    list_print(dllist *);

void    *list_delnode(dllist *, dlnode *);
int     list_addafternode(dlnode *, void *);
int     list_addbeforenode(dlnode *, void *);
#endif

#include<stdio.h>
#include<stdlib.h>

#include "dllist.h"

dllist  *
list_new(dl_comparator comp, dl_print print, dl_freefunc ff)
{
    dllist *list;
    
    if(comp && print && ff)
    { 
        list = malloc(sizeof(dllist));
        list->comp = comp;
        list->print = print;
        list->free_func = ff;
        list->start = NULL;
        list->end = NULL;

        return list;
    }
    return NULL;
}

int     
list_add(dllist *list, void *data)
{
    dlnode *node;
    dlnode *tmp;

    if(!(list && data))
        return 0;

    node = malloc(sizeof(dlnode));
    if(node == NULL)
        return 0;
    node->data = data;

    if(list->start == NULL)
    {
        list->start = node;
        list->end = node;
        node->next = NULL;
        node->prev = NULL;
        return 1;
    }
    tmp = list->start;
    list->start = node;
    node->next = tmp;
    node->prev = NULL;
    tmp->prev = node;
    
    return 1;
}

int     
list_add_end(dllist *list, void *data)
{
    dlnode *node;
    dlnode *tmp;

    if(!(list && data))
        return 0;

    node = malloc(sizeof(dlnode));
    if(node == NULL)
        return 0;
    node->data = data;

    if(list->start == NULL)
    {
        list->start = node;
        list->end = node;
        node->next = NULL;
        node->prev = NULL;
        return 1;
    }
    tmp = list->end;
    list->end= node;
    node->next = NULL;
    node->prev = tmp;
    tmp->next = node;
    
    return 1;
}

dlnode  *
list_search(dllist *list, void *data)
{
    dlnode *node;

    if(!list)
        return NULL;
    if(!(list->start))
        return NULL;
    if(!data)
        return NULL;

    node = list->start;
    while(node != NULL)
    {
        if(list->comp(data, node->data))
            return node;
        node = node->next;
    }
    return NULL;
}

int
list_remove(dllist *list, void *data)
{
    dlnode *node;
    if(!list)
        return 0;
    if(!(list->start))
        return 0;
    if(!data)
        return 0;
            
    node = list->start;
    while(node != NULL)
    {
        if(list->comp(data, node->data))
        {
            if(node->prev)
            {
                if(node->next)
                    node->prev->next = node->next;
                else 
                    node->prev->next = NULL;
            }
            if(node->next)
            {
                if(node->prev)
                    node->next->prev = node->prev;
                else
                    node->next->prev = NULL;
            }
            
            if(list->start == node)
            {
                list->start = node->next;
                if(!(node->next))
                    list->end = node->next;
            }
            else if(list->end == node)
            {
                list->end = NULL;
                list->start = NULL;
            }
            
            list->free_func(node->data);
            free(node);
            node = NULL;

            return 1;
        }
        node = node->next;
    }
    return 0;
}

void *
list_pop(dllist *list)
{
    dlnode *node;
    void *data;
    node = list->start;
    node->next->prev = NULL;
    data = node->data;
    list->start = list->start->next;
    free(node);
    node = NULL;
    return data;
}
    
void *
list_pop_end(dllist *list)
{
    dlnode *node;
    void *data;
    node = list->end;
    node->prev->next = NULL;
    data = node->data;
    list->end = node->prev;
    free(node);
    node = NULL;
    return data;
}

void    
list_free(dllist *list)
{
    dlnode *node;
    dlnode *tmp;
    node = list->start;
    while(node)
    {
        list->free_func(node->data);
        tmp = node;
        node = node->next;
        free(tmp);
        tmp = NULL;
    }
    free(list);
    list = NULL;
}
        
void *
list_delnode(dllist *list, dlnode *node)
{
    void *data;
            
    if(!node)
        return NULL;

    if(node->prev)
    {
        if(node->next)
            node->prev->next = node->next;
        else 
            node->prev->next = NULL;
    }
    if(node->next)
    {
        if(node->prev)
            node->next->prev = node->prev;
        else
            node->next->prev = NULL;
    }
    
    if(list->start == node)
    {
        list->start = node->next;
        if(!(node->next))
            list->end = node->next;
    }
    else if(list->end == node)
    {
        list->end = NULL;
        list->start = NULL;
    }
    
    data = node->data;
    free(node);
    node = NULL;
    return data;
}

int 
list_addafternode(dlnode *node, void *data)
{
    dlnode *new_node;
    new_node = malloc(sizeof(new_node));
    if(!new_node)
        return 0;
    new_node->data = data;
    new_node->next = node->next;
    new_node->prev = node;
    node->next = new_node;
    return 1;
}

int 
list_addbeforenode(dlnode *node, void *data)
{
    dlnode *new_node;
    new_node = malloc(sizeof(new_node));
    if(!new_node)
        return 0;
    new_node->data = data;
    new_node->next = node->next;
    new_node->prev = node;
    node->next = new_node;
    return 1;
}

void    
list_print(dllist *list)
{
    int i = 0;
    dlnode *node;

    if(list)
        if(list->start)
            node = list->start;
        else
            return;
    else
        return;

    while(node)
    {
        printf("%d: ",i);
        list->print(node->data);
        node = node->next;
        i++;
    }
    return;
}