00001
00002 #include "dkcCircularStream.h"
00003
00004
00005
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
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) )
00112 {
00113
00114
00115
00116
00117
00118
00119
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
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
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
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
00163 switch(ptr->mMode){
00164 case edkcCircularStreamInitBuffer:
00165
00166 if(isDoubleProcess(ptr->mEnd,size,ptr->mSize))
00167 {
00168
00169
00170
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
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
00199 ptr->mStart = 0;
00200
00201
00202
00203
00204
00205
00206
00207
00208 return edk_SUCCEEDED;
00209 }
00210
00211
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 }