- Return HARDEOF status from bnet_recv() if bsock NULL rather

[bacula/bacula] / bacula / src / lib / alist.c

diff --git a/bacula/src/lib/alist.c b/bacula/src/lib/alist.c
index e5eafaf93384b43ca7b20b909f50d1a74ed6741b..bf12f3439b114eac3f6659ffcc37c419f08aa51d 100644 (file)
--- a/bacula/src/lib/alist.c
+++ b/bacula/src/lib/alist.c
@@ -1,9 +1,9 @@
 /*
- *  Bacula array list routines    
+ *  Bacula array list routines
  *
  *    alist is a simple malloc'ed array of pointers.  For the moment,
- *      it simply malloc's a bigger array controlled by num_grow.         
- *     Default is to realloc the pointer array for each new member.
+ *      it simply malloc's a bigger array controlled by num_grow.
+ *      Default is to realloc the pointer array for each new member.
  *
  *   Kern Sibbald, June MMIII
  *
@@ -11,34 +11,31 @@
  *
  */
 /*
-   Copyright (C) 2000-2003 Kern Sibbald and John Walker
+   Copyright (C) 2003-2005 Kern Sibbald
 
    This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2 of
-   the License, or (at your option) any later version.
+   modify it under the terms of the GNU General Public License
+   version 2 as amended with additional clauses defined in the
+   file LICENSE in the main source directory.
 
    This program 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
-   General Public License for more details.
-
-   You should have received a copy of the GNU General Public
-   License along with this program; if not, write to the Free
-   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
-   MA 02111-1307, USA.
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
+   the file LICENSE for additional details.
 
  */
 
 #include "bacula.h"
 
 /*
- * Append an item to the list
+ * Private grow list function. Used to insure that
+ *   at least one more "slot" is available.
  */
-void alist::append(void *item) {
+void alist::grow_list()
+{
    if (num_items == 0) {
       if (num_grow == 0) {
-        num_grow = 1;                /* default if not initialized */
+         num_grow = 1;                /* default if not initialized */
       }
       items = (void **)malloc(num_grow * sizeof(void *));
       max_items = num_grow;
@@ -46,9 +43,87 @@ void alist::append(void *item) {
       max_items += num_grow;
       items = (void **)realloc(items, max_items * sizeof(void *));
    }
+}
+
+void *alist::first()
+{
+   cur_item = 1;
+   if (num_items == 0) {
+      return NULL;
+   } else {
+      return items[0];
+   }
+}
+
+void *alist::last()
+{
+   if (num_items == 0) {
+      return NULL;
+   } else {
+      cur_item = num_items;
+      return items[num_items-1];
+   }
+}
+
+void *alist::next()
+{
+   if (cur_item >= num_items) {
+      return NULL;
+   } else {
+      return items[cur_item++];
+   }
+}
+
+void *alist::prev()
+{
+   if (cur_item <= 1) {
+      return NULL;
+   } else {
+      return items[--cur_item];
+   }
+}
+
+/*
+ * prepend an item to the list -- i.e. add to beginning
+ */
+void alist::prepend(void *item) {
+   grow_list();
+   if (num_items == 0) {
+      items[num_items++] = item;
+      return;
+   }
+   for (int i=num_items; i > 0; i--) {
+      items[i] = items[i-1];
+   }
+   items[0] = item;
+   num_items++;
+}
+
+
+/*
+ * Append an item to the list
+ */
+void alist::append(void *item) {
+   grow_list();
    items[num_items++] = item;
 }
 
+/* Remove an item from the list */
+void * alist::remove(int index)
+{
+   void *item;
+   if (index < 0 || index >= num_items) {
+      return NULL;
+   }
+   item = items[index];
+   num_items--;
+   for (int i=index; i < num_items; i++) {
+      items[i] = items[i+1];
+   }
+   return item;
+}
+
+
 /* Get the index item -- we should probably allow real indexing here */
 void * alist::get(int index)
 {
@@ -62,10 +137,14 @@ void * alist::get(int index)
 void alist::destroy()
 {
    if (items) {
-      for (int i=0; i<num_items; i++) {
-        free(items[i]);
+      if (own_items) {
+         for (int i=0; i<num_items; i++) {
+            free(items[i]);
+            items[i] = NULL;
+         }
       }
       free(items);
+      items = NULL;
    }
 }
 
@@ -87,13 +166,13 @@ int main()
    fileset->mylist.init();
 
    printf("Manual allocation/destruction of list:\n");
-   
+
    for (int i=0; i<20; i++) {
       sprintf(buf, "This is item %d", i);
       fileset->mylist.append(bstrdup(buf));
-   } 
-   for (int i=0; i<fileset->mylist.size(); i++) {
-      printf("Item %d = %s\n", i, (char *)fileset->mylist[i]);  
+   }
+   for (int i=0; i< fileset->mylist.size(); i++) {
+      printf("Item %d = %s\n", i, (char *)fileset->mylist[i]);
    }
    fileset->mylist.destroy();
    free(fileset);
@@ -104,15 +183,15 @@ int main()
    for (int i=0; i<20; i++) {
       sprintf(buf, "This is item %d", i);
       mlist->append(bstrdup(buf));
-   } 
-   for (int i=0; i<mlist->size(); i++) {
-      printf("Item %d = %s\n", i, (char *)mlist->get(i));  
+   }
+   for (int i=0; i< mlist->size(); i++) {
+      printf("Item %d = %s\n", i, (char *)mlist->get(i));
    }
 
    delete mlist;
 
 
-   sm_dump(False);
+   sm_dump(false);
 
 }
 #endif