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

# dkcCircularStream.c

説明を見る。

    00001
    00002 #include "dkcCircularStream.h"
    00003
    00004
    00005 #if 0
    00006
    00007 DKC_CIRCULARSTREAM * WINAPI dkcAllocNewCircularStream(size_t size,
    00008                     short mode,const char *filename,const char *openmode)
    00009 {
    00010     DKC_CIRCULARSTREAM *p = NULL;
    00011     int r=edk_FAILED;
    00012
    00013     p = (DKC_CIRCULARSTREAM *)dkcAllocate(sizeof(DKC_CIRCULARSTREAM));
    00014     if(NULL==p) return NULL;
    00015     switch(mode){
    00016     case edkcCircularStreamInitBuffer:
    00017         r = dkcNewCircularStream(p,size);
    00018         break;
    00019     case edkcCircularStreamInitFile:
    00020         r = dkcNewCircularStreamForFile(p,size,filename,openmode);
    00021         break;
    00022     default:
    00023         goto Error;
    00024     }
    00025
    00026     if(DKUTIL_FAILED(r))
    00027     {
    00028         goto Error;
    00029     }
    00030     return p;
    00031 Error:
    00032     dkcFree((void **)&p);
    00033     return NULL;
    00034 }
    00035
    00036 int WINAPI dkcFreeDeleteCircularStream(DKC_CIRCULARSTREAM **ptr){
    00037     if(NULL==ptr){return edk_ArgumentException;}
    00038     if(DKUTIL_FAILED(dkcDeleteCircularStream(*ptr))){
    00039         return edk_FAILED;
    00040     }
    00041     return dkcFree((void **)ptr);
    00042 }
    00043
    00044 int WINAPI dkcNewCircularStream(DKC_CIRCULARSTREAM *ptr,size_t size){
    00045     if(NULL==ptr) return edk_ArgumentException;
    00046     if(NULL != ptr->mStream){
    00047         return edk_FAILED;
    00048     }
    00049
    00050
    00051     ptr->mStream = dkcAllocStream(edkcStreamInitBuffer,size,NULL,NULL);
    00052
    00053     if(!ptr->mStream){
    00054         return edk_OutOfMemory;
    00055     }
    00056
    00057
    00058     ptr->mStart = 0;
    00059     ptr->mEnd = 0;
    00060     ptr->mEnableLength = 0;
    00061     ptr->mMode = edkcCircularStreamInitBuffer;
    00062     ptr->mSize = size;
    00063
    00064     return edk_SUCCEEDED;
    00065 }
    00066
    00067 int WINAPI dkcNewCircularStreamForFile(DKC_CIRCULARSTREAM *ptr,size_t size,const char *filename,const char *openmode)
    00068 {
    00069     void *p;
    00070     if(NULL==ptr || NULL==filename || NULL==openmode) return edk_ArgumentException;
    00071
    00072     p = dkcFOpen(filename,openmode);
    00073     if(NULL==p) return edk_FAILED;
    00074     ptr->mStream = p;
    00075     ptr->mEnableLength = 0;
    00076     ptr->mStart = 0;
    00077     ptr->mEnd = 0;
    00078     ptr->mMode = edkcCircularStreamInitFile;
    00079     ptr->mSize = size;
    00080     return edk_SUCCEEDED;
    00081
    00082 }
    00083 static DKC_INLINE BOOL isDoubleProcess(size_t start,size_t data_length,size_t border_size)
    00084 {
    00085     return (start + data_length > border_size);
    00086 }
    00087
    00088
    00089
    00090 static int WINAPI dkcCircularStreamReadLogic(
    00091     DKC_CIRCULARSTREAM *RingBuf,void *Buf , size_t Len,size_t *readsize,BOOL PeekFlag)
    00092 {
    00093     if(NULL==RingBuf || NULL==RingBuf->mStream || NULL==readsize)
    00094         return edk_ArgumentException;
    00095
    00096
    00097     if( RingBuf->mEnableLength < Len )
    00098     {   // 存在するデータ量より多かったら
    00099         //return edk_FAILED ;
    00100         //とりあえず、ありったけのデータをもらおう。
    00101         Len = RingBuf->mEnableLength;
    00102
    00103     }else{
    00104
    00105
    00106     }
    00107     //読み込むデータはこのくらいあるのだ！
    00108     *readsize = Len;
    00109
    00110     // ２回に別けなければいけないかどうかで処理を分岐
    00111     if( isDoubleProcess(RingBuf->mStart, Len, RingBuf->mSize) /*RingBuf->mStart + Len > RingBuf->mSize*/ )
    00112     {
    00113         // ２回に別ける場合の処理
    00114         //memcpy( Buf,
    00115         //  (char *)RingBuf->mBuffer + RingBuf->mStart,
    00116         //  RingBuf->mSize - RingBuf->mStart ) ;
    00117         //memcpy( (char *)Buf + ( RingBuf->mSize - RingBuf->mStart ),
    00118         //  RingBuf->mBuffer,
    00119         //  Len - ( RingBuf->mSize - RingBuf->mStart ) ) ;
    00120
    00121         //最初からシーク
    00122         dkcStreamToBuffer(RingBuf->mStream,edkcStreamSeekSet,
    00123             RingBuf->mStart, RingBuf->mSize - RingBuf->mStart,Buf,Len);
    00124
    00125         dkcStreamToBuffer(RingBuf->mStream,edkcStreamSeekSet,
    00126             0 ,Len - ( RingBuf->mSize - RingBuf->mStart ),
    00127             (char *)Buf + ( RingBuf->mSize - RingBuf->mStart ),Len);
    00128
    00129         if( PeekFlag == FALSE ) RingBuf->mStart = Len - ( RingBuf->mSize - RingBuf->mStart ) ;
    00130     }
    00131     else
    00132     {
    00133         // １回で格納する場合の処理
    00134         //memcpy( Buf, (char *)RingBuf->mBuffer + RingBuf->mStart, Len ) ;
    00135
    00136         dkcStreamToBuffer(RingBuf->mStream,edkcStreamSeekSet,
    00137             RingBuf->mStart,Len,Buf,Len);
    00138
    00139         if( PeekFlag == FALSE )  RingBuf->mStart += Len ;
    00140     }
    00141
    00142     // データの量を減らす
    00143     if( PeekFlag == FALSE )  RingBuf->mEnableLength -= Len ;
    00144     return edk_SUCCEEDED;
    00145 }
    00146
    00147 //streamをリードする。freadみたいなもの
    00148 int WINAPI dkcCircularStreamRead(DKC_CIRCULARSTREAM *ptr,void *buffer,size_t size,size_t *readsize)
    00149 {
    00150     return dkcCircularStreamReadLogic(ptr,buffer,size,readsize,FALSE);
    00151 }
    00152 //中を覗き見るだけ。
    00153 int WINAPI dkcCircularStreamReference(DKC_CIRCULARSTREAM *ptr,void *buffer,size_t size,size_t *readsize)
    00154 {
    00155     return dkcCircularStreamReadLogic(ptr,buffer,size,readsize,TRUE);
    00156 }
    00157
    00158
    00159 //streamをライトする。fwriteみたいなもの
    00160 int WINAPI dkcCircularStreamWrite(DKC_CIRCULARSTREAM *ptr,const void *buffer,size_t size){
    00161     if(NULL==ptr || NULL==buffer || 0==size ) return edk_ArgumentException;
    00162     //DxLibを参考にしました。この場をお借りしてお礼申し上げます。m(_ _)m
    00163     switch(ptr->mMode){
    00164     case edkcCircularStreamInitBuffer:
    00165         // ２回に分けて格納しなければならないかどうかで処理を分岐
    00166         if(isDoubleProcess(ptr->mEnd,size,ptr->mSize))
    00167         {
    00168             // ２回に別けて格納する場合の処理
    00169             //memcpy( (char *)ptr->mStream + ptr->mEnd, buffer, ptr->mSize - ptr->mEnd ) ;
    00170             //memcpy( ptr->mStream, (char *)buffer + ( ptr->mSize - ptr->mEnd ), size - ( ptr->mSize - ptr->mEnd ) ) ;
    00171             dkcStreamWrite(ptr->mStream,buffer,ptr->mSize - ptr->mEnd);
    00172             dkcStreamSeek(ptr->mStream,0,edkcStreamSeekSet);//オフセットを最初にする。
    00173             dkcStreamWrite(ptr->mStream,(char *)buffer + ( ptr->mSize - ptr->mEnd ),size - ( ptr->mSize - ptr->mEnd ));
    00174             ptr->mEnd = size - ( ptr->mSize - ptr->mEnd ) ;
    00175         }else{
    00176             // １回で格納する場合の処理
    00177             //memcpy( (char *)ptr->mStream + ptr->mEnd, buffer, size ) ;
    00178             dkcStreamWrite(ptr->mStream,buffer,size);
    00179             ptr->mEnd += size ;
    00180         }
    00181         break;
    00182     case edkcCircularStreamInitFile:
    00183         break;
    00184     default://やっぱり老婆心
    00185         return edk_FAILED;
    00186     }
    00187     // 格納しているデータの量を増やす
    00188     ptr->mEnableLength += size;
    00189     return edk_SUCCEEDED;
    00190 }
    00191 int WINAPI dkcCircularStreamZero(DKC_CIRCULARSTREAM *ptr){
    00192     int r;
    00193     if(NULL==ptr || NULL==ptr->mStream){return edk_ArgumentException;}
    00194     r = dkcStreamClear(ptr->mStream);
    00195     if(DKUTIL_FAILED(r)) return r;
    00196     ptr->mEnableLength = 0;
    00197     ptr->mEnd = 0;
    00198     //ptr->mSize = 0;
    00199     ptr->mStart = 0;
    00200
    00201     /*//switch(ptr->mMode){
    00202     //case edkcCircularStreamInitBuffer:
    00203
    00204         //break;
    00205     //case edkcCircularStreamInitBuffer
    00206         //dkcStreamZeroInit(ptr->mStream);
    00207     //}*/
    00208     return edk_SUCCEEDED;
    00209 }
    00210
    00211 //stream内のものをバッファにコピーする。
    00212 int WINAPI dkcCircularStreamToBuffer(const DKC_STREAM *ptr,char *buff,size_t size,size_t want_size)
    00213 {
    00214
    00215     return edk_SUCCEEDED;
    00216 }
    00217
    00218
    00219
    00220
    00222 int WINAPI dkcDeleteCircularStream(DKC_CIRCULARSTREAM *ptr){
    00223     if(NULL==ptr) return edk_ArgumentException;
    00224     if(NULL==ptr->mStream) return edk_FAILED;
    00225     switch(ptr->mMode){
    00226     case edkcCircularStreamInitBuffer:
    00227         dkcFree((void **)&ptr->mStream);
    00228         break;
    00229     case edkcCircularStreamInitFile:
    00230         dkcFClose((FILE **)&ptr->mStream);
    00231         break;
    00232     default:
    00233         return edk_FAILED;
    00234     }
    00235     DKUTIL_MEMZERO(ptr,sizeof(DKC_CIRCULARSTREAM));
    00236     return edk_SUCCEEDED;
    00237 }
    00238
    00239
    00240
    00241
    00242
    00243 int WINAPI dkcCircularStreamDump(DKC_CIRCULARSTREAM *ptr,const char *filename,int flag){
    00244     int result = edk_FAILED;
    00245     char *buffer = NULL;
    00246     size_t buffsize = 0;
    00247
    00248     if(NULL==ptr || NULL==filename ) return edk_ArgumentException;
    00249     switch(flag){
    00250     case edkcCircularStreamDumpAll:
    00251         result = dkcStreamDump(ptr->mStream,filename);
    00252         break;
    00253     case edkcCircularStreamDumpEnable:
    00254         buffer = dkcAllocate(ptr->mEnableLength);
    00255         if(NULL==buffer) return edk_OutOfMemory;
    00256         buffsize = ptr->mEnableLength;
    00257
    00258
    00259         // * : 使用中バッファ - : 無使用バッファ。
    00260         if(ptr->mStart > ptr->mEnd)
    00261         {//*****------***** こんな感じ。
    00262             result = dkcStreamToBuffer(ptr->mStream,edkcStreamSeekSet,
    00263                 ptr->mStart,ptr->mSize - ptr->mStart,
    00264                 buffer,ptr->mSize - ptr->mStart);
    00265
    00266 #       ifdef DEBUG
    00267             if(DKUTIL_FAILED(result)) return edk_FAILED;
    00268 #       endif
    00269             result = dkcStreamToBuffer(ptr->mStream,edkcStreamSeekSet,
    00270                 0,ptr->mEnd,
    00271                 (char *)buffer + (ptr->mSize - ptr->mStart),ptr->mEnd);
    00272
    00273         }else{
    00274             //---*****---- こんな感じ
    00275             result = dkcStreamToBuffer(ptr->mStream,edkcStreamSeekSet,
    00276                 ptr->mStart,ptr->mEnd,buffer,buffsize);
    00277         }
    00278         if(DKUTIL_FAILED(result)) return edk_FAILED;
    00279
    00280
    00281         result = dkcSaveBinary(buffer,buffsize,filename);
    00282
    00283
    00284         break;
    00285     default:
    00286         return edk_ArgumentException;
    00287     }
    00288     return result;
    00289 }
    00290
    00291 #endif