/adlist.c
C | 296 lines | 176 code | 25 blank | 95 comment | 42 complexity | a45e721a5ef6711f9b4bb2bb142fdf24 MD5 | raw file
Possible License(s): BSD-3-Clause
- /* adlist.c - A generic doubly linked list implementation
- *
- * Copyright (c) 2006-2009, Salvatore Sanfilippo <antirez at gmail dot com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of Redis nor the names of its contributors may be used
- * to endorse or promote products derived from this software without
- * specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
- #include <stdlib.h>
- #include "adlist.h"
- #include "zmalloc.h"
- /* Create a new list. The created list can be freed with
- * AlFreeList(), but private value of every node need to be freed
- * by the user before to call AlFreeList().
- *
- * On error, NULL is returned. Otherwise the pointer to the new list. */
- list *listCreate(void)
- {
- struct list *list;
- if ((list = zmalloc(sizeof(*list))) == NULL)
- return NULL;
- list->head = list->tail = NULL;
- list->len = 0;
- list->dup = NULL;
- list->free = NULL;
- list->match = NULL;
- return list;
- }
- /* Free the whole list.
- *
- * This function can't fail. */
- void listRelease(list *list)
- {
- unsigned int len;
- listNode *current, *next;
- current = list->head;
- len = list->len;
- while(len--) {
- next = current->next;
- if (list->free) list->free(current->value);
- zfree(current);
- current = next;
- }
- zfree(list);
- }
- /* Add a new node to the list, to head, contaning the specified 'value'
- * pointer as value.
- *
- * On error, NULL is returned and no operation is performed (i.e. the
- * list remains unaltered).
- * On success the 'list' pointer you pass to the function is returned. */
- list *listAddNodeHead(list *list, void *value)
- {
- listNode *node;
- if ((node = zmalloc(sizeof(*node))) == NULL)
- return NULL;
- node->value = value;
- if (list->len == 0) {
- list->head = list->tail = node;
- node->prev = node->next = NULL;
- } else {
- node->prev = NULL;
- node->next = list->head;
- list->head->prev = node;
- list->head = node;
- }
- list->len++;
- return list;
- }
- /* Add a new node to the list, to tail, contaning the specified 'value'
- * pointer as value.
- *
- * On error, NULL is returned and no operation is performed (i.e. the
- * list remains unaltered).
- * On success the 'list' pointer you pass to the function is returned. */
- list *listAddNodeTail(list *list, void *value)
- {
- listNode *node;
- if ((node = zmalloc(sizeof(*node))) == NULL)
- return NULL;
- node->value = value;
- if (list->len == 0) {
- list->head = list->tail = node;
- node->prev = node->next = NULL;
- } else {
- node->prev = list->tail;
- node->next = NULL;
- list->tail->next = node;
- list->tail = node;
- }
- list->len++;
- return list;
- }
- /* Remove the specified node from the specified list.
- * It's up to the caller to free the private value of the node.
- *
- * This function can't fail. */
- void listDelNode(list *list, listNode *node)
- {
- if (node->prev)
- node->prev->next = node->next;
- else
- list->head = node->next;
- if (node->next)
- node->next->prev = node->prev;
- else
- list->tail = node->prev;
- if (list->free) list->free(node->value);
- zfree(node);
- list->len--;
- }
- /* Returns a list iterator 'iter'. After the initialization every
- * call to listNext() will return the next element of the list.
- *
- * This function can't fail. */
- listIter *listGetIterator(list *list, int direction)
- {
- listIter *iter;
-
- if ((iter = zmalloc(sizeof(*iter))) == NULL) return NULL;
- if (direction == AL_START_HEAD)
- iter->next = list->head;
- else
- iter->next = list->tail;
- iter->direction = direction;
- return iter;
- }
- /* Release the iterator memory */
- void listReleaseIterator(listIter *iter) {
- zfree(iter);
- }
- /* Create an iterator in the list private iterator structure */
- void listRewind(list *list, listIter *li) {
- li->next = list->head;
- li->direction = AL_START_HEAD;
- }
- void listRewindTail(list *list, listIter *li) {
- li->next = list->tail;
- li->direction = AL_START_TAIL;
- }
- /* Return the next element of an iterator.
- * It's valid to remove the currently returned element using
- * listDelNode(), but not to remove other elements.
- *
- * The function returns a pointer to the next element of the list,
- * or NULL if there are no more elements, so the classical usage patter
- * is:
- *
- * iter = listGetItarotr(list,<direction>);
- * while ((node = listNextIterator(iter)) != NULL) {
- * DoSomethingWith(listNodeValue(node));
- * }
- *
- * */
- listNode *listNext(listIter *iter)
- {
- listNode *current = iter->next;
- if (current != NULL) {
- if (iter->direction == AL_START_HEAD)
- iter->next = current->next;
- else
- iter->next = current->prev;
- }
- return current;
- }
- /* Duplicate the whole list. On out of memory NULL is returned.
- * On success a copy of the original list is returned.
- *
- * The 'Dup' method set with listSetDupMethod() function is used
- * to copy the node value. Otherwise the same pointer value of
- * the original node is used as value of the copied node.
- *
- * The original list both on success or error is never modified. */
- list *listDup(list *orig)
- {
- list *copy;
- listIter *iter;
- listNode *node;
- if ((copy = listCreate()) == NULL)
- return NULL;
- copy->dup = orig->dup;
- copy->free = orig->free;
- copy->match = orig->match;
- iter = listGetIterator(orig, AL_START_HEAD);
- while((node = listNext(iter)) != NULL) {
- void *value;
- if (copy->dup) {
- value = copy->dup(node->value);
- if (value == NULL) {
- listRelease(copy);
- listReleaseIterator(iter);
- return NULL;
- }
- } else
- value = node->value;
- if (listAddNodeTail(copy, value) == NULL) {
- listRelease(copy);
- listReleaseIterator(iter);
- return NULL;
- }
- }
- listReleaseIterator(iter);
- return copy;
- }
- /* Search the list for a node matching a given key.
- * The match is performed using the 'match' method
- * set with listSetMatchMethod(). If no 'match' method
- * is set, the 'value' pointer of every node is directly
- * compared with the 'key' pointer.
- *
- * On success the first matching node pointer is returned
- * (search starts from head). If no matching node exists
- * NULL is returned. */
- listNode *listSearchKey(list *list, void *key)
- {
- listIter *iter;
- listNode *node;
- iter = listGetIterator(list, AL_START_HEAD);
- while((node = listNext(iter)) != NULL) {
- if (list->match) {
- if (list->match(node->value, key)) {
- listReleaseIterator(iter);
- return node;
- }
- } else {
- if (key == node->value) {
- listReleaseIterator(iter);
- return node;
- }
- }
- }
- listReleaseIterator(iter);
- return NULL;
- }
- /* Return the element at the specified zero-based index
- * where 0 is the head, 1 is the element next to head
- * and so on. Negative integers are used in order to count
- * from the tail, -1 is the last element, -2 the penultimante
- * and so on. If the index is out of range NULL is returned. */
- listNode *listIndex(list *list, int index) {
- listNode *n;
- if (index < 0) {
- index = (-index)-1;
- n = list->tail;
- while(index-- && n) n = n->prev;
- } else {
- n = list->head;
- while(index-- && n) n = n->next;
- }
- return n;
- }