Annotation of embedaddon/quagga/lib/vector.c, revision 1.1
1.1 ! misho 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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to vector.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib