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

dkcMemoryStream.c

#include <limits.h>
#include "dkcMemoryStream.h"
#include "dkcStdio.h"

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

Include dependency graph

ソースコードを見る。

マクロ定義

#define DKUTIL_C_MEMORYSTREAM_C

関数

DKC_MEMORYSTREAM *WINAPI dkcAllocMemoryStream (size_t size)
 ストリーム領域を得る。

int WINAPI dkcFreeMemoryStream (DKC_MEMORYSTREAM **ptr)
 dkcAllocNewStream()で確保したストリーム領域を開放する

int WINAPI dkcMemoryStreamSeekLogic (DKC_MEMORYSTREAM *ptr, int offset, int point, int origin)
int WINAPI dkcMemoryStreamSeek (DKC_MEMORYSTREAM *ptr, int offset, int origin)
 streamをシークする。fseekみたいなもの

size_t WINAPI dkcMemoryStreamGetSeekPoint (DKC_MEMORYSTREAM *ptr)
 streamのシークポイントを返す。

int WINAPI dkcMemoryStreamRead (DKC_MEMORYSTREAM *ptr, void *buffer, size_t size, size_t *readsize)
 streamをリードする。freadみたいなもの

int WINAPI dkcMemoryStreamResize (DKC_MEMORYSTREAM *ptr, size_t want_size)
 streamのバッファを拡張する。

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

int WINAPI dkcMemoryStreamDynamicWrite (DKC_MEMORYSTREAM *ptr, const void *buffer, size_t size)
 streamをライトする。ライト出来なかったら内部で動的拡張する。

int WINAPI dkcMemoryStreamClear (DKC_MEMORYSTREAM *ptr)
 stream内をmemset(0)する。(seek位置も最初に戻される。

DKC_EXTERN size_t WINAPI dkcMemoryStreamNowOffset (DKC_MEMORYSTREAM *p)
 今、どこまで書きこんでいるかのサイズを取得

DKC_EXTERN BYTE *WINAPI dkcMemoryStreamPointer (DKC_MEMORYSTREAM *p)
 内部バッファへのポインタを取得

DKC_MEMORYSTREAM *WINAPI dkcAllocMemoryStreamCopy (const DKC_MEMORYSTREAM *ptr)
DKC_MEMORYSTREAM *WINAPI dkcAllocMemoryStreamDeserialize (DKC_DESERIALIZE *se)
 DKC_SERIALIZEから新しいMemoryStreamを作る。.

void dkcMemoryStreamSerialize (const DKC_MEMORYSTREAM *ptr, DKC_SERIALIZE *se)
 DKC_SERIALIZEにシリアライズデータをぶち込む.

void WINAPI dkcMemoryStreamAdapterInit (DKC_MEMORYSTREAM_ADAPTER *p, BYTE *buff, size_t size)
int WINAPI dkcMemoryStreamAdapterPushBack (DKC_MEMORYSTREAM_ADAPTER *p, const BYTE *buff, size_t size)
int WINAPI dkcMemoryStreamAdapterPopBack (DKC_MEMORYSTREAM_ADAPTER *p, size_t size)
BYTE *WINAPI dkcMemoryStreamAdapterPointer (DKC_MEMORYSTREAM_ADAPTER *p)
size_t WINAPI dkcMemoryStreamAdapterSize (DKC_MEMORYSTREAM_ADAPTER *p)
int WINAPI dkcMemoryStreamAdapterSetOffset (DKC_MEMORYSTREAM_ADAPTER *p, size_t offset)
size_t WINAPI dkcMemoryStreamAdapterGetOffset (DKC_MEMORYSTREAM_ADAPTER *p)


マクロ定義

#define DKUTIL_C_MEMORYSTREAM_C
 

d金魚

覚え書き:
licence:BSD Licence

dkcMemoryStream.c6 行で定義されています。


関数

DKC_MEMORYSTREAM* WINAPI dkcAllocMemoryStream size_t  size  ) 
 

ストリーム領域を得る。

