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

dkcCircularStream.c

#include "dkcCircularStream.h"

dkcCircularStream.cのインクルード依存関係図

Include dependency graph

ソースコードを見る。

関数

DKC_CIRCULARSTREAM *WINAPI dkcAllocNewCircularStream (size_t size, short mode, const char *filename, const char *openmode)
int WINAPI dkcFreeDeleteCircularStream (DKC_CIRCULARSTREAM **ptr)
int WINAPI dkcNewCircularStream (DKC_CIRCULARSTREAM *ptr, size_t size)
int WINAPI dkcNewCircularStreamForFile (DKC_CIRCULARSTREAM *ptr, size_t size, const char *filename, const char *openmode)
DKC_INLINE BOOL isDoubleProcess (size_t start, size_t data_length, size_t border_size)
int WINAPI dkcCircularStreamReadLogic (DKC_CIRCULARSTREAM *RingBuf, void *Buf, size_t Len, size_t *readsize, BOOL PeekFlag)
int WINAPI dkcCircularStreamRead (DKC_CIRCULARSTREAM *ptr, void *buffer, size_t size, size_t *readsize)
 streamをリードする。freadみたいなもの

int WINAPI dkcCircularStreamReference (DKC_CIRCULARSTREAM *ptr, void *buffer, size_t size, size_t *readsize)
 中を覗き見るだけ。引数についてはdkcCircularStreamRead()を見るべし。

int WINAPI dkcCircularStreamWrite (DKC_CIRCULARSTREAM *ptr, const void *buffer, size_t size)
 streamをライトする。fwriteみたいなもの

int WINAPI dkcCircularStreamZero (DKC_CIRCULARSTREAM *ptr)
 stream内をmemset(0)する。

int WINAPI dkcCircularStreamToBuffer (const DKC_STREAM *ptr, char *buff, size_t size, size_t want_size)
 stream内のものをバッファにコピーする。

int WINAPI dkcDeleteCircularStream (DKC_CIRCULARSTREAM *ptr)
 circular streamをデリート fcloseみたいなもの note 必ずストリームを使用したあとはこれを呼んでください。

int WINAPI dkcCircularStreamDump (DKC_CIRCULARSTREAM *ptr, const char *filename, int flag)
 streamをファイルにダンプする。


関数

DKC_CIRCULARSTREAM* WINAPI dkcAllocNewCircularStream size_t  size,
short  mode,
const char *  filename,
const char *  openmode
 

dkcCircularStream.c7 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcAllocate(), dkcFree(), dkcNewCircularStream(), dkcNewCircularStreamForFile(), DKUTIL_FAILED, edk_FAILED, edkcCircularStreamInitFile, と NULL.

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(&p);
00033     return NULL;
00034 }

int WINAPI dkcCircularStreamDump DKC_CIRCULARSTREAM ptr,
const char *  filename,
int  flag
 

streamをファイルにダンプする。

覚え書き:
ファイルとしてストリームを初期化したのならばこの関数は失敗する

dkcCircularStream.c243 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcAllocate(), dkcSaveBinary(), DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, edk_OutOfMemory, edkcCircularStreamDumpAll, edkcCircularStreamDumpEnable, edkcStreamSeekSet, dkc_CircularStream::mEnableLength, dkc_CircularStream::mEnd, dkc_CircularStream::mSize, dkc_CircularStream::mStart, dkc_CircularStream::mStream, と NULL.

00243                                                                                        {
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 }

int WINAPI dkcCircularStreamRead DKC_CIRCULARSTREAM ptr,
void *  buffer,
size_t  size,
size_t *  readsize
 

streamをリードする。freadみたいなもの

引数:
readsize[out] 実際に読んだサイズを返す。NULLを渡してもOK.
覚え書き:
・指定したサイズ(size)よりもストリームバッファのサイズが小さかった場合 readsizeに実際に読んだサイズを入れます。 ・Readしたデータは取り出したデータとして処理され、 そのバッファ内容は次のデータを保存する領域として再利用されます。 つまり、一度Readしたデータは二度と取り出せません。

dkcCircularStream.c148 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcCircularStreamReadLogic(), と FALSE.

00149 {
00150     return dkcCircularStreamReadLogic(ptr,buffer,size,readsize,FALSE);
00151 }

int WINAPI dkcCircularStreamReadLogic DKC_CIRCULARSTREAM RingBuf,
void *  Buf,
size_t  Len,
size_t *  readsize,
BOOL  PeekFlag
[static]
 

dkcCircularStream.c90 行で定義されています。

参照先 BOOL, DKC_CIRCULARSTREAM, edk_ArgumentException, edk_SUCCEEDED, edkcStreamSeekSet, FALSE, isDoubleProcess(), dkc_CircularStream::mEnableLength, dkc_CircularStream::mSize, dkc_CircularStream::mStart, dkc_CircularStream::mStream, と NULL.

参照元 dkcCircularStreamRead(), と dkcCircularStreamReference().

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     // 2回に別けなければいけないかどうかで処理を分岐
00111     if( isDoubleProcess(RingBuf->mStart, Len, RingBuf->mSize) /*RingBuf->mStart + Len > RingBuf->mSize*/ )
00112     {
00113         // 2回に別ける場合の処理
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         // 1回で格納する場合の処理
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 }

int WINAPI dkcCircularStreamReference DKC_CIRCULARSTREAM ptr,
void *  buffer,
size_t  size,
size_t *  readsize
 

中を覗き見るだけ。引数についてはdkcCircularStreamRead()を見るべし。

