diff options
author | Luo Jinghua <sunmoon1997@gmail.com> | 2009-10-30 10:38:05 +0800 |
---|---|---|
committer | Luo Jinghua <sunmoon1997@gmail.com> | 2009-10-30 10:38:05 +0800 |
commit | 0ba8c53d2de976dcea43624ee4dfd29d82215591 (patch) | |
tree | 70549f1783c29b9d4ea4d7fc19e82b966677decd | |
parent | 908026258ec3f53a311cadd2fb151859e84fbe2e (diff) |
milkway: steal the single list implementation from glib
-rw-r--r-- | milkway/Makefile.am | 2 | ||||
-rw-r--r-- | milkway/mw-slist.c | 949 | ||||
-rw-r--r-- | milkway/mw-slist.h | 156 |
3 files changed, 1107 insertions, 0 deletions
diff --git a/milkway/Makefile.am b/milkway/Makefile.am index df428cf..ee4f67e 100644 --- a/milkway/Makefile.am +++ b/milkway/Makefile.am @@ -21,6 +21,7 @@ milkway_headers = \ mw-object.h \ mw-connection-mgr.h \ mw-list.h \ + mw-slist.h \ mw-source.h libmilkway_la_LDFLAGS = -version-info $(LT_VERSION_INFO) -no-undefined @@ -50,6 +51,7 @@ libmilkway_la_SOURCES = \ mw-object.c \ mw-connection-mgr.c \ mw-list.c \ + mw-slist.c \ mw-source.c milkwayincludedir = $(includedir)/milkway/milkway diff --git a/milkway/mw-slist.c b/milkway/mw-slist.c new file mode 100644 index 0000000..cc394c4 --- /dev/null +++ b/milkway/mw-slist.c @@ -0,0 +1,949 @@ +/* GLIB - Library of useful routines for C programming + * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/* + * Modified by the GLib Team and others 1997-2000. See the AUTHORS + * file for a list of people on the GLib Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GLib at ftp://ftp.gtk.org/pub/gtk/. + */ + +/* + * MT safe + */ + +#include <milkwayint.h> +#include "milkway/mw-slist.h" + +#include <stdlib.h> + +#define _mw_slist_alloc0() calloc (1, sizeof(mw_slist_t)) +#define _mw_slist_alloc() malloc (sizeof(mw_slist_t)) +#define _mw_slist_free1(slist) free (slist) + +mw_slist_t* +mw_slist_alloc (void) +{ + return _mw_slist_alloc0 (); +} + +/** + * mw_slist_free: + * @list: a #mw_slist_t + * + * Frees all of the memory used by a #mw_slist_t. + * The freed elements are returned to the slice allocator. + */ +void +mw_slist_free (mw_slist_t *list) +{ + mw_slist_t *last = list; + mw_slist_t *next; + + if (!list) + return; + + for (;last; last = next) { + next = last->next; + _mw_slist_free1 (last); + } +} + +/** + * mw_slist_free_1: + * @list: a #mw_slist_t element + * + * Frees one #mw_slist_t element. + * It is usually used after mw_slist_remove_link(). + */ +void +mw_slist_free_1 (mw_slist_t *list) +{ + _mw_slist_free1 (list); +} + +/** + * mw_slist_append: + * @list: a #mw_slist_t + * @data: the data for the new element + * + * Adds a new element on to the end of the list. + * + * <note><para> + * The return value is the new start of the list, which may + * have changed, so make sure you store the new value. + * </para></note> + * + * <note><para> + * Note that mw_slist_append() has to traverse the entire list + * to find the end, which is inefficient when adding multiple + * elements. A common idiom to avoid the inefficiency is to prepend + * the elements and reverse the list when all elements have been added. + * </para></note> + * + * |[ + * /* Notice that these are initialized to the empty list. */ + * mw_slist_t *list = NULL, *number_list = NULL; + * + * /* This is a list of strings. */ + * list = mw_slist_append (list, "first"); + * list = mw_slist_append (list, "second"); + * + * /* This is a list of integers. */ + * number_list = mw_slist_append (number_list, INT_TO_POINTER (27)); + * number_list = mw_slist_append (number_list, INT_TO_POINTER (14)); + * ]| + * + * Returns: the new start of the #mw_slist_t + */ +mw_slist_t* +mw_slist_append (mw_slist_t *list, + mw_pointer_t data) +{ + mw_slist_t *new_list; + mw_slist_t *last; + + new_list = _mw_slist_alloc (); + new_list->data = data; + new_list->next = NULL; + + if (list) + { + last = mw_slist_last (list); + /* g_assert (last != NULL); */ + last->next = new_list; + + return list; + } + else + return new_list; +} + +/** + * mw_slist_prepend: + * @list: a #mw_slist_t + * @data: the data for the new element + * + * Adds a new element on to the start of the list. + * + * <note><para> + * The return value is the new start of the list, which + * may have changed, so make sure you store the new value. + * </para></note> + * + * |[ + * /* Notice that it is initialized to the empty list. */ + * mw_slist_t *list = NULL; + * list = mw_slist_prepend (list, "last"); + * list = mw_slist_prepend (list, "first"); + * ]| + * + * Returns: the new start of the #mw_slist_t + */ +mw_slist_t* +mw_slist_prepend (mw_slist_t *list, + mw_pointer_t data) +{ + mw_slist_t *new_list; + + new_list = _mw_slist_alloc (); + new_list->data = data; + new_list->next = list; + + return new_list; +} + +/** + * mw_slist_insert: + * @list: a #mw_slist_t + * @data: the data for the new element + * @position: the position to insert the element. + * If this is negative, or is larger than the number + * of elements in the list, the new element is added on + * to the end of the list. + * + * Inserts a new element into the list at the given position. + * + * Returns: the new start of the #mw_slist_t + */ +mw_slist_t* +mw_slist_insert (mw_slist_t *list, + mw_pointer_t data, + int position) +{ + mw_slist_t *prev_list; + mw_slist_t *tmp_list; + mw_slist_t *new_list; + + if (position < 0) + return mw_slist_append (list, data); + else if (position == 0) + return mw_slist_prepend (list, data); + + new_list = _mw_slist_alloc (); + new_list->data = data; + + if (!list) + { + new_list->next = NULL; + return new_list; + } + + prev_list = NULL; + tmp_list = list; + + while ((position-- > 0) && tmp_list) + { + prev_list = tmp_list; + tmp_list = tmp_list->next; + } + + if (prev_list) + { + new_list->next = prev_list->next; + prev_list->next = new_list; + } + else + { + new_list->next = list; + list = new_list; + } + + return list; +} + +/** + * mw_slist_insert_before: + * @slist: a #mw_slist_t + * @sibling: node to insert @data before + * @data: data to put in the newly-inserted node + * + * Inserts a node before @sibling containing @data. + * + * Returns: the new head of the list. + */ +mw_slist_t* +mw_slist_insert_before (mw_slist_t *slist, + mw_slist_t *sibling, + mw_pointer_t data) +{ + if (!slist) + { + slist = _mw_slist_alloc (); + slist->data = data; + slist->next = NULL; + return slist; + } + else + { + mw_slist_t *node, *last = NULL; + + for (node = slist; node; last = node, node = last->next) + if (node == sibling) + break; + if (!last) + { + node = _mw_slist_alloc (); + node->data = data; + node->next = slist; + + return node; + } + else + { + node = _mw_slist_alloc (); + node->data = data; + node->next = last->next; + last->next = node; + + return slist; + } + } +} + +/** + * mw_slist_concat: + * @list1: a #mw_slist_t + * @list2: the #mw_slist_t to add to the end of the first #mw_slist_t + * + * Adds the second #mw_slist_t onto the end of the first #mw_slist_t. + * Note that the elements of the second #mw_slist_t are not copied. + * They are used directly. + * + * Returns: the start of the new #mw_slist_t + */ +mw_slist_t * +mw_slist_concat (mw_slist_t *list1, mw_slist_t *list2) +{ + if (list2) + { + if (list1) + mw_slist_last (list1)->next = list2; + else + list1 = list2; + } + + return list1; +} + +/** + * mw_slist_remove: + * @list: a #mw_slist_t + * @data: the data of the element to remove + * + * Removes an element from a #mw_slist_t. + * If two elements contain the same data, only the first is removed. + * If none of the elements contain the data, the #mw_slist_t is unchanged. + * + * Returns: the new start of the #mw_slist_t + */ +mw_slist_t* +mw_slist_remove (mw_slist_t *list, + const mw_pointer_t data) +{ + mw_slist_t *tmp, *prev = NULL; + + tmp = list; + while (tmp) + { + if (tmp->data == data) + { + if (prev) + prev->next = tmp->next; + else + list = tmp->next; + + mw_slist_free_1 (tmp); + break; + } + prev = tmp; + tmp = prev->next; + } + + return list; +} + +/** + * mw_slist_remove_all: + * @list: a #mw_slist_t + * @data: data to remove + * + * Removes all list nodes with data equal to @data. + * Returns the new head of the list. Contrast with + * mw_slist_remove() which removes only the first node + * matching the given data. + * + * Returns: new head of @list + */ +mw_slist_t* +mw_slist_remove_all (mw_slist_t *list, + const mw_pointer_t data) +{ + mw_slist_t *tmp, *prev = NULL; + + tmp = list; + while (tmp) + { + if (tmp->data == data) + { + mw_slist_t *next = tmp->next; + + if (prev) + prev->next = next; + else + list = next; + + mw_slist_free_1 (tmp); + tmp = next; + } + else + { + prev = tmp; + tmp = prev->next; + } + } + + return list; +} + +static inline mw_slist_t* +_mw_slist_remove_link (mw_slist_t *list, + mw_slist_t *link) +{ + mw_slist_t *tmp; + mw_slist_t *prev; + + prev = NULL; + tmp = list; + + while (tmp) + { + if (tmp == link) + { + if (prev) + prev->next = tmp->next; + if (list == tmp) + list = list->next; + + tmp->next = NULL; + break; + } + + prev = tmp; + tmp = tmp->next; + } + + return list; +} + +/** + * mw_slist_remove_link: + * @list: a #mw_slist_t + * @link_: an element in the #mw_slist_t + * + * Removes an element from a #mw_slist_t, without + * freeing the element. The removed element's next + * link is set to %NULL, so that it becomes a + * self-contained list with one element. + * + * Returns: the new start of the #mw_slist_t, without the element + */ +mw_slist_t* +mw_slist_remove_link (mw_slist_t *list, + mw_slist_t *link_) +{ + return _mw_slist_remove_link (list, link_); +} + +/** + * mw_slist_delete_link: + * @list: a #mw_slist_t + * @link_: node to delete + * + * Removes the node link_ from the list and frees it. + * Compare this to mw_slist_remove_link() which removes the node + * without freeing it. + * + * Returns: the new head of @list + */ +mw_slist_t* +mw_slist_delete_link (mw_slist_t *list, + mw_slist_t *link_) +{ + list = _mw_slist_remove_link (list, link_); + _mw_slist_free1 (link_); + + return list; +} + +/** + * mw_slist_copy: + * @list: a #mw_slist_t + * + * Copies a #mw_slist_t. + * + * <note><para> + * Note that this is a "shallow" copy. If the list elements + * consist of pointers to data, the pointers are copied but + * the actual data isn't. + * </para></note> + * + * Returns: a copy of @list + */ +mw_slist_t* +mw_slist_copy (mw_slist_t *list) +{ + mw_slist_t *new_list = NULL; + + if (list) + { + mw_slist_t *last; + + new_list = _mw_slist_alloc (); + new_list->data = list->data; + last = new_list; + list = list->next; + while (list) + { + last->next = _mw_slist_alloc (); + last = last->next; + last->data = list->data; + list = list->next; + } + last->next = NULL; + } + + return new_list; +} + +/** + * mw_slist_reverse: + * @list: a #mw_slist_t + * + * Reverses a #mw_slist_t. + * + * Returns: the start of the reversed #mw_slist_t + */ +mw_slist_t* +mw_slist_reverse (mw_slist_t *list) +{ + mw_slist_t *prev = NULL; + + while (list) + { + mw_slist_t *next = list->next; + + list->next = prev; + + prev = list; + list = next; + } + + return prev; +} + +/** + * mw_slist_nth: + * @list: a #mw_slist_t + * @n: the position of the element, counting from 0 + * + * Gets the element at the given position in a #mw_slist_t. + * + * Returns: the element, or %NULL if the position is off + * the end of the #mw_slist_t + */ +mw_slist_t* +mw_slist_nth (mw_slist_t *list, + mw_uint_t n) +{ + while (n-- > 0 && list) + list = list->next; + + return list; +} + +/** + * mw_slist_nth_data: + * @list: a #mw_slist_t + * @n: the position of the element + * + * Gets the data of the element at the given position. + * + * Returns: the element's data, or %NULL if the position + * is off the end of the #mw_slist_t + */ +mw_pointer_t +mw_slist_nth_data (mw_slist_t *list, + mw_uint_t n) +{ + while (n-- > 0 && list) + list = list->next; + + return list ? list->data : NULL; +} + +/** + * mw_slist_find: + * @list: a #mw_slist_t + * @data: the element data to find + * + * Finds the element in a #mw_slist_t which + * contains the given data. + * + * Returns: the found #mw_slist_t element, + * or %NULL if it is not found + */ +mw_slist_t* +mw_slist_find (mw_slist_t *list, + const mw_pointer_t data) +{ + while (list) + { + if (list->data == data) + break; + list = list->next; + } + + return list; +} + + +/** + * mw_slist_find_custom: + * @list: a #mw_slist_t + * @data: user data passed to the function + * @func: the function to call for each element. + * It should return 0 when the desired element is found + * + * Finds an element in a #mw_slist_t, using a supplied function to + * find the desired element. It iterates over the list, calling + * the given function which should return 0 when the desired + * element is found. The function takes two #const mw_pointer_t arguments, + * the #mw_slist_t element's data as the first argument and the + * given user data. + * + * Returns: the found #mw_slist_t element, or %NULL if it is not found + */ +mw_slist_t* +mw_slist_find_custom (mw_slist_t *list, + const mw_pointer_t data, + mw_compare_func_t func) +{ + mw_assert(func != NULL); + + while (list) + { + if (! func (list->data, data)) + return list; + list = list->next; + } + + return NULL; +} + +/** + * mw_slist_position: + * @list: a #mw_slist_t + * @llink: an element in the #mw_slist_t + * + * Gets the position of the given element + * in the #mw_slist_t (starting from 0). + * + * Returns: the position of the element in the #mw_slist_t, + * or -1 if the element is not found + */ +int +mw_slist_position (mw_slist_t *list, + mw_slist_t *llink) +{ + int i; + + i = 0; + while (list) + { + if (list == llink) + return i; + i++; + list = list->next; + } + + return -1; +} + +/** + * mw_slist_index: + * @list: a #mw_slist_t + * @data: the data to find + * + * Gets the position of the element containing + * the given data (starting from 0). + * + * Returns: the index of the element containing the data, + * or -1 if the data is not found + */ +int +mw_slist_index (mw_slist_t *list, + const mw_pointer_t data) +{ + int i; + + i = 0; + while (list) + { + if (list->data == data) + return i; + i++; + list = list->next; + } + + return -1; +} + +/** + * mw_slist_last: + * @list: a #mw_slist_t + * + * Gets the last element in a #mw_slist_t. + * + * <note><para> + * This function iterates over the whole list. + * </para></note> + * + * Returns: the last element in the #mw_slist_t, + * or %NULL if the #mw_slist_t has no elements + */ +mw_slist_t* +mw_slist_last (mw_slist_t *list) +{ + if (list) + { + while (list->next) + list = list->next; + } + + return list; +} + +/** + * mw_slist_length: + * @list: a #mw_slist_t + * + * Gets the number of elements in a #mw_slist_t. + * + * <note><para> + * This function iterates over the whole list to + * count its elements. + * </para></note> + * + * Returns: the number of elements in the #mw_slist_t + */ +mw_uint_t +mw_slist_length (mw_slist_t *list) +{ + mw_uint_t length; + + length = 0; + while (list) + { + length++; + list = list->next; + } + + return length; +} + +/** + * mw_slist_foreach: + * @list: a #mw_slist_t + * @func: the function to call with each element's data + * @user_data: user data to pass to the function + * + * Calls a function for each element of a #mw_slist_t. + */ +void +mw_slist_foreach (mw_slist_t *list, + mw_func_t func, + mw_pointer_t user_data) +{ + while (list) + { + mw_slist_t *next = list->next; + (*func) (list->data, user_data); + list = next; + } +} + +static mw_slist_t* +mw_slist_insert_sorted_real (mw_slist_t *list, + mw_pointer_t data, + mw_func_t func, + mw_pointer_t user_data) +{ + mw_slist_t *tmp_list = list; + mw_slist_t *prev_list = NULL; + mw_slist_t *new_list; + int cmp; + + mw_assert (func != NULL); + + if (!list) + { + new_list = _mw_slist_alloc (); + new_list->data = data; + new_list->next = NULL; + return new_list; + } + + cmp = ((mw_compare_data_func_t) func) (data, tmp_list->data, user_data); + + while ((tmp_list->next) && (cmp > 0)) + { + prev_list = tmp_list; + tmp_list = tmp_list->next; + + cmp = ((mw_compare_data_func_t) func) (data, tmp_list->data, user_data); + } + + new_list = _mw_slist_alloc (); + new_list->data = data; + + if ((!tmp_list->next) && (cmp > 0)) + { + tmp_list->next = new_list; + new_list->next = NULL; + return list; + } + + if (prev_list) + { + prev_list->next = new_list; + new_list->next = tmp_list; + return list; + } + else + { + new_list->next = list; + return new_list; + } +} + +/** + * mw_slist_insert_sorted: + * @list: a #mw_slist_t + * @data: the data for the new element + * @func: the function to compare elements in the list. + * It should return a number > 0 if the first parameter + * comes after the second parameter in the sort order. + * + * Inserts a new element into the list, using the given + * comparison function to determine its position. + * + * Returns: the new start of the #mw_slist_t + */ +mw_slist_t* +mw_slist_insert_sorted (mw_slist_t *list, + mw_pointer_t data, + mw_compare_func_t func) +{ + return mw_slist_insert_sorted_real (list, data, (mw_func_t) func, NULL); +} + +/** + * mw_slist_insert_sorted_with_data: + * @list: a #mw_slist_t + * @data: the data for the new element + * @func: the function to compare elements in the list. + * It should return a number > 0 if the first parameter + * comes after the second parameter in the sort order. + * @user_data: data to pass to comparison function + * + * Inserts a new element into the list, using the given + * comparison function to determine its position. + * + * Returns: the new start of the #mw_slist_t + * + * Since: 2.10 + */ +mw_slist_t* +mw_slist_insert_sorted_with_data (mw_slist_t *list, + mw_pointer_t data, + mw_compare_data_func_t func, + mw_pointer_t user_data) +{ + return mw_slist_insert_sorted_real (list, data, (mw_func_t) func, user_data); +} + +static mw_slist_t * +mw_slist_sort_merge (mw_slist_t *l1, + mw_slist_t *l2, + mw_func_t compare_func, + mw_pointer_t user_data) +{ + mw_slist_t list, *l; + int cmp; + + l=&list; + + while (l1 && l2) + { + cmp = ((mw_compare_data_func_t) compare_func) (l1->data, l2->data, user_data); + + if (cmp <= 0) + { + l=l->next=l1; + l1=l1->next; + } + else + { + l=l->next=l2; + l2=l2->next; + } + } + l->next= l1 ? l1 : l2; + + return list.next; +} + +static mw_slist_t * +mw_slist_sort_real (mw_slist_t *list, + mw_func_t compare_func, + mw_pointer_t user_data) +{ + mw_slist_t *l1, *l2; + + if (!list) + return NULL; + if (!list->next) + return list; + + l1 = list; + l2 = list->next; + + while ((l2 = l2->next) != NULL) + { + if ((l2 = l2->next) == NULL) + break; + l1=l1->next; + } + l2 = l1->next; + l1->next = NULL; + + return mw_slist_sort_merge (mw_slist_sort_real (list, compare_func, user_data), + mw_slist_sort_real (l2, compare_func, user_data), + compare_func, + user_data); +} + +/** + * mw_slist_sort: + * @list: a #mw_slist_t + * @compare_func: the comparison function used to sort the #mw_slist_t. + * This function is passed the data from 2 elements of the #mw_slist_t + * and should return 0 if they are equal, a negative value if the + * first element comes before the second, or a positive value if + * the first element comes after the second. + * + * Sorts a #mw_slist_t using the given comparison function. + * + * Returns: the start of the sorted #mw_slist_t + */ +mw_slist_t * +mw_slist_sort (mw_slist_t *list, + mw_compare_func_t compare_func) +{ + return mw_slist_sort_real (list, (mw_func_t) compare_func, NULL); +} + +/** + * mw_slist_sort_with_data: + * @list: a #mw_slist_t + * @compare_func: comparison function + * @user_data: data to pass to comparison function + * + * Like mw_slist_sort(), but the sort function accepts a user data argument. + * + * Returns: new head of the list + */ +mw_slist_t * +mw_slist_sort_with_data (mw_slist_t *list, + mw_compare_data_func_t compare_func, + mw_pointer_t user_data) +{ + return mw_slist_sort_real (list, (mw_func_t) compare_func, user_data); +} diff --git a/milkway/mw-slist.h b/milkway/mw-slist.h new file mode 100644 index 0000000..3f10854 --- /dev/null +++ b/milkway/mw-slist.h @@ -0,0 +1,156 @@ +/* GLIB - Library of useful routines for C programming + * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/* + * Modified by the GLib Team and others 1997-2000. See the AUTHORS + * file for a list of people on the GLib Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GLib at ftp://ftp.gtk.org/pub/gtk/. + */ + +#ifndef __MW_SLIST_H__ +#define __MW_SLIST_H__ + +MW_BEGIN_DECLS + +typedef struct _mw_slist mw_slist_t; + +struct _mw_slist +{ + mw_pointer_t data; + mw_slist_t *next; +}; + +/* Singly linked lists + */ +mw_public mw_slist_t* +mw_slist_alloc (void); + +mw_public void +mw_slist_free (mw_slist_t *list); + +mw_public void +mw_slist_free_1 (mw_slist_t *list); + +#define mw_slist_free1 mw_slist_free_1 +mw_public mw_slist_t* +mw_slist_append (mw_slist_t *list, + mw_pointer_t data); + +mw_public mw_slist_t* +mw_slist_prepend (mw_slist_t *list, + mw_pointer_t data); + +mw_public mw_slist_t* +mw_slist_insert (mw_slist_t *list, + mw_pointer_t data, + int position); + +mw_public mw_slist_t* +mw_slist_insert_sorted (mw_slist_t *list, + mw_pointer_t data, + mw_compare_func_t func); + +mw_public mw_slist_t* +mw_slist_insert_sorted_with_data (mw_slist_t *list, + mw_pointer_t data, + mw_compare_data_func_t func, + mw_pointer_t user_data); + +mw_public mw_slist_t* +mw_slist_insert_before (mw_slist_t *slist, + mw_slist_t *sibling, + mw_pointer_t data); + +mw_public mw_slist_t* +mw_slist_concat (mw_slist_t *list1, + mw_slist_t *list2); + +mw_public mw_slist_t* +mw_slist_remove (mw_slist_t *list, + const mw_pointer_t data); + +mw_public mw_slist_t* +mw_slist_remove_all (mw_slist_t *list, + const mw_pointer_t data); + +mw_public mw_slist_t* +mw_slist_remove_link (mw_slist_t *list, + mw_slist_t *link_); + +mw_public mw_slist_t* +mw_slist_delete_link (mw_slist_t *list, + mw_slist_t *link_); + +mw_public mw_slist_t* +mw_slist_reverse (mw_slist_t *list); + +mw_public mw_slist_t* +mw_slist_copy (mw_slist_t *list); + +mw_public mw_slist_t* +mw_slist_nth (mw_slist_t *list, + mw_uint_t n); + +mw_public mw_slist_t* +mw_slist_find (mw_slist_t *list, + const mw_pointer_t data); + +mw_public mw_slist_t* +mw_slist_find_custom (mw_slist_t *list, + const mw_pointer_t data, + mw_compare_func_t func); + +mw_public int +mw_slist_position (mw_slist_t *list, + mw_slist_t *llink); + +mw_public int +mw_slist_index (mw_slist_t *list, + const mw_pointer_t data); + +mw_public mw_slist_t* +mw_slist_last (mw_slist_t *list); + +mw_public mw_uint_t +mw_slist_length (mw_slist_t *list); + +mw_public void +mw_slist_foreach (mw_slist_t *list, + mw_func_t func, + mw_pointer_t user_data); + +mw_public mw_slist_t* +mw_slist_sort (mw_slist_t *list, + mw_compare_func_t compare_func); + +mw_public mw_slist_t* +mw_slist_sort_with_data (mw_slist_t *list, + mw_compare_data_func_t compare_func, + mw_pointer_t user_data); + +mw_public mw_pointer_t +mw_slist_nth_data (mw_slist_t *list, + mw_uint_t n); + +#define mw_slist_next(slist) ((slist) ? (((mw_slist_t *)(slist))->next) : NULL) + +MW_END_DECLS + +#endif /* __MW_SLIST_H__ */ |