引数:
flag[in] edkcMemoryStreamにある、StreamInit系のものを渡す
size[in] ストリームの初期化時のサイズ
filename[in] edkcMemoryStreamInitFileをflagに渡した場合、その保存するファイルの名前 flagにedkcMemoryStreamInitFile以外の値を渡した場合はNULLでOK
mode[in] fopenのモード flagにedkcMemoryStreamInitFile以外の値を渡した場合はNULLでOK
戻り値:
DKC_MEMORYSTREAM *のストリームデータ。

dkcMemoryStream.c16 行で定義されています。

参照先 BYTE, DKC_MEMORYSTREAM, dkcAllocate(), dkcFree(), dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcAllocDeserialize(), dkcAllocMemoryStreamCopy(), dkcAllocMemoryStreamDeserialize(), dkcAllocSerialize(), dkcAllocStream(), dkcAllocString(), と dkcAllocUniqueID().

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

DKC_MEMORYSTREAM* WINAPI dkcAllocMemoryStreamCopy const DKC_MEMORYSTREAM ptr  ) 
 

戻り値:
成功したらそのオブジェクトへのポインタが返る。失敗したらNULLが返る。
覚え書き:
C++で言うコピーコンストラクタ。

dkcMemoryStream.c274 行で定義されています。

参照先 DKC_MEMORYSTREAM, dkcAllocMemoryStream(), dkcMemoryStreamSeek(), dkcMemoryStreamWrite(), dkcmNOT_ASSERT, edkcMemoryStreamSeekSet, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, と NULL.

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 }

DKC_MEMORYSTREAM* WINAPI dkcAllocMemoryStreamDeserialize DKC_DESERIALIZE se  ) 
 

DKC_SERIALIZEから新しいMemoryStreamを作る。.

dkcMemoryStream.c293 行で定義されています。

参照先 DKC_DESERIALIZE, DKC_MEMORYSTREAM, dkcAllocMemoryStream(), dkcDeserializeRead(), dkcmNOT_ASSERT, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, と NULL.

参照元 dkcAllocStringDeserialize().

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 }

int WINAPI dkcFreeMemoryStream DKC_MEMORYSTREAM **  ptr  ) 
 

dkcAllocNewStream()で確保したストリーム領域を開放する

引数:
ptr[in][out] 削除するストリームデータ。入れたデータはNULLになる。

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

参照先 DKC_MEMORYSTREAM, dkcFree(), edk_ArgumentException, edk_FAILED, と NULL.

参照元 dkcAllocDeserialize(), dkcAllocSerialize(), dkcAllocStringDeserialize(), dkcFreeDeserialize(), dkcFreeSerialize(), dkcFreeStream(), dkcFreeString(), と dkcFreeUniqueID().

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

size_t WINAPI dkcMemoryStreamAdapterGetOffset DKC_MEMORYSTREAM_ADAPTER p  ) 
 

dkcMemoryStream.c381 行で定義されています。

参照先 DKC_MEMORYSTREAM_ADAPTER, と dkc_MemoryStreamAdapter::mNowOffset.

参照元 dkcRLEPackBitsEncode().

00381                                                                           {
00382     return p->mNowOffset;
00383 }

void WINAPI dkcMemoryStreamAdapterInit DKC_MEMORYSTREAM_ADAPTER p,
BYTE buff,
size_t  size
 

dkcMemoryStream.c331 行で定義されています。

参照先 BYTE, DKC_MEMORYSTREAM_ADAPTER, dkc_MemoryStreamAdapter::mBuff, dkc_MemoryStreamAdapter::mNowOffset, と dkc_MemoryStreamAdapter::mSize.

参照元 dkcRLEPackBitsEncode().

00332 {
00333     p->mBuff = buff;
00334     p->mSize = size;
00335     p->mNowOffset = 0;
00336 
00337 }

BYTE* WINAPI dkcMemoryStreamAdapterPointer DKC_MEMORYSTREAM_ADAPTER p  ) 
 

dkcMemoryStream.c365 行で定義されています。

参照先 BYTE, DKC_MEMORYSTREAM_ADAPTER, と dkc_MemoryStreamAdapter::mBuff.

参照元 dkcRLEPackBitsEncode().

00365                                                                        {
00366  return p->mBuff;
00367 }