dkcCircularStream.c153 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcCircularStreamReadLogic(), と TRUE.

00154 {
00155     return dkcCircularStreamReadLogic(ptr,buffer,size,readsize,TRUE);
00156 }

int WINAPI dkcCircularStreamToBuffer const DKC_STREAM ptr,
char *  buff,
size_t  size,
size_t  want_size
 

stream内のものをバッファにコピーする。

dkcCircularStream.c212 行で定義されています。

参照先 DKC_STREAM, と edk_SUCCEEDED.

00213 {
00214     
00215     return edk_SUCCEEDED;
00216 }

int WINAPI dkcCircularStreamWrite DKC_CIRCULARSTREAM ptr,
const void *  buffer,
size_t  size
 

streamをライトする。fwriteみたいなもの

覚え書き:
内部ストリームバッファは円型です。いわいるRingBufferって奴です。 dkcCircularStreamWriteしたらdkcCircularStreamReadしてデータを出してあげましょう。 そうしなければ、いずれ、円型バッファの有効データが一杯になってこの関数は失敗します。 C言語版 boost::circular_bufferみたいなものですね^^;(といいますか、また車輪の再開発してるし・・・。

dkcCircularStream.c160 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcStreamSeek(), dkcStreamWrite(), edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, edkcCircularStreamInitFile, edkcStreamSeekSet, isDoubleProcess(), dkc_CircularStream::mEnableLength, dkc_CircularStream::mEnd, dkc_CircularStream::mMode, dkc_CircularStream::mSize, dkc_CircularStream::mStream, と NULL.

00160                                                                                          {
00161     if(NULL==ptr || NULL==buffer || 0==size ) return edk_ArgumentException;
00162     //DxLibを参考にしました。この場をお借りしてお礼申し上げます。m(_ _)m
00163     switch(ptr->mMode){
00164     case edkcCircularStreamInitBuffer:
00165         // 2回に分けて格納しなければならないかどうかで処理を分岐
00166         if(isDoubleProcess(ptr->mEnd,size,ptr->mSize))
00167         {
00168             // 2回に別けて格納する場合の処理
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             // 1回で格納する場合の処理
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 }

int WINAPI dkcCircularStreamZero DKC_CIRCULARSTREAM ptr  ) 
 

stream内をmemset(0)する。

dkcCircularStream.c191 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcStreamClear(), DKUTIL_FAILED, edk_ArgumentException, edk_SUCCEEDED, dkc_CircularStream::mEnableLength, dkc_CircularStream::mEnd, dkc_CircularStream::mStart, dkc_CircularStream::mStream, と NULL.

00191                                                          {
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 }

int WINAPI dkcDeleteCircularStream DKC_CIRCULARSTREAM ptr  ) 
 

circular streamをデリート fcloseみたいなもの note 必ずストリームを使用したあとはこれを呼んでください。

dkcCircularStream.c222 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcFClose(), dkcFree(), DKUTIL_MEMZERO, edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, edkcCircularStreamInitFile, dkc_CircularStream::mMode, dkc_CircularStream::mStream, と NULL.

参照元 dkcFreeDeleteCircularStream().

00222                                                            {
00223     if(NULL==ptr) return edk_ArgumentException;
00224     if(NULL==ptr->mStream) return edk_FAILED;
00225     switch(ptr->mMode){
00226     case edkcCircularStreamInitBuffer:
00227         dkcFree(&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 }

int WINAPI dkcFreeDeleteCircularStream DKC_CIRCULARSTREAM **  ptr  ) 
 

dkcCircularStream.c36 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcDeleteCircularStream(), dkcFree(), DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, と NULL.

00036                                                                 {
00037     if(NULL==ptr){return edk_ArgumentException;}
00038     if(DKUTIL_FAILED(dkcDeleteCircularStream(*ptr))){
00039         return edk_FAILED;
00040     }
00041     return dkcFree(ptr);
00042 }

int WINAPI dkcNewCircularStream DKC_CIRCULARSTREAM ptr,
size_t  size
 

dkcCircularStream.c44 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcAllocStream(), edk_ArgumentException, edk_FAILED, edk_OutOfMemory, edk_SUCCEEDED, dkc_CircularStream::mEnableLength, dkc_CircularStream::mEnd, dkc_CircularStream::mMode, dkc_CircularStream::mSize, dkc_CircularStream::mStart, dkc_CircularStream::mStream, と NULL.

参照元 dkcAllocNewCircularStream().

00044                                                                     {
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 }

int WINAPI dkcNewCircularStreamForFile DKC_CIRCULARSTREAM ptr,
size_t  size,
const char *  filename,
const char *  openmode
 

dkcCircularStream.c67 行で定義されています。

参照先 DKC_CIRCULARSTREAM, dkcFOpen(), edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, edkcCircularStreamInitFile, dkc_CircularStream::mEnableLength, dkc_CircularStream::mEnd, dkc_CircularStream::mMode, dkc_CircularStream::mSize, dkc_CircularStream::mStart, dkc_CircularStream::mStream, と NULL.

参照元 dkcAllocNewCircularStream().

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 }

DKC_INLINE BOOL isDoubleProcess size_t  start,
size_t  data_length,
size_t  border_size
[static]
 

dkcCircularStream.c83 行で定義されています。

参照先 BOOL, と DKC_INLINE.

参照元 dkcCircularMemoryStreamReadLogic(), dkcCircularMemoryStreamWrite(), dkcCircularStreamReadLogic(), と dkcCircularStreamWrite().

00084 {
00085     return (start + data_length > border_size);
00086 }


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