WINGs/data.c

   1 /*
   2  *  WINGs WMData function library
   3  *
   4  *  Copyright (c) 1999-2003 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 #include <string.h>
  22 #include "WUtil.h"
  23
  24 typedef struct W_Data {
  25         unsigned length;        /* How many bytes we have */
  26         unsigned capacity;      /* How many bytes it can hold */
  27         unsigned growth;        /* How much to grow */
  28         void *bytes;            /* Actual data */
  29         unsigned retainCount;
  30         WMFreeDataProc *destructor;
  31         int format;             /* 0, 8, 16 or 32 */
  32 } W_Data;
  33
  34 /* Creating and destroying data objects */
  35
  36 WMData *WMCreateDataWithCapacity(unsigned capacity)
  37 {
  38         WMData *aData;
  39
  40         aData = (WMData *) wmalloc(sizeof(WMData));
  41
  42         if (capacity > 0)
  43                 aData->bytes = wmalloc(capacity);
  44         else
  45                 aData->bytes = NULL;
  46
  47         aData->capacity = capacity;
  48         aData->growth = capacity / 2 > 0 ? capacity / 2 : 1;
  49         aData->length = 0;
  50         aData->retainCount = 1;
  51         aData->format = 0;
  52         aData->destructor = wfree;
  53
  54         return aData;
  55 }
  56
  57 WMData *WMCreateDataWithLength(unsigned length)
  58 {
  59         WMData *aData;
  60
  61         aData = WMCreateDataWithCapacity(length);
  62         if (length > 0) {
  63                 aData->length = length;
  64         }
  65
  66         return aData;
  67 }
  68
  69 WMData *WMCreateDataWithBytes(void *bytes, unsigned length)
  70 {
  71         WMData *aData;
  72
  73         aData = WMCreateDataWithCapacity(length);
  74         aData->length = length;
  75         memcpy(aData->bytes, bytes, length);
  76
  77         return aData;
  78 }
  79
  80 WMData *WMCreateDataWithBytesNoCopy(void *bytes, unsigned length, WMFreeDataProc * destructor)
  81 {
  82         WMData *aData;
  83
  84         aData = (WMData *) wmalloc(sizeof(WMData));
  85         aData->length = length;
  86         aData->capacity = length;
  87         aData->growth = length / 2 > 0 ? length / 2 : 1;
  88         aData->bytes = bytes;
  89         aData->retainCount = 1;
  90         aData->format = 0;
  91         aData->destructor = destructor;
  92
  93         return aData;
  94 }
  95
  96 WMData *WMCreateDataWithData(WMData * aData)
  97 {
  98         WMData *newData;
  99
 100         if (aData->length > 0) {
 101                 newData = WMCreateDataWithBytes(aData->bytes, aData->length);
 102         } else {
 103                 newData = WMCreateDataWithCapacity(0);
 104         }
 105         newData->format = aData->format;
 106
 107         return newData;
 108 }
 109
 110 WMData *WMRetainData(WMData * aData)
 111 {
 112         aData->retainCount++;
 113         return aData;
 114 }
 115
 116 void WMReleaseData(WMData * aData)
 117 {
 118         aData->retainCount--;
 119         if (aData->retainCount > 0)
 120                 return;
 121         if (aData->bytes != NULL && aData->destructor != NULL) {
 122                 aData->destructor(aData->bytes);
 123         }
 124         wfree(aData);
 125 }
 126
 127 /* Adjusting capacity */
 128
 129 void WMSetDataCapacity(WMData * aData, unsigned capacity)
 130 {
 131         if (aData->capacity != capacity) {
 132                 aData->bytes = wrealloc(aData->bytes, capacity);
 133                 aData->capacity = capacity;
 134                 aData->growth = capacity / 2 > 0 ? capacity / 2 : 1;
 135         }
 136         if (aData->length > capacity) {
 137                 aData->length = capacity;
 138         }
 139 }
 140
 141 void WMSetDataLength(WMData * aData, unsigned length)
 142 {
 143         if (length > aData->capacity) {
 144                 WMSetDataCapacity(aData, length);
 145         }
 146         if (length > aData->length) {
 147                 memset((unsigned char *)aData->bytes + aData->length, 0, length - aData->length);
 148         }
 149         aData->length = length;
 150 }
 151
 152 void WMSetDataFormat(WMData * aData, unsigned format)
 153 {
 154         aData->format = format;
 155 }
 156
 157 void WMIncreaseDataLengthBy(WMData * aData, unsigned extraLength)
 158 {
 159         WMSetDataLength(aData, aData->length + extraLength);
 160 }
 161
 162 /* Accessing data */
 163
 164 const void *WMDataBytes(WMData * aData)
 165 {
 166         return aData->bytes;
 167 }
 168
 169 void WMGetDataBytes(WMData * aData, void *buffer)
 170 {
 171         wassertr(aData->length > 0);
 172
 173         memcpy(buffer, aData->bytes, aData->length);
 174 }
 175
 176 unsigned WMGetDataFormat(WMData * aData)
 177 {
 178         return aData->format;
 179 }
 180
 181 void WMGetDataBytesWithLength(WMData * aData, void *buffer, unsigned length)
 182 {
 183         wassertr(aData->length > 0);
 184         wassertr(length <= aData->length);
 185
 186         memcpy(buffer, aData->bytes, length);
 187 }
 188
 189 void WMGetDataBytesWithRange(WMData * aData, void *buffer, WMRange aRange)
 190 {
 191         wassertr(aRange.position < aData->length);
 192         wassertr(aRange.count <= aData->length - aRange.position);
 193
 194         memcpy(buffer, (unsigned char *)aData->bytes + aRange.position, aRange.count);
 195 }
 196
 197 WMData *WMGetSubdataWithRange(WMData * aData, WMRange aRange)
 198 {
 199         void *buffer;
 200         WMData *newData;
 201
 202         if (aRange.count <= 0)
 203                 return WMCreateDataWithCapacity(0);
 204
 205         buffer = wmalloc(aRange.count);
 206         WMGetDataBytesWithRange(aData, buffer, aRange);
 207         newData = WMCreateDataWithBytesNoCopy(buffer, aRange.count, wfree);
 208         newData->format = aData->format;
 209
 210         return newData;
 211 }
 212
 213 /* Testing data */
 214
 215 Bool WMIsDataEqualToData(WMData * aData, WMData * anotherData)
 216 {
 217         if (aData->length != anotherData->length)
 218                 return False;
 219         else if (!aData->bytes && !anotherData->bytes)  /* both are empty */
 220                 return True;
 221         else if (!aData->bytes || !anotherData->bytes)  /* one of them is empty */
 222                 return False;
 223         return (memcmp(aData->bytes, anotherData->bytes, aData->length) == 0);
 224 }
 225
 226 unsigned WMGetDataLength(WMData * aData)
 227 {
 228         return aData->length;
 229 }
 230
 231 /* Adding data */
 232 void WMAppendDataBytes(WMData * aData, void *bytes, unsigned length)
 233 {
 234         unsigned oldLength = aData->length;
 235         unsigned newLength = oldLength + length;
 236
 237         if (newLength > aData->capacity) {
 238                 unsigned nextCapacity = aData->capacity + aData->growth;
 239                 unsigned nextGrowth = aData->capacity ? aData->capacity : 1;
 240
 241                 while (nextCapacity < newLength) {
 242                         unsigned tmp = nextCapacity + nextGrowth;
 243
 244                         nextGrowth = nextCapacity;
 245                         nextCapacity = tmp;
 246                 }
 247                 WMSetDataCapacity(aData, nextCapacity);
 248                 aData->growth = nextGrowth;
 249         }
 250         memcpy((unsigned char *)aData->bytes + oldLength, bytes, length);
 251         aData->length = newLength;
 252 }
 253
 254 void WMAppendData(WMData * aData, WMData * anotherData)
 255 {
 256         if (anotherData->length > 0)
 257                 WMAppendDataBytes(aData, anotherData->bytes, anotherData->length);
 258 }
 259
 260 /* Modifying data */
 261
 262 void WMReplaceDataBytesInRange(WMData * aData, WMRange aRange, void *bytes)
 263 {
 264         wassertr(aRange.position < aData->length);
 265         wassertr(aRange.count <= aData->length - aRange.position);
 266
 267         memcpy((unsigned char *)aData->bytes + aRange.position, bytes, aRange.count);
 268 }
 269
 270 void WMResetDataBytesInRange(WMData * aData, WMRange aRange)
 271 {
 272         wassertr(aRange.position < aData->length);
 273         wassertr(aRange.count <= aData->length - aRange.position);
 274
 275         memset((unsigned char *)aData->bytes + aRange.position, 0, aRange.count);
 276 }
 277
 278 void WMSetData(WMData * aData, WMData * anotherData)
 279 {
 280         unsigned length = anotherData->length;
 281
 282         WMSetDataCapacity(aData, length);
 283         if (length > 0)
 284                 memcpy(aData->bytes, anotherData->bytes, length);
 285         aData->length = length;
 286 }
 287
 288 /* Storing data */