src/axl/axl_factory.c

   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  *         C/ Dr. Michavila Nº 14
  32  *         Coslada 28820 Madrid
  33  *         Spain
  34  *
  35  *      Email address:
  36  *         info@aspl.es - http://fact.aspl.es
  37  */
  38 #include <axl.h>
  39
  40 typedef struct _axlItemBlock axlItemBlock;
  41
  42 struct _axlItemBlock {
  43         axlPointer      items;
  44         axlItemBlock  * next;
  45 };
  46
  47 struct _axlFactory {
  48         int       count;
  49         int       step;
  50         int       type_size;
  51         axlItemBlock * block;
  52 };
  53
  54 /**
  55  * @internal Allows to create a new factory, for the provided
  56  * type.
  57  *
  58  * This will cause the function to return an axlFactory with blocks
  59  * initialized.
  60  *
  61  * @param type The type to initialize the factory created.
  62  *
  63  * @return A newly allocated factory.
  64  */
  65 axlFactory * axl_factory_create (int size_of_type)
  66 {
  67         axlFactory * result;
  68
  69         result            = axl_new (axlFactory, 1);
  70         result->type_size = size_of_type;
  71         result->step      = 256 / size_of_type;
  72
  73         result->block        = axl_new (axlItemBlock, 1);
  74         result->block->items = calloc (result->step, size_of_type);
  75
  76         return result;
  77
  78 } /* end axl_factory_create */
  79
  80 /**
  81  * @internal Function that allows to get a block from the factory.
  82  *
  83  * @param factory The factory that is being used to allocate more
  84  * memory.
  85  *
  86  * @return A reference to newly allocated memory.
  87  */
  88 axlPointer   axl_factory_get (axlFactory * factory)
  89 {
  90         axlItemBlock * block;
  91
  92         /* update factory allocated elements */
  93         factory->count++;
  94
  95         if ((factory->count) > factory->step) {
  96
  97                 if (factory->step == (256 / factory->type_size))
  98                         factory->step = 512 / factory->type_size;
  99                 else if (factory->step == (512 / factory->type_size))
 100                         factory->step = 1024 / factory->type_size;
 101                 else if (factory->step == (1024 / factory->type_size))
 102                         factory->step = 2048 / factory->type_size;
 103
 104                 block          = axl_new (axlItemBlock, 1);
 105                 block->items   = calloc (factory->step, factory->type_size);
 106                 factory->count = 1;
 107
 108                 block->next    = factory->block;
 109                 factory->block = block;
 110
 111         } /* end if */
 112
 113         return ((char *)factory->block->items) + ((factory->count - 1) * factory->type_size);
 114 } /* end if */
 115
 116 /**
 117  * @internal Allows to deallocate the axlFactory created.
 118  *
 119  * @param factory
 120  */
 121 void         axl_factory_free (axlFactory * factory)
 122 {
 123         axlItemBlock * block;
 124         axlItemBlock * aux;
 125
 126         /* do nothing if null received */
 127         if (factory == NULL)
 128                 return;
 129
 130         /* get the first block */
 131         block = factory->block;
 132
 133         while (block != NULL) {
 134
 135                 /* get a reference to the next */
 136                 aux = block->next;
 137
 138                 /* free items and the block */
 139                 axl_free (block->items);
 140                 axl_free (block);
 141
 142                 /* get the next */
 143                 block = aux;
 144
 145         } /* end while */
 146
 147         axl_free (factory);
 148
 149         return;
 150 }
 151
 152 typedef struct _axlStrBlock axlStrBlock;
 153
 154 struct _axlStrBlock {
 155         char        * buffer;
 156         axlStrBlock * next;
 157 };
 158
 159 struct _axlStrFactory {
 160         int           index;
 161         int           step;
 162         int           size;
 163         axlStrBlock * block;
 164 };
 165
 166 /**
 167  * @internal Allows to create an string factory, an abstraction that
 168  * allows to allocate string chuncks in a memory efficient way,
 169  * according to the Axl Library allocation pattern.
 170  *
 171  * @return A reference to the newly allocated axlStrFactory.
 172  */
 173 axlStrFactory * axl_string_factory_create ()
 174 {
 175         axlStrFactory * factory;
 176
 177         /* create a factory */
 178         factory                = axl_new (axlStrFactory, 1);
 179         factory->step          = 1024;
 180         factory->size          = 1024;
 181         factory->block         = axl_new (axlStrBlock, 1);
 182         factory->block->buffer = axl_new (char, factory->size);
 183
 184         /* return factory created */
 185         return factory;
 186 }
 187
 188 /**
 189  * @internal Allows to allocate a new chunk from the axlStrFactory.
 190  *
 191  * @param factory The factory that will be used to allocate an string.
 192  *
 193  * @param size The size to allocate. The amount of memory to allocate
 194  * to hold the string.
 195  *
 196  * @return A pointer to allocated memory to hold the exact amount of
 197  * memory requested.
 198  */
 199 char          * axl_string_factory_alloc  (axlStrFactory * factory, int size)
 200 {
 201         axlStrBlock * block;
 202         char        * result;
 203
 204         /* check that we could satisfy the size request with current
 205          * block */
 206         if ((factory->size - factory->index - 1) < size ) {
 207
 208                 /* alloc a new block */
 209                 block = axl_new (axlStrBlock, 1);
 210
 211                 /* ensure the block can hold the string */
 212                 if (size > factory->size) {
 213                         block->buffer = axl_new (char, size + 1);
 214                         factory->size = size + 1;
 215                 } else {
 216                         /* store step allocation */
 217                         factory->size = factory->step;
 218                         block->buffer = axl_new (char, factory->size + 1);
 219                 }
 220
 221                 /* configure the new block */
 222                 block->next    = factory->block;
 223                 factory->block = block;
 224                 factory->index = 0;
 225         } /* end if */
 226
 227         /* get current index available */
 228         result = factory->block->buffer + factory->index;
 229
 230         /* nullify to normalize string */
 231         result [ size ] = 0;
 232
 233         /* reserve size bytes */
 234         factory->index += size + 1;
 235
 236         return result;
 237 }
 238
 239 /**
 240  * @internal Deallocs the axl stream factory and all chunks allocated.
 241  *
 242  * @param factory The factory to dealloc.
 243  */
 244 void            axl_string_factory_free   (axlStrFactory * factory)
 245 {
 246         axlStrBlock * block;
 247         axlStrBlock * aux;
 248
 249         /* do nothing if null received */
 250         if (factory == NULL)
 251                 return;
 252
 253         /* get the first block */
 254         block = factory->block;
 255
 256         while (block != NULL) {
 257
 258                 /* get a reference to the next */
 259                 aux = block->next;
 260
 261                 /* free items and the block */
 262                 axl_free (block->buffer);
 263                 axl_free (block);
 264
 265                 /* get the next */
 266                 block = aux;
 267
 268         } /* end while */
 269
 270         axl_free (factory);
 271
 272         return;
 273 }
 274
 275