apps/plugins/mpegplayer/mpeg_linkedlist.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Linked list API definitions
  11  *
  12  * Copyright (c) 2007 Michael Sevakis
  13  *
  14  * All files in this archive are subject to the GNU General Public License.
  15  * See the file COPYING in the source tree root for full license agreement.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "plugin.h"
  22 #include "mpegplayer.h"
  23 #include "mpeg_linkedlist.h"
  24
  25 /* Initialize a master list head */
  26 void list_initialize(struct list_item *master_list_head)
  27 {
  28     master_list_head->prev = master_list_head->next = NULL;
  29 }
  30
  31 /* Are there items after the head item? */
  32 bool list_is_empty(struct list_item *head_item)
  33 {
  34     return head_item->next == NULL;
  35 }
  36
  37 /* Does the item belong to a list? */
  38 bool list_is_item_listed(struct list_item *item)
  39 {
  40     return item->prev != NULL;
  41 }
  42
  43 /* Is the item a member in a particular list? */
  44 bool list_is_member(struct list_item *master_list_head,
  45                     struct list_item *item)
  46 {
  47     if (item != master_list_head && item->prev != NULL)
  48     {
  49         struct list_item *curr = master_list_head->next;
  50
  51         while (curr != NULL)
  52         {
  53             if (item != curr)
  54             {
  55                 curr = curr->next;
  56                 continue;
  57             }
  58
  59             return true;
  60         }
  61     }
  62
  63     return false;
  64 }
  65
  66 /* Remove an item from a list - no head item needed */
  67 void list_remove_item(struct list_item *item)
  68 {
  69     if (item->prev == NULL)
  70     {
  71         /* Not in a list - no change - could be the master list head
  72          * as well which cannot be removed */
  73         return;
  74     }
  75
  76     item->prev->next = item->next;
  77
  78     if (item->next != NULL)
  79     {
  80         /* Not last item */
  81         item->next->prev = item->prev;
  82     }
  83
  84     /* Mark as not in a list */
  85     item->prev = NULL;
  86 }
  87
  88 /* Add a list item after the base item */
  89 void list_add_item(struct list_item *head_item,
  90                    struct list_item *item)
  91 {
  92     if (item->prev != NULL)
  93     {
  94         /* Already in a list - no change */
  95         DEBUGF("list_add_item: item already in a list\n");
  96         return;
  97     }
  98
  99     if (item == head_item)
 100     {
 101         /* Cannot add the item to itself */
 102         DEBUGF("list_add_item: item == head_item\n");
 103         return;
 104     }
 105
 106     /* Insert first */
 107     item->prev = head_item;
 108     item->next = head_item->next;
 109
 110     if (head_item->next != NULL)
 111     {
 112         /* Not first item */
 113         head_item->next->prev = item;
 114     }
 115
 116     head_item->next = item;
 117 }
 118
 119 /* Clear list items after the head item */
 120 void list_clear_all(struct list_item *head_item)
 121 {
 122     struct list_item *curr = head_item->next;
 123
 124     while (curr != NULL)
 125     {
 126         list_remove_item(curr);
 127         curr = head_item->next;
 128     }
 129 }
 130
 131 /* Enumerate all items after the head item - passing each item in turn
 132  * to the callback as well as the data value. The current item may be
 133  * safely removed. Items added after the current position will be enumated
 134  * but not ones added before it. The callback may return false to stop
 135  * the enumeration. */
 136 void list_enum_items(struct list_item *head_item,
 137                      list_enum_callback_t callback,
 138                      intptr_t data)
 139 {
 140     struct list_item *next = head_item->next;
 141
 142     while (next != NULL)
 143     {
 144         struct list_item *curr = next;
 145         next = curr->next;
 146         if (!callback(curr, data))
 147             break;
 148     }
 149 }