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