メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcMemoryStream.c

説明を見る。
00001 
00006 #define DKUTIL_C_MEMORYSTREAM_C
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 = (DKC_MEMORYSTREAM *)dkcAllocate(sizeof(DKC_MEMORYSTREAM));
00021 
00022     if(NULL==p) return NULL;
00023     p->mBuffer = (BYTE *)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((void **)&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((void **)&((*ptr)->mBuffer));
00041     return dkcFree((void **)ptr);
00042 }
00043 
00044 
00045 
00046 
00047 static int WINAPI dkcMemoryStreamSeekLogic(DKC_MEMORYSTREAM *ptr,int offset,int point,int origin){
00048     /*
00049     状態繊維:
00050     offset + succeeded
00051     offset - succeeded
00052     offset + length error
00053     offset - length error
00054     */
00055     size_t change = (size_t)(point + offset);
00056 
00057 
00058     //if(!(ptr->mSize > change)){
00059     if(!(ptr->mSize >= change)){
00060         return edk_FAILED;
00061     }
00062 
00063     //common...
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 /*- 1*/,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     //error check
00102 
00103     if(NULL==ptr || NULL==readsize) return edk_ArgumentException;
00104 
00105     //Read = (int)(ptr->mNowOffset + size); 
00106     //Read = (int)(ptr->mSize - Read); 
00107     //if(Read < 0) return edk_BufferOverFlow;
00108     
00109     //process...
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     if(DKUTIL_FAILED(dkc_memcpy(buffer,size,ptr->mBuffer + ptr->mNowOffset,f_read)))
00126     {
00127         return edk_FAILED;
00128     }
00129 
00130     //update...
00131     ptr->mNowOffset += f_read;
00132     *readsize = f_read;
00133     
00134     return edk_SUCCEEDED;
00135 }
00136 
00137 
00138 int WINAPI dkcMemoryStreamResize(DKC_MEMORYSTREAM *ptr,size_t want_size)
00139 {
00140     int ra_r = 0;
00141     void *NewPtr = NULL;
00142     void *OldPtr = NULL;
00143     
00144     //error check
00145     if(NULL==ptr) return edk_ArgumentException;
00146 
00147 
00148     //process
00149     OldPtr = ptr->mBuffer;
00150 
00151     ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00152     if(DKUTIL_FAILED(ra_r)){
00153         return edk_FAILED;
00154     }
00155 
00156     //update...
00157     ptr->mBuffer = (BYTE *)NewPtr;
00158     ptr->mSize = want_size;
00159 
00160 
00161     return edk_SUCCEEDED;
00162 }
00163 
00168 static int WINAPI dkcMemoryStreamAutoExpandResize(DKC_MEMORYSTREAM *ptr,size_t expand_size){
00169     int ra_r = 0;
00170     void *NewPtr = NULL;
00171     void *OldPtr = NULL;
00172     size_t ReallocatedSize = 0;
00173     size_t want_size;
00174     //size_t want_size = ptr->mSize + expand_size + 1;//なんとなく+1
00175     
00176     if(NULL==ptr) return edk_ArgumentException;
00177 
00178     OldPtr = ptr->mBuffer;
00179     /*
00180     ra_r = dkcReallocateAutoExpand(realloc,&NewPtr,&OldPtr,ptr->mSize,&ReallocatedSize);
00181     if(DKUTIL_FAILED(ra_r)){
00182         return edk_FAILED;
00183     }
00184     if(want_size > ReallocatedSize){
00185         OldPtr = NewPtr;
00186         ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00187         if(DKUTIL_FAILED(ra_r)){
00188             return edk_FAILED;
00189         }
00190         ReallocatedSize = want_size;
00191     }
00192     */
00193     want_size = dkcReallocateSizeFunction(
00194         ptr->mSize + ptr->mNowOffset,
00195         (expand_size <= 256) ? 256 : expand_size
00196     );
00197     ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00198     if(DKUTIL_FAILED(ra_r)){
00199         return edk_FAILED;
00200     }
00201     ReallocatedSize = want_size;
00202 
00203 
00204 
00205     ptr->mBuffer = (BYTE *)NewPtr;
00206     ptr->mSize = ReallocatedSize;
00207 
00208 
00209     return edk_SUCCEEDED;
00210 
00211 }
00212 
00213 int WINAPI dkcMemoryStreamWrite(DKC_MEMORYSTREAM *ptr,const void *buffer,size_t size){
00214     size_t rest;
00215 
00216     if(NULL==ptr) return edk_ArgumentException;
00217     
00218 
00219     if(ptr->mSize < ptr->mNowOffset + size){return edk_FAILED;}
00220     rest = ptr->mSize - ptr->mNowOffset;
00221     
00222     //酷バグ:dkcmNOT_ASSERTはDEBUGモード時にしか展開されない。
00223     /*dkcmNOT_ASSERT(
00224     ));*/
00225     if(DKUTIL_FAILED(dkc_memcpy(
00226         (void *)((BYTE *)ptr->mBuffer + ptr->mNowOffset),
00227         rest,
00228         buffer,size))){
00229         return edk_FAILED;
00230     }
00231     
00232     ptr->mNowOffset += size;
00233     
00234     return edk_SUCCEEDED;
00235 }
00236 
00237 
00238 int WINAPI dkcMemoryStreamDynamicWrite(DKC_MEMORYSTREAM *ptr,const void *buffer,size_t size){
00239     int result;
00240     size_t want_size;
00241 
00242     if(NULL==ptr) return edk_ArgumentException;
00243 
00244     want_size =  ptr->mNowOffset + size;
00245 
00246     if(ptr->mSize < want_size)
00247     {
00248         result = dkcMemoryStreamAutoExpandResize(ptr,size);
00249         //result = dkcMemoryStreamResize(ptr,want_size);
00250         if(DKUTIL_FAILED(result)) return edk_FAILED;
00251     }
00252 
00253     return dkcMemoryStreamWrite(ptr,buffer,size);
00254 }
00255 
00256 
00257 
00258 
00259 
00260 
00261 
00262 
00263 
00264 int WINAPI dkcMemoryStreamClear(DKC_MEMORYSTREAM *ptr){
00265     dkcmNOT_ASSERT(NULL==ptr);
00266     //if(NULL==ptr) return edk_ArgumentException;
00267     memset(ptr->mBuffer,0,ptr->mSize);
00268     ptr->mNowOffset = 0;
00269     return edk_SUCCEEDED;
00270 }
00271 
00272 DKC_EXTERN size_t WINAPI dkcMemoryStreamNowOffset(DKC_MEMORYSTREAM *p){
00273     return p->mNowOffset;
00274 }
00275 
00276 DKC_EXTERN BYTE *WINAPI dkcMemoryStreamPointer(DKC_MEMORYSTREAM *p){
00277     return p->mBuffer;
00278 
00279 }
00280 
00281 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStreamCopy(const DKC_MEMORYSTREAM *ptr)
00282 {
00283     DKC_MEMORYSTREAM *tp = NULL;
00284 
00285     dkcmNOT_ASSERT(NULL==ptr);
00286 
00287     tp = dkcAllocMemoryStream(ptr->mSize);
00288     if(NULL==tp) return NULL;
00289 
00290     dkcMemoryStreamWrite(tp,ptr->mBuffer,ptr->mSize);
00291 
00292     //内部オフセット変更                                    /* 先頭から */
00293     dkcMemoryStreamSeek(tp,ptr->mNowOffset,edkcMemoryStreamSeekSet);
00294     return tp;
00295 }
00296 
00297 
00298 
00299 //DKC_SERIALIZEから新しいMemoryStreamを作る。
00300 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStreamDeserialize(DKC_DESERIALIZE *se)
00301 {
00302     DKC_MEMORYSTREAM *p;
00303     DKC_MEMORYSTREAM t;
00304     size_t read;
00305     //dkcmNOT_ASSERT(NULL==se);
00306     
00307 
00308     dkcDeserializeRead(se,&t,sizeof(t),&read);
00309     
00310     p = dkcAllocMemoryStream(t.mSize);
00311     if(NULL==p) return NULL;
00312 
00313     /* シリアライズデータと同じにしないと^^; */
00314 
00315     dkcDeserializeRead(se,p->mBuffer,t.mSize,&read);
00316     
00317     dkcmNOT_ASSERT(read != t.mSize);
00318 
00319     
00320     p->mNowOffset = t.mNowOffset;
00321     
00322     return p;
00323 }
00324 
00325 
00327 void dkcMemoryStreamSerialize(const DKC_MEMORYSTREAM *ptr,DKC_SERIALIZE *se)
00328 {
00329     dkcmNOT_ASSERT(NULL==ptr);
00330 
00331     dkcSerializeWrite(se,ptr,sizeof(*ptr));
00332     dkcSerializeWrite(se,ptr->mBuffer,ptr->mSize);
00333 
00334 }
00335 
00336 
00337 
00338 void WINAPI dkcMemoryStreamAdapterInit(DKC_MEMORYSTREAM_ADAPTER *p,BYTE *buff,size_t size)
00339 {
00340     p->mBuff = buff;
00341     p->mSize = size;
00342     p->mNowOffset = 0;
00343 
00344 }
00345 
00346 int WINAPI dkcMemoryStreamAdapterPushBack(DKC_MEMORYSTREAM_ADAPTER *p,const BYTE *buff,size_t size)
00347 {
00348     size_t offset = p->mNowOffset;
00349     BYTE *tb = p->mBuff;
00350     if(dkcCheckOverflowULONG(offset,size)){
00351         return edk_FAILED;
00352     }
00353     if(offset + size >= p->mSize){
00354         return edk_BufferOverFlow;
00355     }
00356     memcpy(&tb[offset],buff,size);
00357 
00358     p->mNowOffset += size;
00359 
00360     return edk_SUCCEEDED;
00361 }
00362 
00363 int WINAPI dkcMemoryStreamAdapterPopBack(DKC_MEMORYSTREAM_ADAPTER *p,size_t size)
00364 {
00365     if(size > p->mNowOffset){
00366         return edk_FAILED;
00367     }
00368     p->mNowOffset -= size;
00369     return edk_SUCCEEDED;
00370 }
00371 
00372 BYTE *WINAPI dkcMemoryStreamAdapterPointer(DKC_MEMORYSTREAM_ADAPTER *p){
00373  return p->mBuff;
00374 }
00375 
00376 size_t WINAPI dkcMemoryStreamAdapterSize(DKC_MEMORYSTREAM_ADAPTER *p){
00377     return p->mSize;
00378 
00379 }
00380 
00381 int WINAPI dkcMemoryStreamAdapterSetOffset(DKC_MEMORYSTREAM_ADAPTER *p,size_t offset){
00382     if(offset > p->mSize){
00383         return edk_FAILED;
00384     }
00385     p->mNowOffset = offset;
00386     return edk_SUCCEEDED;
00387 }
00388 size_t WINAPI dkcMemoryStreamAdapterGetOffset(DKC_MEMORYSTREAM_ADAPTER *p){
00389     return p->mNowOffset;
00390 }

dkutil_cに対してTue Dec 7 01:09:56 2004に生成されました。 doxygen 1.3.6