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

dkcMemoryStream.c

説明を見る。
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     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 = 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 = 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 
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 //DKC_SERIALIZEから新しいMemoryStreamを作る。
00285 DKC_MEMORYSTREAM * WINAPI dkcAllocMemoryStreamDeserialize(DKC_DESERIALIZE *se)
00286 {
00287     DKC_MEMORYSTREAM *p;
00288     DKC_MEMORYSTREAM t;
00289     size_t read;
00290     //dkcmNOT_ASSERT(NULL==se);
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 }

dkutil_cに対してSun Jul 18 22:45:21 2004に生成されました。 doxygen 1.3.6