#ifndef LIST_H
#define LIST_H

#include <stdlib.h>

struct ListElmt {
	void		*data;
	struct ListElmt	*next;
};

struct List {
	int	size;

	int		(*match)(const void *key1, const void *key2);
	void		(*destroy)(void *data);

	struct ListElmt	*head, *tail;
}

/*
 * Initializes a linked list
 * List: Linked list to initialize
 * destructor:	helper to destruct and free data allocated for the list
 */
void list_init(List *list, void (*destroy)(void *data));

/*
 * Destroy a linked list, its elements and calls its destructor.
 * May or may not free memory, depends on its desctructor.
 */
void list_destroy(List *list);

/*
 * Insert a new element AFTER 'element'. If 'element is NULL, the new element is
 * inserted at the head of the list. The new element contains a pointer to
 * 'data', so, its pointer should remain valid as long as the element remains in
 * the list. It's caller's responsibility to manage storage associated with data.
 * Return: 0 if successful, negative otherwise
 */
int list_ins_next(List *list, ListElmt *element, const void *data);

/*
 * Remove the element just after 'element', if NULL, remove the element at the
 * list head. Upon return, 'data' points to the data stored in the removed
 * element. It's caller's responsibility to manage storage associated with data.
 * Return: 0 if successful, negative otherwise
 */
int list_rem_next(List *list, ListElmt *element, void **data);

#define list_size(list) ((list)->size)
#define list_head(list) ((list)->head)
#define list_tail(list) ((list)->tail)

/* Return: 1 if the element is at the head of the list, 0 otherwise */
#define list_is_head(list, element) ((element) == ((list)->head) ? 1 : 0)

/* Return: 1 if the element is at the tail of the list, 0 otherwise */
#define list_is_tail(element) ((element)->next == NULL ? 1 : 0)

/* Return: Data stored in the element */
#define list_data(element) ((element)->data)

/* Return: Element following the specified element */
#define list_next(element) ((element)->next)

#endif /* LIST_H */


#ifndef DLIST_H
#define DLIST_H
/* Doubly Linked List implementation */

/* doubly-linked list elements */
struct DListElmt {
	void			*data;
	struct DListElmt	*prev;
	struct DListElmt	*next;
};

/* doubly-linked list structure */

struct DList {
	int	size;
	int			(*match)(const void *key1, const void *key2);
	void			(*destroy)(void *data);

	struct	DlistElmt	*head, *tail;
};

/* Public interface */

void dlist_init(struct Dlist *List, void (*destroy)(void *data));
void dlist_destroy(struct DList *list);

int dlist_ins_next(struct DList *list, struct DListElmt *element,
		   const void *data);
int dlist_ins_prev(struct DList *list, struct DListElmt *element,
		   const void *data);

int dlist_remove(struct DList *list, struct DListElmt *element, void **data);

#define dlist_size(list) ((list)->size)
#define dlist_head(list) ((list)->head)
#define dlist_tail(list) ((list)->tail)

#define dlist_is_head(element) ((element)->prev == NULL ? 1 : 0)
#define dlist_is_tail(element) ((element)->next == NULL ? 1 : 0)

#define dlist_data(element) ((element)->data)
#define dlist_next(element) ((element)->next)
#define dlist_prev(element) ((element)->prev)

#endif /* DLIST_H */