WINGs/data.c

   1 /*
   2  *  WINGs WMData function library
   3  *
   4  *  Copyright (c) 1999 Dan Pascu
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21
  22
  23 #include <string.h>
  24 #include "WUtil.h"
  25
  26
  27 typedef struct W_Data {
  28     unsigned   length;      /* How many bytes we have */
  29     unsigned   capacity;    /* How many bytes it can hold */
  30     unsigned   growth;      /* How much to grow */
  31     void       *bytes;      /* Actual data */
  32     unsigned   retainCount;
  33     WMFreeDataProc *destructor;
  34     int        format;      /* 0, 8, 16 or 32 */
  35     unsigned   freeData:1;  /* whether the data should be released */
  36 } W_Data;
  37
  38
  39
  40
  41 /* Creating and destroying data objects */
  42
  43 WMData*
  44 WMCreateDataWithCapacity(unsigned capacity) /*FOLD00*/
  45 {
  46     WMData *aData;
  47
  48     aData = (WMData*)wmalloc(sizeof(WMData));
  49
  50     if (capacity>0)
  51         aData->bytes = wmalloc(capacity);
  52     else
  53         aData->bytes = NULL;
  54     aData->capacity = capacity;
  55     aData->growth = capacity/2 > 0 ? capacity/2 : 1;
  56     aData->length = 0;
  57     aData->retainCount = 1;
  58     aData->freeData = 1;
  59     aData->format = 0;
  60     aData->destructor = NULL;
  61
  62     return aData;
  63 }
  64
  65
  66 WMData*
  67 WMCreateDataWithLength(unsigned length) /*FOLD00*/
  68 {
  69     WMData *aData;
  70
  71     aData = WMCreateDataWithCapacity(length);
  72     if (length>0) {
  73         memset(aData->bytes, 0, length);
  74         aData->length = length;
  75     }
  76
  77     return aData;
  78 }
  79
  80
  81 WMData*
  82 WMCreateDataWithBytes(void *bytes, unsigned length) /*FOLD00*/
  83 {
  84     WMData *aData;
  85
  86     aData = WMCreateDataWithCapacity(length);
  87     aData->length = length;
  88     memcpy(aData->bytes, bytes, length);
  89
  90     return aData;
  91 }
  92
  93
  94 WMData*
  95 WMCreateDataWithBytesNoCopy(void *bytes, unsigned length) /*FOLD00*/
  96 {
  97     WMData *aData;
  98
  99     aData = (WMData*)wmalloc(sizeof(WMData));
 100     aData->length = length;
 101     aData->capacity = length;
 102     aData->growth = length/2 > 0 ? length/2 : 1;
 103     aData->bytes = bytes;
 104     aData->retainCount = 1;
 105     aData->freeData = 0;
 106     aData->format = 0;
 107     aData->destructor = NULL;
 108
 109     return aData;
 110 }
 111
 112
 113 WMData*
 114 WMCreateDataWithBytesAndDestructor(void *bytes, unsigned length,
 115                                    WMFreeDataProc *destructor)
 116 {
 117     WMData *aData;
 118
 119     aData = (WMData*)wmalloc(sizeof(WMData));
 120     aData->length = length;
 121     aData->capacity = length;
 122     aData->growth = length/2 > 0 ? length/2 : 1;
 123     aData->bytes = bytes;
 124     aData->retainCount = 1;
 125     aData->freeData = 0;
 126     aData->format = 0;
 127     aData->destructor = destructor;
 128
 129     return aData;
 130 }
 131
 132
 133 WMData*
 134 WMCreateDataWithData(WMData *aData) /*FOLD00*/
 135 {
 136     WMData *newData;
 137     if (aData->length > 0) {
 138         newData = WMCreateDataWithBytes(aData->bytes, aData->length);
 139     } else {
 140         newData = WMCreateDataWithCapacity(0);
 141     }
 142     newData->destructor = aData->destructor;
 143     newData->format = aData->format;
 144
 145     return newData;
 146 }
 147
 148
 149 WMData*
 150 WMRetainData(WMData *aData) /*FOLD00*/
 151 {
 152     aData->retainCount++;
 153     return aData;
 154 }
 155
 156
 157 void
 158 WMReleaseData(WMData *aData) /*FOLD00*/
 159 {
 160     aData->retainCount--;
 161     if (aData->retainCount > 0)
 162         return;
 163     if (aData->bytes && aData->freeData) {
 164         if (aData->destructor != NULL)
 165             aData->destructor(aData->bytes);
 166         else
 167             wfree(aData->bytes);
 168     }
 169     wfree(aData);
 170 }
 171
 172
 173
 174 /* Adjusting capacity */
 175
 176 void
 177 WMSetDataCapacity(WMData *aData, unsigned capacity) /*FOLD00*/
 178 {
 179     if (aData->capacity != capacity) {
 180         aData->bytes = wrealloc(aData->bytes, capacity);
 181         aData->capacity = capacity;
 182         aData->growth = capacity/2 > 0 ? capacity/2 : 1;
 183     }
 184     if (aData->length > capacity) {
 185         aData->length = capacity;
 186     }
 187 }
 188
 189
 190 void
 191 WMSetDataLength(WMData *aData, unsigned length) /*FOLD00*/
 192 {
 193     if (length > aData->capacity) {
 194         WMSetDataCapacity(aData, length);
 195     }
 196     if (length > aData->length) {
 197         unsigned char   *dataBytes = (unsigned char *)aData->bytes;
 198
 199         memset(dataBytes + aData->length, 0, length - aData->length);
 200     }
 201     aData->length = length;
 202 }
 203
 204
 205 void
 206 WMSetDataFormat(WMData *aData, unsigned format)
 207 {
 208     aData->format = format;
 209 }
 210
 211
 212 void
 213 WMIncreaseDataLengthBy(WMData *aData, unsigned extraLength) /*FOLD00*/
 214 {
 215     WMSetDataLength(aData, aData->length + extraLength);
 216 }
 217
 218
 219 /* Accessing data */
 220
 221 const void*
 222 WMDataBytes(WMData *aData) /*FOLD00*/
 223 {
 224     return aData->bytes;
 225 }
 226
 227
 228 void
 229 WMGetDataBytes(WMData *aData, void *buffer) /*FOLD00*/
 230 {
 231     wassertr(aData->length > 0);
 232
 233     memcpy(buffer, aData->bytes, aData->length);
 234 }
 235
 236
 237 unsigned
 238 WMGetDataFormat(WMData *aData)
 239 {
 240     return aData->format;
 241 }
 242
 243
 244 void
 245 WMGetDataBytesWithLength(WMData *aData, void *buffer, unsigned length) /*FOLD00*/
 246 {
 247     wassertr(aData->length > 0);
 248     wassertr(length <= aData->length);
 249
 250     memcpy(buffer, aData->bytes, length);
 251 }
 252
 253
 254 void
 255 WMGetDataBytesWithRange(WMData *aData, void *buffer, WMRange aRange) /*FOLD00*/
 256 {
 257         unsigned char *dataBytes = (unsigned char *)aData->bytes;
 258
 259     wassertr(aRange.position < aData->length);
 260     wassertr(aRange.count <= aData->length-aRange.position);
 261
 262     memcpy(buffer,dataBytes + aRange.position, aRange.count);
 263 }
 264
 265
 266 WMData*
 267 WMGetSubdataWithRange(WMData *aData, WMRange aRange) /*FOLD00*/
 268 {
 269     void *buffer;
 270     WMData *newData;
 271
 272     /* return an empty subdata instead if aRange.count is 0 ? */
 273     wassertrv(aRange.count > 0, NULL);
 274
 275     buffer = wmalloc(aRange.count);
 276     WMGetDataBytesWithRange(aData, buffer, aRange);
 277     newData = WMCreateDataWithBytesNoCopy(buffer, aRange.count);
 278     newData->destructor = aData->destructor;
 279     newData->format = aData->format;
 280
 281     return newData;
 282 }
 283
 284
 285 /* Testing data */
 286
 287 Bool
 288 WMIsDataEqualToData(WMData *aData, WMData *anotherData) /*FOLD00*/
 289 {
 290     if (aData->length != anotherData->length)
 291         return False;
 292     else if (!aData->bytes && !anotherData->bytes) /* both are empty */
 293         return True;
 294     else if (!aData->bytes || !anotherData->bytes) /* one of them is empty */
 295         return False;
 296     return (memcmp(aData->bytes, anotherData->bytes, aData->length)==0);
 297 }
 298
 299
 300 unsigned
 301 WMGetDataLength(WMData *aData) /*FOLD00*/
 302 {
 303     return aData->length;
 304 }
 305
 306
 307 /* Adding data */
 308 void
 309 WMAppendDataBytes(WMData *aData, void *bytes, unsigned length) /*FOLD00*/
 310 {
 311     unsigned oldLength = aData->length;
 312     unsigned newLength = oldLength + length;
 313         unsigned char *dataBytes = (unsigned char *)aData->bytes;
 314
 315     if (newLength > aData->capacity) {
 316         unsigned nextCapacity = aData->capacity + aData->growth;
 317         unsigned nextGrowth = aData->capacity ? aData->capacity : 1;
 318
 319         while (nextCapacity < newLength) {
 320             unsigned tmp = nextCapacity + nextGrowth;
 321
 322             nextGrowth = nextCapacity;
 323             nextCapacity = tmp;
 324         }
 325         WMSetDataCapacity(aData, nextCapacity);
 326         aData->growth = nextGrowth;
 327     }
 328     memcpy(dataBytes + oldLength, bytes, length);
 329     aData->length = newLength;
 330 }
 331
 332
 333 void
 334 WMAppendData(WMData *aData, WMData *anotherData) /*FOLD00*/
 335 {
 336     if (anotherData->length > 0)
 337         WMAppendDataBytes(aData, anotherData->bytes, anotherData->length);
 338 }
 339
 340
 341
 342 /* Modifying data */
 343
 344 void
 345 WMReplaceDataBytesInRange(WMData *aData, WMRange aRange, void *bytes) /*FOLD00*/
 346 {
 347         unsigned char *dataBytes = (unsigned char *)aData->bytes;
 348
 349     wassertr(aRange.position < aData->length);
 350     wassertr(aRange.count <= aData->length-aRange.position);
 351
 352     memcpy(dataBytes + aRange.position, bytes, aRange.count);
 353 }
 354
 355
 356 void
 357 WMResetDataBytesInRange(WMData *aData, WMRange aRange) /*FOLD00*/
 358 {
 359         unsigned char *dataBytes = (unsigned char *)aData->bytes;
 360
 361     wassertr(aRange.position < aData->length);
 362     wassertr(aRange.count <= aData->length-aRange.position);
 363
 364     memset(dataBytes + aRange.position, 0, aRange.count);
 365 }
 366
 367
 368 void
 369 WMSetData(WMData *aData, WMData *anotherData) /*FOLD00*/
 370 {
 371     unsigned length = anotherData->length;
 372
 373     WMSetDataCapacity(aData, length);
 374     if (length > 0)
 375         memcpy(aData->bytes, anotherData->bytes, length);
 376     aData->length = length;
 377 }
 378
 379
 380 /* Storing data */
 381
 382