gclib2/modules/Core/dlist.cxx

   1 /*
   2  * (c) Oleg Puchinin 2006
   3  * graycardinalster@gmail.com
   4  *
   5  */
   6
   7 /* 2006-05-25 */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <Macroses.h>
  13 #include <dlist.h>
  14
  15 DList::~DList ()
  16 {
  17         __dlist_entry_t * one;
  18         __dlist_entry_t * d_del;
  19         if (! head || dont_free)
  20                 return;
  21
  22         one = head;
  23         while (one) {
  24                 d_del = one;
  25                 one = one->next;
  26                 free (d_del);
  27         }
  28         head = NULL;
  29         tail = NULL;
  30 }
  31
  32 char * DList::init (__dlist_entry_t * one)
  33 {
  34         head = one;
  35         tail = one;
  36         return one->data;
  37 }
  38
  39 char * DList::add_head (char * one)
  40 {
  41         __dlist_entry_t *entry;
  42
  43         if (head == NULL)
  44                 return init (one);
  45
  46         entry = new_one (one);
  47         head->prev = entry;
  48         entry->next = head;
  49         head = entry;
  50
  51         return one;
  52 }
  53
  54 char * DList::add_tail (char * one)
  55 {
  56         __dlist_entry_t * entry;
  57         if (tail == NULL)
  58                 return init (one);
  59
  60         entry = new_one (one);
  61         tail->next = entry;
  62         entry->prev = tail;
  63         tail = entry;
  64
  65         return one;
  66 }
  67
  68 void DList::rm (__dlist_entry_t * one)
  69 {
  70         if (! one)
  71                 return;
  72
  73         --ecount;
  74         if (one == tail && one == head) {
  75                 free (one);
  76                 head = NULL;
  77                 tail = NULL;
  78                 return;
  79         }
  80
  81         if (one == head) {
  82                 head = one->next;
  83                 head->prev = NULL;
  84                 free (one);
  85                 return;
  86         }
  87
  88         if (one == tail) {
  89                 tail = one->prev;
  90                 tail->next = NULL;
  91                 free (one);
  92                 return;
  93         }
  94
  95         one->prev->next = one->next;
  96         one->next->prev = one->prev;
  97         free (one);
  98 }
  99
 100 void DList::detach (__dlist_entry_t * one)
 101 {
 102         if (! one)
 103                 return;
 104
 105         if (one == tail && one == head) {
 106                 head = NULL;
 107                 tail = NULL;
 108                 return;
 109         }
 110
 111         if (one == head) {
 112                 head = one->next;
 113                 head->prev = NULL;
 114                 return;
 115         }
 116
 117         if (one == tail) {
 118                 tail = one->prev;
 119                 tail->next = NULL;
 120                 return;
 121         }
 122
 123         one->prev->next = one->next;
 124         one->next->prev = one->prev;
 125 }
 126
 127
 128 char * DList::add_after (__dlist_entry_t *two, char * one)
 129 {
 130         __dlist_entry_t * entry;
 131
 132         if (! two || ! one)
 133                 return NULL;
 134
 135         if (two == tail)
 136                 return add_tail (one);
 137
 138         entry = new_one (one);
 139         if (two->next) {
 140                 entry->prev = two;
 141                 entry->next = two->next;
 142                 two->next->prev = entry;
 143                 two->next = entry;
 144         } else
 145                 return NULL;
 146
 147         return one;
 148 }
 149
 150 char * DList::add_before (__dlist_entry_t *two, char * one)
 151 {
 152         __dlist_entry_t * entry;
 153
 154         if (! two || ! one)
 155                 return NULL;
 156
 157         if (two == head)
 158                 return add_head (one);
 159
 160         entry = new_one (one);
 161         if (two->prev) {
 162                 entry->next = two;
 163                 entry->prev = two->prev;
 164                 two->prev->next = entry;
 165                 two->prev = entry;
 166         } else
 167                 return NULL;
 168
 169         return one;
 170 }
 171
 172 void DList::foreach (Dfunc_t f)
 173 {
 174         __dlist_entry_t * entry;
 175         entry = head;
 176         while (entry) {
 177                 f((void *) entry->data);
 178                 entry = entry->next;
 179         }
 180 }
 181
 182 char * DList::add_entry_head (__dlist_entry_t * one)
 183 {
 184         if (head == NULL)
 185                 return init (one);
 186         head->prev = one;
 187         one->next = head;
 188         one->prev = NULL;
 189         head = one;
 190         return one->data;
 191 }
 192
 193 char * DList::add_entry_tail (__dlist_entry_t * one)
 194 {
 195         if (tail == NULL)
 196                 return init (one);
 197         tail->next = one;
 198         one->prev = tail;
 199         one->next = NULL;
 200         tail = one;
 201         return one->data;
 202 }
 203
 204 __dlist_entry_t * DList::get_entry_at (int N)
 205 {
 206         __dlist_entry_t * one;
 207         one = get_head ();
 208         if (! one || ! N)
 209                 return NULL;
 210         while ((one = one->next) && one && --N);
 211         return NULL;
 212 }
 213
 214 char * DList::get_at (int N)
 215 {
 216         __dlist_entry_t * one;
 217         one = get_entry_at (N);
 218         if (! one)
 219                 return NULL;
 220         else
 221                 return one->data;
 222 }
 223