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