00001
00007 #include <limits.h>
00008 #include "dkcMemoryStream.h"
00009
00010 #include "dkcStdio.h"
00011
00012
00013
00014
00015
00016 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStream(size_t size){
00017 DKC_MEMORYSTREAM *p;
00018 if(0==size) return NULL;
00019
00020 p = dkcAllocate(sizeof(DKC_MEMORYSTREAM));
00021
00022 if(NULL==p) return NULL;
00023 p->mBuffer = dkcAllocate(size);
00024 if(NULL==p->mBuffer) goto Error;
00025
00026 p->mSize = size;
00027 p->mNowOffset = 0;
00028 return p;
00029 Error:
00030 dkcFree(&p);
00031 return NULL;
00032
00033 }
00034
00035
00036 int WINAPI dkcFreeMemoryStream(DKC_MEMORYSTREAM **ptr){
00037 if(NULL==ptr || NULL==*ptr) return edk_ArgumentException;
00038 if(NULL==(*ptr)->mBuffer) return edk_FAILED;
00039
00040 dkcFree(&((*ptr)->mBuffer));
00041 return dkcFree(ptr);
00042 }
00043
00044
00045
00046
00047 static int WINAPI dkcMemoryStreamSeekLogic(DKC_MEMORYSTREAM *ptr,int offset,int point,int origin){
00048
00049
00050
00051
00052
00053
00054
00055 size_t change = (size_t)(point + offset);
00056
00057
00058
00059 if(!(ptr->mSize >= change)){
00060 return edk_FAILED;
00061 }
00062
00063
00064
00065 ptr->mNowOffset = change;
00066
00067
00068 return edk_SUCCEEDED;
00069 }
00070
00071 int WINAPI dkcMemoryStreamSeek(DKC_MEMORYSTREAM *ptr,int offset,int origin){
00072 int result = edk_FAILED;
00073 if(NULL==ptr) return edk_ArgumentException;
00074 switch(origin)
00075 {
00076 case edkcMemoryStreamSeekCurrent:
00077 result = dkcMemoryStreamSeekLogic(ptr,offset,ptr->mNowOffset,origin);
00078 break;
00079 case edkcMemoryStreamSeekEnd:
00080 result = dkcMemoryStreamSeekLogic(ptr,offset,0,origin);
00081 break;
00082 case edkcMemoryStreamSeekSet:
00083 result = dkcMemoryStreamSeekLogic(ptr,offset,ptr->mSize ,origin);
00084 break;
00085 default:
00086
00087 return edk_ArgumentException;
00088 }
00089 return result;
00090 }
00091
00092 size_t WINAPI dkcMemoryStreamGetSeekPoint(DKC_MEMORYSTREAM *ptr)
00093 {
00094 return ptr->mNowOffset;
00095 }
00096
00097 int WINAPI dkcMemoryStreamRead(DKC_MEMORYSTREAM *ptr,void *buffer,size_t size,size_t *readsize){
00098
00099
00100 size_t f_read = 0;
00101
00102
00103 if(NULL==ptr || NULL==readsize) return edk_ArgumentException;
00104
00105
00106
00107
00108
00109
00110
00111 f_read = ptr->mNowOffset + size;
00112
00113 if(ptr->mSize <= f_read){
00114 f_read = ptr->mSize - ptr->mNowOffset;
00115 if(0==f_read) return edk_BufferOverFlow;
00116 }else{
00117 f_read = size;
00118 }
00119
00120
00121
00122 dkcmNOT_ASSERT(edk_FAILED==dkc_memcpy(buffer,size,
00123 ptr->mBuffer + ptr->mNowOffset,f_read
00124 ));
00125
00126
00127
00128 ptr->mNowOffset += f_read;
00129 *readsize = f_read;
00130
00131 return edk_SUCCEEDED;
00132 }
00133
00134
00135 int WINAPI dkcMemoryStreamResize(DKC_MEMORYSTREAM *ptr,size_t want_size)
00136 {
00137 int ra_r = 0;
00138 void *NewPtr = NULL;
00139 void *OldPtr = NULL;
00140
00141
00142 if(NULL==ptr) return edk_ArgumentException;
00143
00144
00145
00146 OldPtr = ptr->mBuffer;
00147
00148 ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00149 if(DKUTIL_FAILED(ra_r)){
00150 return edk_FAILED;
00151 }
00152
00153
00154 ptr->mBuffer = NewPtr;
00155 ptr->mSize = want_size;
00156
00157
00158 return edk_SUCCEEDED;
00159 }
00160
00165 static int WINAPI dkcMemoryStreamAutoExpandResize(DKC_MEMORYSTREAM *ptr,size_t expand_size){
00166 int ra_r = 0;
00167 void *NewPtr = NULL;
00168 void *OldPtr = NULL;
00169 size_t ReallocatedSize = 0;
00170 size_t want_size;
00171
00172
00173 if(NULL==ptr) return edk_ArgumentException;
00174
00175 OldPtr = ptr->mBuffer;
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190 want_size = dkcReallocateSizeFunction(
00191 ptr->mSize + ptr->mNowOffset,
00192 (expand_size <= 256) ? 256 : expand_size
00193 );
00194 ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00195 if(DKUTIL_FAILED(ra_r)){
00196 return edk_FAILED;
00197 }
00198 ReallocatedSize = want_size;
00199
00200
00201
00202 ptr->mBuffer = NewPtr;
00203 ptr->mSize = ReallocatedSize;
00204
00205
00206 return edk_SUCCEEDED;
00207
00208 }
00209
00210 int WINAPI dkcMemoryStreamWrite(DKC_MEMORYSTREAM *ptr,const void *buffer,size_t size){
00211 size_t rest;
00212
00213 if(NULL==ptr) return edk_ArgumentException;
00214
00215
00216 if(ptr->mSize < ptr->mNowOffset + size){return edk_FAILED;}
00217 rest = ptr->mSize - ptr->mNowOffset;
00218
00219 dkcmNOT_ASSERT(DKUTIL_FAILED(dkc_memcpy(
00220 (void *)((BYTE *)ptr->mBuffer + ptr->mNowOffset),
00221 rest,
00222 buffer,size)
00223 ));
00224
00225 ptr->mNowOffset += size;
00226
00227 return edk_SUCCEEDED;
00228 }
00229
00230
00231 int WINAPI dkcMemoryStreamDynamicWrite(DKC_MEMORYSTREAM *ptr,const void *buffer,size_t size){
00232 int result;
00233 size_t want_size;
00234
00235 if(NULL==ptr) return edk_ArgumentException;
00236
00237 want_size = ptr->mNowOffset + size;
00238
00239 if(ptr->mSize < want_size)
00240 {
00241 result = dkcMemoryStreamAutoExpandResize(ptr,size);
00242
00243 if(DKUTIL_FAILED(result)) return edk_FAILED;
00244 }
00245
00246 return dkcMemoryStreamWrite(ptr,buffer,size);
00247 }
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257 int WINAPI dkcMemoryStreamClear(DKC_MEMORYSTREAM *ptr){
00258 dkcmNOT_ASSERT(NULL==ptr);
00259
00260 memset(ptr->mBuffer,0,ptr->mSize);
00261 ptr->mNowOffset = 0;
00262 return edk_SUCCEEDED;
00263 }
00264
00265
00266 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStreamCopy(const DKC_MEMORYSTREAM *ptr)
00267 {
00268 DKC_MEMORYSTREAM *tp = NULL;
00269
00270 dkcmNOT_ASSERT(NULL==ptr);
00271
00272 tp = dkcAllocMemoryStream(ptr->mSize);
00273 if(NULL==tp) return NULL;
00274
00275 dkcMemoryStreamWrite(tp,ptr->mBuffer,ptr->mSize);
00276
00277
00278 dkcMemoryStreamSeek(tp,ptr->mNowOffset,edkcMemoryStreamSeekSet);
00279 return tp;
00280 }
00281
00282
00283
00284
00285 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStreamDeserialize(DKC_DESERIALIZE *se)
00286 {
00287 DKC_MEMORYSTREAM *p;
00288 DKC_MEMORYSTREAM t;
00289 size_t read;
00290
00291
00292
00293 dkcDeserializeRead(se,&t,sizeof(t),&read);
00294
00295 p = dkcAllocMemoryStream(t.mSize);
00296 if(NULL==p) return NULL;
00297
00298
00299
00300 dkcDeserializeRead(se,p->mBuffer,t.mSize,&read);
00301
00302 dkcmNOT_ASSERT(read != t.mSize);
00303
00304
00305 p->mNowOffset = t.mNowOffset;
00306
00307 return p;
00308 }
00309
00310
00312 void dkcMemoryStreamSerialize(const DKC_MEMORYSTREAM *ptr,DKC_SERIALIZE *se)
00313 {
00314 dkcmNOT_ASSERT(NULL==ptr);
00315
00316 dkcSerializeWrite(se,ptr,sizeof(*ptr));
00317 dkcSerializeWrite(se,ptr->mBuffer,ptr->mSize);
00318
00319 }