WINGs/data.c

   1 /*
   2  *  WINGs WMData function library
   3  *
   4  *  Copyright (c) 1999-2000 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
  55     aData->capacity = capacity;
  56     aData->growth = capacity/2 > 0 ? capacity/2 : 1;
  57     aData->length = 0;
  58     aData->retainCount = 1;
  59     aData->format = 0;
  60     aData->freeData = 1;
  61     aData->destructor = NULL;
  62
  63     return aData;
  64 }
  65
  66
  67 WMData*
  68 WMCreateDataWithLength(unsigned length) /*FOLD00*/
  69 {
  70     WMData *aData;
  71
  72     aData = WMCreateDataWithCapacity(length);
  73     if (length>0) {
  74         memset(aData->bytes, 0, length);
  75         aData->length = length;
  76     }
  77
  78     return aData;
  79 }
  80
  81
  82 WMData*
  83 WMCreateDataWithBytes(void *bytes, unsigned length) /*FOLD00*/
  84 {
  85     WMData *aData;
  86
  87     aData = WMCreateDataWithCapacity(length);
  88     aData->length = length;
  89     memcpy(aData->bytes, bytes, length);
  90
  91     return aData;
  92 }
  93
  94
  95 WMData*
  96 WMCreateDataWithBytesNoCopy(void *bytes, unsigned length, /*FOLD00*/
  97                             WMFreeDataProc *destructor)
  98 {
  99     WMData *aData;
 100
 101     aData = (WMData*)wmalloc(sizeof(WMData));
 102     aData->length = length;
 103     aData->capacity = length;
 104     aData->growth = length/2 > 0 ? length/2 : 1;
 105     aData->bytes = bytes;
 106     aData->retainCount = 1;
 107     aData->freeData = 0;
 108     aData->format = 0;
 109     aData->destructor = destructor;
 110
 111     return aData;
 112 }
 113
 114
 115 WMData*
 116 WMCreateDataWithData(WMData *aData) /*FOLD00*/
 117 {
 118     WMData *newData;
 119
 120     if (aData->length > 0) {
 121         newData = WMCreateDataWithBytes(aData->bytes, aData->length);
 122     } else {
 123         newData = WMCreateDataWithCapacity(0);
 124     }
 125     newData->format = aData->format;
 126
 127     return newData;
 128 }
 129
 130
 131 WMData*
 132 WMRetainData(WMData *aData) /*FOLD00*/
 133 {
 134     aData->retainCount++;
 135     return aData;
 136 }
 137
 138
 139 void
 140 WMReleaseData(WMData *aData) /*FOLD00*/
 141 {
 142     aData->retainCount--;
 143     if (aData->retainCount > 0)
 144         return;
 145     if (aData->bytes != NULL) {
 146         if (aData->destructor != NULL) {
 147             aData->destructor(aData->bytes);
 148         } else if (aData->freeData) {
 149             wfree(aData->bytes);
 150         }
 151     }
 152     wfree(aData);
 153 }
 154
 155
 156
 157 /* Adjusting capacity */
 158
 159 void
 160 WMSetDataCapacity(WMData *aData, unsigned capacity) /*FOLD00*/
 161 {
 162     if (aData->capacity != capacity) {
 163         aData->bytes = wrealloc(aData->bytes, capacity);
 164         aData->capacity = capacity;
 165         aData->growth = capacity/2 > 0 ? capacity/2 : 1;
 166     }
 167     if (aData->length > capacity) {
 168         aData->length = capacity;
 169     }
 170 }
 171
 172
 173 void
 174 WMSetDataLength(WMData *aData, unsigned length) /*FOLD00*/
 175 {
 176     if (length > aData->capacity) {
 177         WMSetDataCapacity(aData, length);
 178     }
 179     if (length > aData->length) {
 180         unsigned char   *dataBytes = (unsigned char *)aData->bytes;
 181
 182         memset(dataBytes + aData->length, 0, length - aData->length);
 183     }
 184     aData->length = length;
 185 }
 186
 187
 188 void
 189 WMSetDataFormat(WMData *aData, unsigned format)
 190 {
 191     aData->format = format;
 192 }
 193
 194
 195 void
 196 WMIncreaseDataLengthBy(WMData *aData, unsigned extraLength) /*FOLD00*/
 197 {
 198     WMSetDataLength(aData, aData->length + extraLength);
 199 }
 200
 201
 202 /* Accessing data */
 203
 204 const void*
 205 WMDataBytes(WMData *aData) /*FOLD00*/
 206 {
 207     return aData->bytes;
 208 }
 209
 210
 211 void
 212 WMGetDataBytes(WMData *aData, void *buffer) /*FOLD00*/
 213 {
 214     wassertr(aData->length > 0);
 215
 216     memcpy(buffer, aData->bytes, aData->length);
 217 }
 218
 219
 220 unsigned
 221 WMGetDataFormat(WMData *aData)
 222 {
 223     return aData->format;
 224 }
 225
 226
 227 void
 228 WMGetDataBytesWithLength(WMData *aData, void *buffer, unsigned length) /*FOLD00*/
 229 {
 230     wassertr(aData->length > 0);
 231     wassertr(length <= aData->length);
 232
 233     memcpy(buffer, aData->bytes, length);
 234 }
 235
 236
 237 void
 238 WMGetDataBytesWithRange(WMData *aData, void *buffer, WMRange aRange) /*FOLD00*/
 239 {
 240     unsigned char *dataBytes = (unsigned char *)aData->bytes;
 241
 242     wassertr(aRange.position < aData->length);
 243     wassertr(aRange.count <= aData->length-aRange.position);
 244
 245     memcpy(buffer,dataBytes + aRange.position, aRange.count);
 246 }
 247
 248
 249 WMData*
 250 WMGetSubdataWithRange(WMData *aData, WMRange aRange) /*FOLD00*/
 251 {
 252     void *buffer;
 253     WMData *newData;
 254
 255     /* return an empty subdata instead if aRange.count is 0 ? */
 256     wassertrv(aRange.count > 0, NULL);
 257
 258     buffer = wmalloc(aRange.count);
 259     WMGetDataBytesWithRange(aData, buffer, aRange);
 260     newData = WMCreateDataWithBytesNoCopy(buffer, aRange.count, wfree);
 261     //newData->freeData = 1;
 262     newData->format = aData->format;
 263
 264     return newData;
 265 }
 266
 267
 268 /* Testing data */
 269
 270 Bool
 271 WMIsDataEqualToData(WMData *aData, WMData *anotherData) /*FOLD00*/
 272 {
 273     if (aData->length != anotherData->length)
 274         return False;
 275     else if (!aData->bytes && !anotherData->bytes) /* both are empty */
 276         return True;
 277     else if (!aData->bytes || !anotherData->bytes) /* one of them is empty */
 278         return False;
 279     return (memcmp(aData->bytes, anotherData->bytes, aData->length)==0);
 280 }
 281
 282
 283 unsigned
 284 WMGetDataLength(WMData *aData) /*FOLD00*/
 285 {
 286     return aData->length;
 287 }
 288
 289
 290 /* Adding data */
 291 void
 292 WMAppendDataBytes(WMData *aData, void *bytes, unsigned length) /*FOLD00*/
 293 {
 294     unsigned oldLength = aData->length;
 295     unsigned newLength = oldLength + length;
 296     unsigned char *dataBytes = (unsigned char *)aData->bytes;
 297
 298     if (newLength > aData->capacity) {
 299         unsigned nextCapacity = aData->capacity + aData->growth;
 300         unsigned nextGrowth = aData->capacity ? aData->capacity : 1;
 301
 302         while (nextCapacity < newLength) {
 303             unsigned tmp = nextCapacity + nextGrowth;
 304
 305             nextGrowth = nextCapacity;
 306             nextCapacity = tmp;
 307         }
 308         WMSetDataCapacity(aData, nextCapacity);
 309         aData->growth = nextGrowth;
 310     }
 311     memcpy(dataBytes + oldLength, bytes, length);
 312     aData->length = newLength;
 313 }
 314
 315
 316 void
 317 WMAppendData(WMData *aData, WMData *anotherData) /*FOLD00*/
 318 {
 319     if (anotherData->length > 0)
 320         WMAppendDataBytes(aData, anotherData->bytes, anotherData->length);
 321 }
 322
 323
 324
 325 /* Modifying data */
 326
 327 void
 328 WMReplaceDataBytesInRange(WMData *aData, WMRange aRange, void *bytes) /*FOLD00*/
 329 {
 330         unsigned char *dataBytes = (unsigned char *)aData->bytes;
 331
 332     wassertr(aRange.position < aData->length);
 333     wassertr(aRange.count <= aData->length-aRange.position);
 334
 335     memcpy(dataBytes + aRange.position, bytes, aRange.count);
 336 }
 337
 338
 339 void
 340 WMResetDataBytesInRange(WMData *aData, WMRange aRange) /*FOLD00*/
 341 {
 342         unsigned char *dataBytes = (unsigned char *)aData->bytes;
 343
 344     wassertr(aRange.position < aData->length);
 345     wassertr(aRange.count <= aData->length-aRange.position);
 346
 347     memset(dataBytes + aRange.position, 0, aRange.count);
 348 }
 349
 350
 351 void
 352 WMSetData(WMData *aData, WMData *anotherData) /*FOLD00*/
 353 {
 354     unsigned length = anotherData->length;
 355
 356     WMSetDataCapacity(aData, length);
 357     if (length > 0)
 358         memcpy(aData->bytes, anotherData->bytes, length);
 359     aData->length = length;
 360 }
 361
 362
 363 /* Storing data */
 364
 365