jslist.h

00001 /*
00002   Based on gslist.c from glib-1.2.9 (LGPL).
00003 
00004   Adaption to JACK, Copyright (C) 2002 Kai Vehmanen.
00005     - replaced use of gtypes with normal ANSI C types
00006     - glib's memory allocation routines replaced with
00007       malloc/free calls
00008 
00009   This program is free software; you can redistribute it and/or modify
00010   it under the terms of the GNU Lesser General Public License as published by
00011   the Free Software Foundation; either version 2.1 of the License, or
00012   (at your option) any later version.
00013   
00014   This program is distributed in the hope that it will be useful,
00015   but WITHOUT ANY WARRANTY; without even the implied warranty of
00016   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017   GNU Lesser General Public License for more details.
00018   
00019   You should have received a copy of the GNU Lesser General Public License
00020   along with this program; if not, write to the Free Software 
00021   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00022 
00023 */
00024 
00025 #ifndef __jack_jslist_h__
00026 #define __jack_jslist_h__
00027 
00028 #include <stdlib.h>
00029 
00030 #ifdef WIN32
00031 #define __inline__ inline
00032 #endif
00033 
00034 typedef struct _JSList JSList;
00035 
00036 typedef int     (*JCompareFunc) (void* a, void* b);
00037 struct _JSList
00038 {
00039     void *data;
00040     JSList *next;
00041 };
00042 
00043 static __inline__
00044 JSList*
00045 jack_slist_alloc (void)
00046 {
00047     JSList *new_list;
00048 
00049     new_list = (JSList*)malloc(sizeof(JSList));
00050     new_list->data = NULL;
00051     new_list->next = NULL;
00052 
00053     return new_list;
00054 }
00055 
00056 static __inline__
00057 JSList*
00058 jack_slist_prepend (JSList* list, void* data)
00059 {
00060     JSList *new_list;
00061 
00062     new_list = (JSList*)malloc(sizeof(JSList));
00063     new_list->data = data;
00064     new_list->next = list;
00065 
00066     return new_list;
00067 }
00068 
00069 #define jack_slist_next(slist)  ((slist) ? (((JSList *)(slist))->next) : NULL)
00070 static __inline__
00071 JSList*
00072 jack_slist_last (JSList *list)
00073 {
00074     if (list) {
00075         while (list->next)
00076             list = list->next;
00077     }
00078 
00079     return list;
00080 }
00081 
00082 static __inline__
00083 JSList*
00084 jack_slist_remove_link (JSList *list,
00085                         JSList *link)
00086 {
00087     JSList *tmp;
00088     JSList *prev;
00089 
00090     prev = NULL;
00091     tmp = list;
00092 
00093     while (tmp) {
00094         if (tmp == link) {
00095             if (prev)
00096                 prev->next = tmp->next;
00097             if (list == tmp)
00098                 list = list->next;
00099 
00100             tmp->next = NULL;
00101             break;
00102         }
00103 
00104         prev = tmp;
00105         tmp = tmp->next;
00106     }
00107 
00108     return list;
00109 }
00110 
00111 static __inline__
00112 void
00113 jack_slist_free (JSList *list)
00114 {
00115     while (list) {
00116         JSList *next = list->next;
00117         free(list);
00118         list = next;
00119     }
00120 }
00121 
00122 static __inline__
00123 void
00124 jack_slist_free_1 (JSList *list)
00125 {
00126     if (list) {
00127         free(list);
00128     }
00129 }
00130 
00131 static __inline__
00132 JSList*
00133 jack_slist_remove (JSList *list,
00134                    void *data)
00135 {
00136     JSList *tmp;
00137     JSList *prev;
00138 
00139     prev = NULL;
00140     tmp = list;
00141 
00142     while (tmp) {
00143         if (tmp->data == data) {
00144             if (prev)
00145                 prev->next = tmp->next;
00146             if (list == tmp)
00147                 list = list->next;
00148 
00149             tmp->next = NULL;
00150             jack_slist_free (tmp);
00151 
00152             break;
00153         }
00154 
00155         prev = tmp;
00156         tmp = tmp->next;
00157     }
00158 
00159     return list;
00160 }
00161 
00162 static __inline__
00163 unsigned int
00164 jack_slist_length (JSList *list)
00165 {
00166     unsigned int length;
00167 
00168     length = 0;
00169     while (list) {
00170         length++;
00171         list = list->next;
00172     }
00173 
00174     return length;
00175 }
00176 
00177 static __inline__
00178 JSList*
00179 jack_slist_find (JSList *list,
00180                  void *data)
00181 {
00182     while (list) {
00183         if (list->data == data)
00184             break;
00185         list = list->next;
00186     }
00187 
00188     return list;
00189 }
00190 
00191 static __inline__
00192 JSList*
00193 jack_slist_copy (JSList *list)
00194 {
00195     JSList *new_list = NULL;
00196 
00197     if (list) {
00198         JSList *last;
00199 
00200         new_list = jack_slist_alloc ();
00201         new_list->data = list->data;
00202         last = new_list;
00203         list = list->next;
00204         while (list) {
00205             last->next = jack_slist_alloc ();
00206             last = last->next;
00207             last->data = list->data;
00208             list = list->next;
00209         }
00210     }
00211 
00212     return new_list;
00213 }
00214 
00215 static __inline__
00216 JSList*
00217 jack_slist_append (JSList *list,
00218                    void *data)
00219 {
00220     JSList *new_list;
00221     JSList *last;
00222 
00223     new_list = jack_slist_alloc ();
00224     new_list->data = data;
00225 
00226     if (list) {
00227         last = jack_slist_last (list);
00228         last->next = new_list;
00229 
00230         return list;
00231     } else
00232         return new_list;
00233 }
00234 
00235 static __inline__
00236 JSList*
00237 jack_slist_sort_merge (JSList *l1,
00238                        JSList *l2,
00239                        JCompareFunc compare_func)
00240 {
00241     JSList list, *l;
00242 
00243     l = &list;
00244 
00245     while (l1 && l2) {
00246         if (compare_func(l1->data, l2->data) < 0) {
00247             l = l->next = l1;
00248             l1 = l1->next;
00249         } else {
00250             l = l->next = l2;
00251             l2 = l2->next;
00252         }
00253     }
00254     l->next = l1 ? l1 : l2;
00255 
00256     return list.next;
00257 }
00258 
00259 static __inline__
00260 JSList*
00261 jack_slist_sort (JSList *list,
00262                  JCompareFunc compare_func)
00263 {
00264     JSList *l1, *l2;
00265 
00266     if (!list)
00267         return NULL;
00268     if (!list->next)
00269         return list;
00270 
00271     l1 = list;
00272     l2 = list->next;
00273 
00274     while ((l2 = l2->next) != NULL) {
00275         if ((l2 = l2->next) == NULL)
00276             break;
00277         l1 = l1->next;
00278     }
00279     l2 = l1->next;
00280     l1->next = NULL;
00281 
00282     return jack_slist_sort_merge (jack_slist_sort (list, compare_func),
00283                                   jack_slist_sort (l2, compare_func),
00284                                   compare_func);
00285 }
00286 
00287 #endif /* __jack_jslist_h__ */

Generated on Thu Feb 14 11:16:02 2008 for Jackdmp by  doxygen 1.5.1