]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - lib/vector.c
New upstream version 1.2.4
[quagga-debian.git] / lib / vector.c
1 /* Generic vector interface routine
2  * Copyright (C) 1997 Kunihiro Ishiguro
3  *
4  * This file is part of GNU Zebra.
5  *
6  * GNU Zebra is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the
8  * Free Software Foundation; either version 2, or (at your option) any
9  * later version.
10  *
11  * GNU Zebra is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19  * 02111-1307, USA.  
20  */
21
22 #include <zebra.h>
23
24 #include "vector.h"
25 #include "memory.h"
26
27 /* Initialize vector : allocate memory and return vector. */
28 vector
29 vector_init (unsigned int size)
30 {
31   vector v = XCALLOC (MTYPE_VECTOR, sizeof (struct _vector));
32
33   /* allocate at least one slot */
34   if (size == 0)
35     size = 1;
36
37   v->alloced = size;
38   v->active = 0;
39   v->index = XCALLOC (MTYPE_VECTOR_INDEX, sizeof (void *) * size);
40   return v;
41 }
42
43 void
44 vector_only_wrapper_free (vector v)
45 {
46   XFREE (MTYPE_VECTOR, v);
47 }
48
49 void
50 vector_only_index_free (void *index)
51 {
52   XFREE (MTYPE_VECTOR_INDEX, index);
53 }
54
55 void
56 vector_free (vector v)
57 {
58   XFREE (MTYPE_VECTOR_INDEX, v->index);
59   XFREE (MTYPE_VECTOR, v);
60 }
61
62 vector
63 vector_copy (vector v)
64 {
65   unsigned int size;
66   vector new = XCALLOC (MTYPE_VECTOR, sizeof (struct _vector));
67
68   new->active = v->active;
69   new->alloced = v->alloced;
70
71   size = sizeof (void *) * (v->alloced);
72   new->index = XCALLOC (MTYPE_VECTOR_INDEX, size);
73   memcpy (new->index, v->index, size);
74
75   return new;
76 }
77
78 /* Check assigned index, and if it runs short double index pointer */
79 void
80 vector_ensure (vector v, unsigned int num)
81 {
82   if (v->alloced > num)
83     return;
84
85   v->index = XREALLOC (MTYPE_VECTOR_INDEX, 
86                        v->index, sizeof (void *) * (v->alloced * 2));
87   memset (&v->index[v->alloced], 0, sizeof (void *) * v->alloced);
88   v->alloced *= 2;
89   
90   if (v->alloced <= num)
91     vector_ensure (v, num);
92 }
93
94 /* This function only returns next empty slot index.  It dose not mean
95    the slot's index memory is assigned, please call vector_ensure()
96    after calling this function. */
97 int
98 vector_empty_slot (vector v)
99 {
100   unsigned int i;
101
102   if (v->active == 0)
103     return 0;
104
105   for (i = 0; i < v->active; i++)
106     if (v->index[i] == 0)
107       return i;
108
109   return i;
110 }
111
112 /* Set value to the smallest empty slot. */
113 int
114 vector_set (vector v, void *val)
115 {
116   unsigned int i;
117
118   i = vector_empty_slot (v);
119   vector_ensure (v, i);
120
121   v->index[i] = val;
122
123   if (v->active <= i)
124     v->active = i + 1;
125
126   return i;
127 }
128
129 /* Set value to specified index slot. */
130 int
131 vector_set_index (vector v, unsigned int i, void *val)
132 {
133   vector_ensure (v, i);
134
135   v->index[i] = val;
136
137   if (v->active <= i)
138     v->active = i + 1;
139
140   return i;
141 }
142
143 /* Look up vector.  */
144 void *
145 vector_lookup (vector v, unsigned int i)
146 {
147   if (i >= v->active)
148     return NULL;
149   return v->index[i];
150 }
151
152 /* Lookup vector, ensure it. */
153 void *
154 vector_lookup_ensure (vector v, unsigned int i)
155 {
156   vector_ensure (v, i);
157   return v->index[i];
158 }
159
160 /* Unset value at specified index slot. */
161 void
162 vector_unset (vector v, unsigned int i)
163 {
164   if (i >= v->alloced)
165     return;
166
167   v->index[i] = NULL;
168
169   if (i + 1 == v->active) 
170     {
171       v->active--;
172       while (i && v->index[--i] == NULL && v->active--) 
173         ;                               /* Is this ugly ? */
174     }
175 }
176
177 /* Count the number of not emplty slot. */
178 unsigned int
179 vector_count (vector v)
180 {
181   unsigned int i;
182   unsigned count = 0;
183
184   for (i = 0; i < v->active; i++) 
185     if (v->index[i] != NULL)
186       count++;
187
188   return count;
189 }