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