list.c

   1 /**
   2  *
   3  * cpulimit - a cpu limiter for Linux
   4  *
   5  * Copyright (C) 2005-2008, by:  Angelo Marletta <marlonx80@hotmail.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  *
  21  **********************************************************************
  22  *
  23  * Dynamic list implementation
  24  *
  25  */
  26
  27 #include "list.h"
  28
  29 #define EMPTYLIST NULL
  30
  31 void init_list(struct list *l,int keysize) {
  32     l->first=l->last=NULL;
  33     l->keysize=keysize;
  34     l->count=0;
  35 }
  36
  37 struct list_node *add_elem(struct list *l,void *elem) {
  38     struct list_node *newnode=malloc(sizeof(struct list_node));
  39     newnode->data=elem;
  40     newnode->previous=l->last;
  41     newnode->next=NULL;
  42     if (l->count==0) {
  43         l->first=l->last=newnode;
  44     }
  45     else {
  46         l->last->next=newnode;
  47         l->last=newnode;
  48     }
  49     l->count++;
  50     return newnode;
  51 }
  52
  53 void delete_node(struct list *l,struct list_node *node) {
  54     if (l->count==1) l->first=l->last=NULL;
  55     else
  56         if (node==l->first) {
  57         node->next->previous=NULL;
  58         l->first=node->next;
  59     }
  60     else
  61         if (node==l->last) {
  62             node->previous->next=NULL;
  63             l->last=node->previous;
  64         }
  65         else {
  66             node->previous->next=node->next;
  67             node->next->previous=node->previous;
  68         }
  69     l->count--;
  70     free(node);
  71 }
  72
  73 void destroy_node(struct list *l,struct list_node *node) {
  74     free(node->data);
  75     node->data=NULL;
  76     delete_node(l,node);
  77 }
  78
  79 int is_EMPTYLIST_list(struct list *l) {
  80     return (l->count==0?TRUE:FALSE);
  81 }
  82
  83 int get_list_count(struct list *l) {
  84     return l->count;
  85 }
  86
  87 void *first_elem(struct list *l) {
  88     return l->first->data;
  89 }
  90
  91 struct list_node *first_node(struct list *l) {
  92     return l->first;
  93 }
  94
  95 void *last_elem(struct list *l) {
  96     return l->last->data;
  97 }
  98
  99 struct list_node *last_node(struct list *l) {
 100     return l->last;
 101 }
 102
 103 struct list_node *xlocate_node(struct list *l,void *elem,int offset,int length) {
 104     struct list_node *tmp;
 105     tmp=l->first;
 106     while(tmp!=NULL) {
 107         if(!memcmp(tmp->data+offset,elem,length==0?l->keysize:length)) return (tmp);
 108         tmp=tmp->next;
 109     }
 110     return EMPTYLIST;
 111 }
 112
 113 struct list_node *locate_node(struct list *l,void *elem) {
 114     return(xlocate_node(l,elem,0,0));
 115 }
 116
 117 void *xlocate_elem(struct list *l,void *elem,int offset,int length) {
 118     struct list_node *node=xlocate_node(l,elem,offset,length);
 119     return(node==NULL?NULL:node->data);
 120 }
 121
 122 void *locate_elem(struct list *l,void *elem) {
 123     return(xlocate_elem(l,elem,0,0));
 124 }
 125
 126 void flush_list(struct list *l) {
 127     struct list_node *tmp;
 128     while(l->first!=EMPTYLIST) {
 129         tmp=l->first;
 130         l->first=l->first->next;
 131         free(tmp);
 132         tmp=NULL;
 133     }
 134     l->last=EMPTYLIST;
 135     l->count=0;
 136 }
 137
 138 void destroy_list(struct list *l) {
 139     struct list_node *tmp;
 140     while(l->first!=EMPTYLIST) {
 141         tmp=l->first;
 142         l->first=l->first->next;
 143         free(tmp->data);
 144         tmp->data=NULL;
 145         free(tmp);
 146         tmp=NULL;
 147     }
 148     l->last=EMPTYLIST;
 149     l->count=0;
 150 }