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