src/list.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * list.h: a non-sucky linked list implementation
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  */
  12
  13
  14 #ifndef __LIST_H__
  15 #define __LIST_H__
  16
  17 #include <pthread.h>
  18
  19
  20 class List {
  21 public:
  22         class Node {
  23         public:
  24                 Node *next;
  25                 Node *prev;
  26
  27                 // public
  28                 Node ();
  29                 virtual ~Node () { }
  30         };
  31
  32         typedef bool (* NodeAction) (Node *node, void *data);
  33
  34 protected:
  35         int length;
  36         Node *head;
  37         Node *tail;
  38
  39 public:
  40         // constructors
  41         List ();
  42         virtual ~List ();
  43
  44         // properties
  45         Node *First () { return head; }
  46         Node *Last ();
  47         bool IsEmpty ();
  48         int Length ();
  49
  50         // methods
  51         void Clear (bool freeNodes);
  52
  53         Node *Append (Node *node);
  54         Node *Prepend (Node *node);
  55         Node *Prepend (List *list);
  56         Node *Insert (Node *node, int index);
  57         Node *InsertAfter (Node *node, Node *after);
  58         Node *InsertBefore (Node *node, Node *before);
  59
  60         Node *Replace (Node *node, int index);
  61
  62         Node *Find (NodeAction find, void *data);
  63         void Remove (NodeAction find, void *data);
  64         void Remove (Node *node);
  65         void RemoveAt (int index);
  66         void Unlink (Node *node);
  67
  68         Node *Index (int index);
  69
  70         int IndexOf (Node *node);
  71         int IndexOf (NodeAction find, void *data);
  72
  73         void ForEach (NodeAction action, void *data);
  74 };
  75
  76 class Queue {
  77 protected:
  78         pthread_mutex_t lock;
  79         List *list;
  80
  81 public:
  82         Queue ();
  83         ~Queue ();
  84
  85         // convenience properties
  86         bool IsEmpty ();
  87         int Length ();
  88
  89         // convenience methods
  90         void Clear (bool freeNodes);
  91
  92         void Push (List::Node *node);
  93         List::Node *Pop ();
  94
  95         void Lock ();
  96         void Unlock ();
  97
  98         // accessing the internal linked list directly requires manual Locking/Unlocking.
  99         List *LinkedList ();
 100
 101         // copies the queue and empties the original
 102         void  MoveTo (Queue &queue);
 103 };
 104
 105 class ArrayList {
 106 private:
 107         void **array;
 108         int size; // size of array
 109         int count; // # of items in the array
 110
 111 public:
 112         ArrayList ();
 113         ~ArrayList ();
 114
 115         int GetCount () { return count; }
 116         void SetCount (int value);
 117
 118         int GetCapacity ();
 119         void SetCapacity (int value);
 120
 121         void EnsureCapacity (int capacity);
 122         int Add (void *item);
 123         void *& operator [] (int index) { return array [index]; }
 124 };
 125
 126 #endif /* __LIST_H__ */