メインページ | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

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     
00126 
00127     //update...
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     //error check
00142     if(NULL==ptr) return edk_ArgumentException;
00143 
00144 
00145     //process
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     //update...
00154     ptr->mBuffer = (BYTE *)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     //size_t want_size = ptr->mSize + expand_size + 1;//なんとなく+1
00172     
00173     if(NULL==ptr) return edk_ArgumentException;
00174 
00175     OldPtr = ptr->mBuffer;
00176     /*
00177     ra_r = dkcReallocateAutoExpand(realloc,&NewPtr,&OldPtr,ptr->mSize,&ReallocatedSize);
00178     if(DKUTIL_FAILED(ra_r)){
00179         return edk_FAILED;
00180     }
00181     if(want_size > ReallocatedSize){
00182         OldPtr = NewPtr;
00183         ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00184         if(DKUTIL_FAILED(ra_r)){
00185             return edk_FAILED;
00186         }
00187         ReallocatedSize = want_size;
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 = (BYTE *)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         //result = dkcMemoryStreamResize(ptr,want_size);
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     //if(NULL==ptr) return edk_ArgumentException;
00260     memset(ptr->mBuffer,0,ptr->mSize);
00261     ptr->mNowOffset = 0;
00262     return edk_SUCCEEDED;
00263 }
00264 
00265 DKC_EXTERN size_t WINAPI dkcMemoryStreamNowOffset(DKC_MEMORYSTREAM *p){
00266     return p->mNowOffset;
00267 }
00268 
00269 DKC_EXTERN BYTE *WINAPI dkcMemoryStreamPointer(DKC_MEMORYSTREAM *p){
00270     return p->mBuffer;
00271 
00272 }
00273 
00274 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStreamCopy(const DKC_MEMORYSTREAM *ptr)
00275 {
00276     DKC_MEMORYSTREAM *tp = NULL;
00277 
00278     dkcmNOT_ASSERT(NULL==ptr);
00279 
00280     tp = dkcAllocMemoryStream(ptr->mSize);
00281     if(NULL==tp) return NULL;
00282 
00283     dkcMemoryStreamWrite(tp,ptr->mBuffer,ptr->mSize);
00284 
00285     //内部オフセット変更                                    /* 先頭から */
00286     dkcMemoryStreamSeek(tp,ptr->mNowOffset,edkcMemoryStreamSeekSet);
00287     return tp;
00288 }
00289 
00290 
00291 
00292 //DKC_SERIALIZEから新しいMemoryStreamを作る。
00293 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStreamDeserialize(DKC_DESERIALIZE *se)
00294 {
00295     DKC_MEMORYSTREAM *p;
00296     DKC_MEMORYSTREAM t;
00297     size_t read;
00298     //dkcmNOT_ASSERT(NULL==se);
00299     
00300 
00301     dkcDeserializeRead(se,&t,sizeof(t),&read);
00302     
00303     p = dkcAllocMemoryStream(t.mSize);
00304     if(NULL==p) return NULL;
00305 
00306     /* シリアライズデータと同じにしないと^^; */
00307 
00308     dkcDeserializeRead(se,p->mBuffer,t.mSize,&read);
00309     
00310     dkcmNOT_ASSERT(read != t.mSize);
00311 
00312     
00313     p->mNowOffset = t.mNowOffset;
00314     
00315     return p;
00316 }
00317 
00318 
00320 void dkcMemoryStreamSerialize(const DKC_MEMORYSTREAM *ptr,DKC_SERIALIZE *se)
00321 {
00322     dkcmNOT_ASSERT(NULL==ptr);
00323 
00324     dkcSerializeWrite(se,ptr,sizeof(*ptr));
00325     dkcSerializeWrite(se,ptr->mBuffer,ptr->mSize);
00326 
00327 }
00328 
00329 
00330 
00331 void WINAPI dkcMemoryStreamAdapterInit(DKC_MEMORYSTREAM_ADAPTER *p,BYTE *buff,size_t size)
00332 {
00333     p->mBuff = buff;
00334     p->mSize = size;
00335     p->mNowOffset = 0;
00336 
00337 }
00338 
00339 int WINAPI dkcMemoryStreamAdapterPushBack(DKC_MEMORYSTREAM_ADAPTER *p,const BYTE *buff,size_t size)
00340 {
00341     size_t offset = p->mNowOffset;
00342     BYTE *tb = p->mBuff;
00343     if(dkcCheckOverflowULONG(offset,size)){
00344         return edk_FAILED;
00345     }
00346     if(offset + size >= p->mSize){
00347         return edk_BufferOverFlow;
00348     }
00349     memcpy(&tb[offset],buff,size);
00350 
00351     p->mNowOffset += size;
00352 
00353     return edk_SUCCEEDED;
00354 }
00355 
00356 int WINAPI dkcMemoryStreamAdapterPopBack(DKC_MEMORYSTREAM_ADAPTER *p,size_t size)
00357 {
00358     if(size > p->mNowOffset){
00359         return edk_FAILED;
00360     }
00361     p->mNowOffset -= size;
00362     return edk_SUCCEEDED;
00363 }
00364 
00365 BYTE *WINAPI dkcMemoryStreamAdapterPointer(DKC_MEMORYSTREAM_ADAPTER *p){
00366  return p->mBuff;
00367 }
00368 
00369 size_t WINAPI dkcMemoryStreamAdapterSize(DKC_MEMORYSTREAM_ADAPTER *p){
00370     return p->mSize;
00371 
00372 }
00373 
00374 int WINAPI dkcMemoryStreamAdapterSetOffset(DKC_MEMORYSTREAM_ADAPTER *p,size_t offset){
00375     if(offset > p->mSize){
00376         return edk_FAILED;
00377     }
00378     p->mNowOffset = offset;
00379     return edk_SUCCEEDED;
00380 }
00381 size_t WINAPI dkcMemoryStreamAdapterGetOffset(DKC_MEMORYSTREAM_ADAPTER *p){
00382     return p->mNowOffset;
00383 }

dkutil_cに対してTue Oct 19 03:34:55 2004に生成されました。 doxygen 1.3.6