int WINAPI dkcMemoryStreamAdapterPopBack DKC_MEMORYSTREAM_ADAPTER p,
size_t  size
 

dkcMemoryStream.c356 行で定義されています。

参照先 DKC_MEMORYSTREAM_ADAPTER, edk_FAILED, edk_SUCCEEDED, と dkc_MemoryStreamAdapter::mNowOffset.

参照元 dkcRLEPackBitsEncode().

00357 {
00358     if(size > p->mNowOffset){
00359         return edk_FAILED;
00360     }
00361     p->mNowOffset -= size;
00362     return edk_SUCCEEDED;
00363 }

int WINAPI dkcMemoryStreamAdapterPushBack DKC_MEMORYSTREAM_ADAPTER p,
const BYTE buff,
size_t  size
 

dkcMemoryStream.c339 行で定義されています。

参照先 BYTE, DKC_MEMORYSTREAM_ADAPTER, dkcCheckOverflowULONG(), edk_BufferOverFlow, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStreamAdapter::mBuff, dkc_MemoryStreamAdapter::mNowOffset, と dkc_MemoryStreamAdapter::mSize.

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 }

int WINAPI dkcMemoryStreamAdapterSetOffset DKC_MEMORYSTREAM_ADAPTER p,
size_t  offset
 

dkcMemoryStream.c374 行で定義されています。

参照先 DKC_MEMORYSTREAM_ADAPTER, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStreamAdapter::mNowOffset, と dkc_MemoryStreamAdapter::mSize.

00374                                                                                      {
00375     if(offset > p->mSize){
00376         return edk_FAILED;
00377     }
00378     p->mNowOffset = offset;
00379     return edk_SUCCEEDED;
00380 }

size_t WINAPI dkcMemoryStreamAdapterSize DKC_MEMORYSTREAM_ADAPTER p  ) 
 

dkcMemoryStream.c369 行で定義されています。

参照先 DKC_MEMORYSTREAM_ADAPTER, と dkc_MemoryStreamAdapter::mSize.

00369                                                                      {
00370     return p->mSize;
00371 
00372 }

int WINAPI dkcMemoryStreamAutoExpandResize DKC_MEMORYSTREAM ptr,
size_t  expand_size
[static]
 

引数:
ptr[in] 所貴下済みのDKC_MEMORYSTREAMへのポインタ
expand_size[in] 希望する拡張サイズ

dkcMemoryStream.c165 行で定義されています。

参照先 BYTE, DKC_MEMORYSTREAM, dkcReallocate(), dkcReallocateSizeFunction(), DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcMemoryStreamDynamicWrite().

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

int WINAPI dkcMemoryStreamClear DKC_MEMORYSTREAM ptr  ) 
 

stream内をmemset(0)する。(seek位置も最初に戻される。

dkcMemoryStream.c257 行で定義されています。

参照先 DKC_MEMORYSTREAM, dkcmNOT_ASSERT, edk_SUCCEEDED, と NULL.

参照元 dkcStreamClear(), と dkcStringCopy().

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

int WINAPI dkcMemoryStreamDynamicWrite DKC_MEMORYSTREAM ptr,
const void *  buffer,
size_t  size
 

streamをライトする。ライト出来なかったら内部で動的拡張する。

dkcMemoryStream.c231 行で定義されています。

参照先 DKC_MEMORYSTREAM, dkcMemoryStreamAutoExpandResize(), dkcMemoryStreamWrite(), DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcSerializeWrite(), dkcStringConcatenate(), と dkcStringCopy().

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

size_t WINAPI dkcMemoryStreamGetSeekPoint DKC_MEMORYSTREAM ptr  ) 
 

streamのシークポイントを返す。

dkcMemoryStream.c92 行で定義されています。

参照先 DKC_MEMORYSTREAM, と dkc_MemoryStream::mNowOffset.

参照元 dkcStringInsert().

00093 {
00094     return ptr->mNowOffset;
00095 }

DKC_EXTERN size_t WINAPI dkcMemoryStreamNowOffset DKC_MEMORYSTREAM p  ) 
 

今、どこまで書きこんでいるかのサイズを取得

dkcMemoryStream.c265 行で定義されています。

