Annotation of gpl/axl/src/axl_factory.c, revision 1.1
1.1 ! misho 1: /*
! 2: * LibAxl: Another XML library
! 3: * Copyright (C) 2006 Advanced Software Production Line, S.L.
! 4: *
! 5: * This program is free software; you can redistribute it and/or
! 6: * modify it under the terms of the GNU Lesser General Public License
! 7: * as published by the Free Software Foundation; either version 2.1 of
! 8: * the License, or (at your option) any later version.
! 9: *
! 10: * This program is distributed in the hope that it will be useful,
! 11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 13: * GNU Lesser General Public License for more details.
! 14: *
! 15: * You should have received a copy of the GNU Lesser General Public
! 16: * License along with this program; if not, write to the Free
! 17: * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
! 18: * 02111-1307 USA
! 19: *
! 20: * You may find a copy of the license under this software is released
! 21: * at COPYING file. This is LGPL software: you are welcome to
! 22: * develop proprietary applications using this library without any
! 23: * royalty or fee but returning back any change, improvement or
! 24: * addition in the form of source code, project image, documentation
! 25: * patches, etc.
! 26: *
! 27: * For commercial support on build XML enabled solutions contact us:
! 28: *
! 29: * Postal address:
! 30: * Advanced Software Production Line, S.L.
! 31: * Edificio Alius A, Oficina 102,
! 32: * C/ Antonio Suarez Nº 10,
! 33: * Alcalá de Henares 28802 Madrid
! 34: * Spain
! 35: *
! 36: * Email address:
! 37: * info@aspl.es - http://www.aspl.es/xml
! 38: */
! 39: #include <axl.h>
! 40:
! 41: #define LOG_DOMAIN "axl-factory"
! 42:
! 43: typedef struct _axlItemBlock axlItemBlock;
! 44:
! 45: struct _axlItemBlock {
! 46: axlPointer items;
! 47: axlItemBlock * next;
! 48: };
! 49:
! 50: struct _axlFactory {
! 51: int count;
! 52: int step;
! 53: int type_size;
! 54:
! 55: int spare_max;
! 56: int spare_next;
! 57: axlPointer * spares;
! 58:
! 59: axlItemBlock * block;
! 60: };
! 61:
! 62: /**
! 63: * @internal Allows to create a new factory, for the provided
! 64: * type.
! 65: *
! 66: * This will cause the function to return an axlFactory with blocks
! 67: * initialized.
! 68: *
! 69: * @param type The type to initialize the factory created.
! 70: *
! 71: * @return A newly allocated factory.
! 72: */
! 73: axlFactory * axl_factory_create (int size_of_type)
! 74: {
! 75: axlFactory * result;
! 76:
! 77: result = axl_new (axlFactory, 1);
! 78: result->type_size = size_of_type;
! 79: result->step = 256 / size_of_type;
! 80:
! 81: /* create available block */
! 82: result->block = axl_new (axlItemBlock, 1);
! 83: result->block->items = axl_calloc (result->step, size_of_type);
! 84:
! 85: return result;
! 86:
! 87: } /* end axl_factory_create */
! 88:
! 89: /**
! 90: * @internal Function that allows to get a block from the factory.
! 91: *
! 92: * @param factory The factory that is being used to allocate more
! 93: * memory.
! 94: *
! 95: * @return A reference to newly allocated memory.
! 96: */
! 97: axlPointer axl_factory_get (axlFactory * factory)
! 98: {
! 99: axlItemBlock * block;
! 100: axlPointer result;
! 101:
! 102: /* check if we have spares available */
! 103: if (factory->spare_max > 0 && factory->spare_next >= 0) {
! 104: result = factory->spares[factory->spare_next];
! 105: factory->spare_next--;
! 106: return result;
! 107: } /* end if */
! 108:
! 109: /* update factory allocated elements */
! 110: factory->count++;
! 111:
! 112: if ((factory->count) > factory->step) {
! 113:
! 114: if (factory->step == (256 / factory->type_size))
! 115: factory->step = 512 / factory->type_size;
! 116: else if (factory->step == (512 / factory->type_size))
! 117: factory->step = 1024 / factory->type_size;
! 118: else if (factory->step == (1024 / factory->type_size))
! 119: factory->step = 2048 / factory->type_size;
! 120:
! 121: block = axl_new (axlItemBlock, 1);
! 122: block->items = axl_calloc (factory->step, factory->type_size);
! 123: factory->count = 1;
! 124:
! 125: block->next = factory->block;
! 126: factory->block = block;
! 127:
! 128: } /* end if */
! 129:
! 130: return ((char *)factory->block->items) + ((factory->count - 1) * factory->type_size);
! 131: } /* end if */
! 132:
! 133: void axl_factory_release_spare (axlFactory * factory, axlPointer node)
! 134: {
! 135: /* check if we have spare structure avaialble */
! 136: if (factory->spare_max == 0) {
! 137: /* basic case, where spares structure is not ready (no
! 138: * previous release done). We initialize and set
! 139: * maximum spare capacity to 1 and next spare pointer
! 140: * to retrieve on next axl_factory_get set to 0 */
! 141: factory->spares = axl_new (axlPointer, 10);
! 142: factory->spare_max = 9;
! 143: factory->spare_next = 0;
! 144: } else if (factory->spare_max > factory->spare_next) {
! 145: /* found that we have available spare pointer capacity
! 146: * and spare next is lower, so we don't need to
! 147: * allocate more memory to store current spares plus
! 148: * the gone being spared at this moment */
! 149: if (factory->spare_next == -1)
! 150: factory->spare_next = 0;
! 151: else {
! 152: factory->spare_next++;
! 153: } /* end if */
! 154: } else {
! 155: /* not enough to store spares, realloc and copy */
! 156: factory->spare_max += 10;
! 157: factory->spares = realloc (factory->spares, sizeof (axlPointer) * factory->spare_max);
! 158: factory->spare_max--;
! 159: factory->spare_next++;
! 160: }
! 161:
! 162: /* store node pointer */
! 163: factory->spares[factory->spare_next] = node;
! 164:
! 165: return;
! 166: }
! 167:
! 168: /**
! 169: * @brief Allows to get how many spare nodes can be stored (returned
! 170: * into the factory via axl_factory_release_spare).
! 171: *
! 172: * @param factory The factory where the spare value will be returned.
! 173: *
! 174: * @return The spare max or -1 if it fails.
! 175: */
! 176: int axl_factory_spare_max (axlFactory * factory)
! 177: {
! 178: if (factory == NULL)
! 179: return -1;
! 180: return factory->spare_max;
! 181: }
! 182:
! 183: /**
! 184: * @brief Allows to get how many spare nodes are stored (returned into
! 185: * the factory via axl_factory_release_spare). The value returned is
! 186: * the index to the next item to return, this means that having the
! 187: * index + 1 is the number of spares already stored.
! 188: *
! 189: * @param factory The factory where the next spare index value will be returned.
! 190: *
! 191: * @return The next spare index or -1 if it fails.
! 192: */
! 193: int axl_factory_spare_next (axlFactory * factory)
! 194: {
! 195: if (factory == NULL)
! 196: return -1;
! 197: return factory->spare_next;
! 198: }
! 199:
! 200: /**
! 201: * @internal Allows to deallocate the axlFactory created.
! 202: *
! 203: * @param factory
! 204: */
! 205: void axl_factory_free (axlFactory * factory)
! 206: {
! 207: axlItemBlock * block;
! 208: axlItemBlock * aux;
! 209:
! 210: /* do nothing if null received */
! 211: if (factory == NULL)
! 212: return;
! 213:
! 214: /* get the first block */
! 215: block = factory->block;
! 216: while (block != NULL) {
! 217:
! 218: /* get a reference to the next */
! 219: aux = block->next;
! 220:
! 221: /* free items and the block */
! 222: axl_free (block->items);
! 223: axl_free (block);
! 224:
! 225: /* get the next */
! 226: block = aux;
! 227:
! 228: } /* end while */
! 229:
! 230: axl_free (factory->spares);
! 231: axl_free (factory);
! 232:
! 233: return;
! 234: }
! 235:
! 236: typedef struct _axlStrBlock axlStrBlock;
! 237:
! 238: struct _axlStrBlock {
! 239: char * buffer;
! 240: axlStrBlock * next;
! 241: };
! 242:
! 243: struct _axlStrFactory {
! 244: int index;
! 245: int step;
! 246: int size;
! 247: axlStrBlock * block;
! 248: };
! 249:
! 250: /**
! 251: * @internal Allows to create an string factory, an abstraction that
! 252: * allows to allocate string chuncks in a memory efficient way,
! 253: * according to the Axl Library allocation pattern.
! 254: *
! 255: * @return A reference to the newly allocated axlStrFactory.
! 256: */
! 257: axlStrFactory * axl_string_factory_create (void)
! 258: {
! 259: axlStrFactory * factory;
! 260:
! 261: /* create a factory */
! 262: factory = axl_new (axlStrFactory, 1);
! 263: factory->step = 1024;
! 264: factory->size = 1024;
! 265: factory->block = axl_new (axlStrBlock, 1);
! 266: factory->block->buffer = axl_new (char, factory->size);
! 267:
! 268: /* return factory created */
! 269: return factory;
! 270: }
! 271:
! 272: /**
! 273: * @internal Allows to allocate a new chunk from the axlStrFactory.
! 274: *
! 275: * @param factory The factory that will be used to allocate an string.
! 276: *
! 277: * @param size The size to allocate. The amount of memory to allocate
! 278: * to hold the string.
! 279: *
! 280: * @return A pointer to allocated memory to hold the exact amount of
! 281: * memory requested.
! 282: */
! 283: char * axl_string_factory_alloc (axlStrFactory * factory, int size)
! 284: {
! 285: axlStrBlock * block;
! 286: char * result;
! 287:
! 288: /* check that we could satisfy the size request with current
! 289: * block */
! 290: if ((factory->size - factory->index - 1) < size ) {
! 291:
! 292: /* alloc a new block */
! 293: block = axl_new (axlStrBlock, 1);
! 294:
! 295: /* ensure the block can hold the string */
! 296: if (size > factory->size) {
! 297: block->buffer = axl_new (char, size + 1);
! 298: factory->size = size + 1;
! 299: } else {
! 300: /* store step allocation */
! 301: factory->size = factory->step;
! 302: block->buffer = axl_new (char, factory->size + 1);
! 303: }
! 304:
! 305: /* configure the new block */
! 306: block->next = factory->block;
! 307: factory->block = block;
! 308: factory->index = 0;
! 309: } /* end if */
! 310:
! 311: /* get current index available */
! 312: result = factory->block->buffer + factory->index;
! 313:
! 314: /* nullify to normalize string */
! 315: result [ size ] = 0;
! 316:
! 317: /* reserve size bytes */
! 318: factory->index += size + 1;
! 319:
! 320: return result;
! 321: }
! 322:
! 323: /**
! 324: * @internal Deallocs the axl stream factory and all chunks allocated.
! 325: *
! 326: * @param factory The factory to dealloc.
! 327: */
! 328: void axl_string_factory_free (axlStrFactory * factory)
! 329: {
! 330: axlStrBlock * block;
! 331: axlStrBlock * aux;
! 332:
! 333: /* do nothing if null received */
! 334: if (factory == NULL)
! 335: return;
! 336:
! 337: /* get the first block */
! 338: block = factory->block;
! 339:
! 340: while (block != NULL) {
! 341:
! 342: /* get a reference to the next */
! 343: aux = block->next;
! 344:
! 345: /* free items and the block */
! 346: axl_free (block->buffer);
! 347: axl_free (block);
! 348:
! 349: /* get the next */
! 350: block = aux;
! 351:
! 352: } /* end while */
! 353: axl_free (factory);
! 354:
! 355: return;
! 356: }
! 357:
! 358:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to axl_factory.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / gpl / axl / src