X-Git-Url: https://tinc-vpn.org/git/browse?p=tinc;a=blobdiff_plain;f=lib%2Flist.c;h=a26c58d603555a7bfceb77fa3a18774773a8758e;hp=5358f1980ad6193b52516c238cd1240915d7556a;hb=c0af4c37d2046ffb3e07dd62f266a4fb99ea5614;hpb=fba19c30c92d39e74f5fd5594053793b036f30f4 diff --git a/lib/list.c b/lib/list.c index 5358f198..a26c58d6 100644 --- a/lib/list.c +++ b/lib/list.c @@ -1,7 +1,7 @@ /* list.c -- functions to deal with double linked lists - Copyright (C) 2000 Ivo Timmermans - 2000 Guus Sliepen + Copyright (C) 2000-2005 Ivo Timmermans + 2000-2006 Guus Sliepen This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -13,134 +13,157 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - - $Id: list.c,v 1.1 2000/10/20 16:44:32 zarq Exp $ + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#include "config.h" +#include "system.h" -#include +#include "list.h" +#include "xalloc.h" -#include -#include -#include +/* (De)constructors */ -#include +list_t *list_alloc(list_action_t delete) { + list_t *list; -/* - list_new + list = xmalloc_and_zero(sizeof(list_t)); + list->delete = delete; - Initialize a new list. -*/ -list_t *list_new(void) -{ - list_t *list; + return list; +} - list = xmalloc_and_zero(sizeof(list_t)); - return list; +void list_free(list_t *list) { + free(list); } -/* - list_delete +list_node_t *list_alloc_node(void) { + return xmalloc_and_zero(sizeof(list_node_t)); +} - Delete the element pointed to by idx from the list. -*/ -list_node_t *list_delete(list_t *list, list_node_t *idx) -{ - list_node_t *res; - - if(!list) - return NULL; - if(!idx) - return NULL; - - if(list->callbacks->delete != NULL) - if(list->callbacks->delete(idx->data)) - error(ERR_WARNING, N_("List callback[delete] failed for %08lx - freeing anyway"), idx->data); - - free(idx->data); - - if(idx->prev == NULL) - /* First element in list */ - { - res = idx->next; - list->head = idx->next; - } - if(idx->next == NULL) - /* Last element in list */ - { - res = NULL; - list->tail = idx->prev; - } - if(idx->prev != NULL && idx->next != NULL) - /* Neither first nor last element */ - { - idx->prev->next = idx->next; - idx->next->prev = idx->prev; - } - if(list->head == NULL) - list->tail = NULL; - else - if(list->tail == NULL) - list->head = NULL; - free(idx); - return res; +void list_free_node(list_t *list, list_node_t *node) { + if(node->data && list->delete) + list->delete(node->data); + + free(node); } -/* - list_forall_nodes +/* Insertion and deletion */ - Call function() on each element in the list. If this function - returns non-zero, the element will be removed from the list. -*/ -void list_forall_nodes(list_t *list, int (*function)(void *data)) -{ - list_node_t *p; - int res; - - if(!list) /* no list given */ - return; - if(!function) /* no function given */ - return; - if(!list->head) /* list is empty */ - return; - for(p = list->head; p != NULL; p = p->next) - { - res = function(p->data); - if(res != 0) - p = list_delete(list, p); - } +list_node_t *list_insert_head(list_t *list, void *data) { + list_node_t *node; + + node = list_alloc_node(); + + node->data = data; + node->prev = NULL; + node->next = list->head; + list->head = node; + + if(node->next) + node->next->prev = node; + else + list->tail = node; + + list->count++; + + return node; } -/* - list_destroy +list_node_t *list_insert_tail(list_t *list, void *data) { + list_node_t *node; - Free all datastructures contained in this list. It uses the delete - callback for this list to free each element. -*/ -void list_destroy(list_t *list) -{ - if(!list) - return; - list_destroy_nodes(list); - free(list); + node = list_alloc_node(); + + node->data = data; + node->next = NULL; + node->prev = list->tail; + list->tail = node; + + if(node->prev) + node->prev->next = node; + else + list->head = node; + + list->count++; + + return node; } -/* - list_append +void list_unlink_node(list_t *list, list_node_t *node) { + if(node->prev) + node->prev->next = node->next; + else + list->head = node->next; - Append a new node to the list that points to data. -*/ -list_append(list_t *list, void *data) -{ - list_node_t *n; - - n = xmalloc_and_zero(sizeof(list_node_t)); - n->data = data; - n->prev = list->tail; - list->tail->next = n; - list->tail = n; + if(node->next) + node->next->prev = node->prev; + else + list->tail = node->prev; + + list->count--; +} + +void list_delete_node(list_t *list, list_node_t *node) { + list_unlink_node(list, node); + list_free_node(list, node); +} + +void list_delete_head(list_t *list) { + list_delete_node(list, list->head); +} + +void list_delete_tail(list_t *list) { + list_delete_node(list, list->tail); +} + +/* Head/tail lookup */ + +void *list_get_head(list_t *list) { + if(list->head) + return list->head->data; + else + return NULL; +} + +void *list_get_tail(list_t *list) { + if(list->tail) + return list->tail->data; + else + return NULL; +} + +/* Fast list deletion */ + +void list_delete_list(list_t *list) { + list_node_t *node, *next; + + for(node = list->head; node; node = next) { + next = node->next; + list_free_node(list, node); + } + + list_free(list); +} + +/* Traversing */ + +void list_foreach_node(list_t *list, list_action_node_t action) { + list_node_t *node, *next; + + for(node = list->head; node; node = next) { + next = node->next; + action(node); + } +} + +void list_foreach(list_t *list, list_action_t action) { + list_node_t *node, *next; + + for(node = list->head; node; node = next) { + next = node->next; + if(node->data) + action(node->data); + } }