参照先 DKC_EXTERN, DKC_MEMORYSTREAM, と dkc_MemoryStream::mNowOffset.

00265                                                                       {
00266     return p->mNowOffset;
00267 }

DKC_EXTERN BYTE* WINAPI dkcMemoryStreamPointer DKC_MEMORYSTREAM p  ) 
 

内部バッファへのポインタを取得

dkcMemoryStream.c269 行で定義されています。

参照先 BYTE, DKC_EXTERN, DKC_MEMORYSTREAM, と dkc_MemoryStream::mBuffer.

00269                                                                    {
00270     return p->mBuffer;
00271 
00272 }

int WINAPI dkcMemoryStreamRead DKC_MEMORYSTREAM ptr,
void *  buffer,
size_t  size,
size_t *  readsize
 

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

引数:
readsize[out] 実際に読んだサイズを返す。NULLを渡してもOK.
覚え書き:
指定したサイズ(size)よりもストリームバッファのサイズが小さかった場合 readsizeに実際に読んだサイズを入れます。

dkcMemoryStream.c97 行で定義されています。

参照先 dkc_memcpy(), DKC_MEMORYSTREAM, dkcmNOT_ASSERT, edk_ArgumentException, edk_BufferOverFlow, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcDeserializeRead(), と dkcStreamRead().

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

int WINAPI dkcMemoryStreamResize DKC_MEMORYSTREAM ptr,
size_t  want_size
 

streamのバッファを拡張する。

dkcMemoryStream.c135 行で定義されています。

参照先 BYTE, DKC_MEMORYSTREAM, dkcReallocate(), DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mSize, と NULL.

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 }

int WINAPI dkcMemoryStreamSeek DKC_MEMORYSTREAM ptr,
int  offset,
int  origin
 

streamをシークする。fseekみたいなもの

dkcMemoryStream.c71 行で定義されています。

参照先 DKC_MEMORYSTREAM, dkcMemoryStreamSeekLogic(), edk_ArgumentException, edk_FAILED, edkcMemoryStreamSeekCurrent, edkcMemoryStreamSeekEnd, edkcMemoryStreamSeekSet, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcAllocMemoryStreamCopy(), dkcRLEDecode(), dkcRLEEncode(), dkcStreamSeek(), dkcStringCopy(), と dkcStringErase().

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

int WINAPI dkcMemoryStreamSeekLogic DKC_MEMORYSTREAM ptr,
int  offset,
int  point,
int  origin
[static]
 

dkcMemoryStream.c47 行で定義されています。

参照先 DKC_MEMORYSTREAM, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStream::mNowOffset, と dkc_MemoryStream::mSize.

参照元 dkcMemoryStreamSeek().

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

void dkcMemoryStreamSerialize const DKC_MEMORYSTREAM ptr,
DKC_SERIALIZE se
 

DKC_SERIALIZEにシリアライズデータをぶち込む.

dkcMemoryStream.c320 行で定義されています。

参照先 DKC_MEMORYSTREAM, DKC_SERIALIZE, dkcmNOT_ASSERT, dkcSerializeWrite(), と NULL.

参照元 dkcStringSerialize().

00321 {
00322     dkcmNOT_ASSERT(NULL==ptr);
00323 
00324     dkcSerializeWrite(se,ptr,sizeof(*ptr));
00325     dkcSerializeWrite(se,ptr->mBuffer,ptr->mSize);
00326 
00327 }

int WINAPI dkcMemoryStreamWrite DKC_MEMORYSTREAM ptr,
const void *  buffer,
size_t  size
 

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

覚え書き:
内部ストリームバッファは動的拡張です。気にせずどんどんぶち込みましょう。 C言語版のSTLのstd::vectorみたいなものですね。(といいますか、車輪の再開発してるし・・・。

dkcMemoryStream.c210 行で定義されています。

参照先 BYTE, dkc_memcpy(), DKC_MEMORYSTREAM, dkcmNOT_ASSERT, DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL.

参照元 dkcAllocMemoryStreamCopy(), dkcMemoryStreamDynamicWrite(), dkcRLEDecode(), dkcStreamWrite(), getABS(), と getRLE().

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


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