#include <limits.h>#include "dkcMemoryStream.h"#include "dkcStdio.h"dkcMemoryStream.cのインクルード依存関係図

マクロ定義 | |
| #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) |
|
|
d金魚
dkcMemoryStream.c の 6 行で定義されています。 |
|
|
ストリーム領域を得る。
dkcMemoryStream.c の 16 行で定義されています。 参照先 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 }
|
|
|
dkcMemoryStream.c の 281 行で定義されています。 参照先 DKC_MEMORYSTREAM, dkcAllocMemoryStream(), dkcMemoryStreamSeek(), dkcMemoryStreamWrite(), dkcmNOT_ASSERT, edkcMemoryStreamSeekSet, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, と NULL.
00282 {
00283 DKC_MEMORYSTREAM *tp = NULL;
00284
00285 dkcmNOT_ASSERT(NULL==ptr);
00286
00287 tp = dkcAllocMemoryStream(ptr->mSize);
00288 if(NULL==tp) return NULL;
00289
00290 dkcMemoryStreamWrite(tp,ptr->mBuffer,ptr->mSize);
00291
00292 //内部オフセット変更 /* 先頭から */
00293 dkcMemoryStreamSeek(tp,ptr->mNowOffset,edkcMemoryStreamSeekSet);
00294 return tp;
00295 }
|
|
|
DKC_SERIALIZEから新しいMemoryStreamを作る。.
dkcMemoryStream.c の 300 行で定義されています。 参照先 DKC_DESERIALIZE, DKC_MEMORYSTREAM, dkcAllocMemoryStream(), dkcDeserializeRead(), dkcmNOT_ASSERT, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, と NULL. 参照元 dkcAllocStringDeserialize().
00301 {
00302 DKC_MEMORYSTREAM *p;
00303 DKC_MEMORYSTREAM t;
00304 size_t read;
00305 //dkcmNOT_ASSERT(NULL==se);
00306
00307
00308 dkcDeserializeRead(se,&t,sizeof(t),&read);
00309
00310 p = dkcAllocMemoryStream(t.mSize);
00311 if(NULL==p) return NULL;
00312
00313 /* シリアライズデータと同じにしないと^^; */
00314
00315 dkcDeserializeRead(se,p->mBuffer,t.mSize,&read);
00316
00317 dkcmNOT_ASSERT(read != t.mSize);
00318
00319
00320 p->mNowOffset = t.mNowOffset;
00321
00322 return p;
00323 }
|
|
|
dkcAllocNewStream()で確保したストリーム領域を開放する
dkcMemoryStream.c の 36 行で定義されています。 参照先 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 }
|
|
|
dkcMemoryStream.c の 388 行で定義されています。 参照先 DKC_MEMORYSTREAM_ADAPTER, と dkc_MemoryStreamAdapter::mNowOffset.
00388 {
00389 return p->mNowOffset;
00390 } |
|
||||||||||||||||
|
dkcMemoryStream.c の 338 行で定義されています。 参照先 BYTE, DKC_MEMORYSTREAM_ADAPTER, dkc_MemoryStreamAdapter::mBuff, dkc_MemoryStreamAdapter::mNowOffset, と dkc_MemoryStreamAdapter::mSize.
00339 {
00340 p->mBuff = buff;
00341 p->mSize = size;
00342 p->mNowOffset = 0;
00343
00344 }
|
|
|
dkcMemoryStream.c の 372 行で定義されています。 参照先 BYTE, DKC_MEMORYSTREAM_ADAPTER, と dkc_MemoryStreamAdapter::mBuff.
00372 {
00373 return p->mBuff;
00374 }
|
|
||||||||||||
|
dkcMemoryStream.c の 363 行で定義されています。 参照先 DKC_MEMORYSTREAM_ADAPTER, edk_FAILED, edk_SUCCEEDED, と dkc_MemoryStreamAdapter::mNowOffset.
00364 {
00365 if(size > p->mNowOffset){
00366 return edk_FAILED;
00367 }
00368 p->mNowOffset -= size;
00369 return edk_SUCCEEDED;
00370 }
|
|
||||||||||||||||
|
dkcMemoryStream.c の 346 行で定義されています。 参照先 BYTE, DKC_MEMORYSTREAM_ADAPTER, dkcCheckOverflowULONG(), edk_BufferOverFlow, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStreamAdapter::mBuff, dkc_MemoryStreamAdapter::mNowOffset, と dkc_MemoryStreamAdapter::mSize.
00347 {
00348 size_t offset = p->mNowOffset;
00349 BYTE *tb = p->mBuff;
00350 if(dkcCheckOverflowULONG(offset,size)){
00351 return edk_FAILED;
00352 }
00353 if(offset + size >= p->mSize){
00354 return edk_BufferOverFlow;
00355 }
00356 memcpy(&tb[offset],buff,size);
00357
00358 p->mNowOffset += size;
00359
00360 return edk_SUCCEEDED;
00361 }
|
|
||||||||||||
|
dkcMemoryStream.c の 381 行で定義されています。 参照先 DKC_MEMORYSTREAM_ADAPTER, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStreamAdapter::mNowOffset, と dkc_MemoryStreamAdapter::mSize.
00381 {
00382 if(offset > p->mSize){
00383 return edk_FAILED;
00384 }
00385 p->mNowOffset = offset;
00386 return edk_SUCCEEDED;
00387 }
|
|
|
dkcMemoryStream.c の 376 行で定義されています。 参照先 DKC_MEMORYSTREAM_ADAPTER, と dkc_MemoryStreamAdapter::mSize.
00376 {
00377 return p->mSize;
00378
00379 }
|
|
||||||||||||
|
dkcMemoryStream.c の 168 行で定義されています。 参照先 BYTE, DKC_MEMORYSTREAM, dkcReallocate(), dkcReallocateSizeFunction(), DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL. 参照元 dkcMemoryStreamDynamicWrite().
00168 {
00169 int ra_r = 0;
00170 void *NewPtr = NULL;
00171 void *OldPtr = NULL;
00172 size_t ReallocatedSize = 0;
00173 size_t want_size;
00174 //size_t want_size = ptr->mSize + expand_size + 1;//なんとなく+1
00175
00176 if(NULL==ptr) return edk_ArgumentException;
00177
00178 OldPtr = ptr->mBuffer;
00179 /*
00180 ra_r = dkcReallocateAutoExpand(realloc,&NewPtr,&OldPtr,ptr->mSize,&ReallocatedSize);
00181 if(DKUTIL_FAILED(ra_r)){
00182 return edk_FAILED;
00183 }
00184 if(want_size > ReallocatedSize){
00185 OldPtr = NewPtr;
00186 ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00187 if(DKUTIL_FAILED(ra_r)){
00188 return edk_FAILED;
00189 }
00190 ReallocatedSize = want_size;
00191 }
00192 */
00193 want_size = dkcReallocateSizeFunction(
00194 ptr->mSize + ptr->mNowOffset,
00195 (expand_size <= 256) ? 256 : expand_size
00196 );
00197 ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00198 if(DKUTIL_FAILED(ra_r)){
00199 return edk_FAILED;
00200 }
00201 ReallocatedSize = want_size;
00202
00203
00204
00205 ptr->mBuffer = (BYTE *)NewPtr;
00206 ptr->mSize = ReallocatedSize;
00207
00208
00209 return edk_SUCCEEDED;
00210
00211 }
|
|
|
stream内をmemset(0)する。(seek位置も最初に戻される。
dkcMemoryStream.c の 264 行で定義されています。 参照先 DKC_MEMORYSTREAM, dkcmNOT_ASSERT, edk_SUCCEEDED, と NULL. 参照元 dkcStreamClear(), と dkcStringCopy().
00264 {
00265 dkcmNOT_ASSERT(NULL==ptr);
00266 //if(NULL==ptr) return edk_ArgumentException;
00267 memset(ptr->mBuffer,0,ptr->mSize);
00268 ptr->mNowOffset = 0;
00269 return edk_SUCCEEDED;
00270 }
|
|
||||||||||||||||
|
streamをライトする。ライト出来なかったら内部で動的拡張する。
dkcMemoryStream.c の 238 行で定義されています。 参照先 DKC_MEMORYSTREAM, dkcMemoryStreamAutoExpandResize(), dkcMemoryStreamWrite(), DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL. 参照元 dkcSerializeWrite(), dkcStringConcatenate(), と dkcStringCopy().
00238 {
00239 int result;
00240 size_t want_size;
00241
00242 if(NULL==ptr) return edk_ArgumentException;
00243
00244 want_size = ptr->mNowOffset + size;
00245
00246 if(ptr->mSize < want_size)
00247 {
00248 result = dkcMemoryStreamAutoExpandResize(ptr,size);
00249 //result = dkcMemoryStreamResize(ptr,want_size);
00250 if(DKUTIL_FAILED(result)) return edk_FAILED;
00251 }
00252
00253 return dkcMemoryStreamWrite(ptr,buffer,size);
00254 }
|
|
|
streamのシークポイントを返す。
dkcMemoryStream.c の 92 行で定義されています。 参照先 DKC_MEMORYSTREAM, と dkc_MemoryStream::mNowOffset. 参照元 dkcStringInsert().
00093 {
00094 return ptr->mNowOffset;
00095 }
|
|
|
今、どこまで書きこんでいるかのサイズを取得
dkcMemoryStream.c の 272 行で定義されています。 参照先 DKC_EXTERN, DKC_MEMORYSTREAM, と dkc_MemoryStream::mNowOffset.
00272 {
00273 return p->mNowOffset;
00274 }
|
|
|
内部バッファへのポインタを取得
dkcMemoryStream.c の 276 行で定義されています。 参照先 BYTE, DKC_EXTERN, DKC_MEMORYSTREAM, と dkc_MemoryStream::mBuffer.
00276 {
00277 return p->mBuffer;
00278
00279 }
|
|
||||||||||||||||||||
|
streamをリードする。freadみたいなもの
dkcMemoryStream.c の 97 行で定義されています。 参照先 dkc_memcpy(), DKC_MEMORYSTREAM, DKUTIL_FAILED, 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 if(DKUTIL_FAILED(dkc_memcpy(buffer,size,ptr->mBuffer + ptr->mNowOffset,f_read)))
00126 {
00127 return edk_FAILED;
00128 }
00129
00130 //update...
00131 ptr->mNowOffset += f_read;
00132 *readsize = f_read;
00133
00134 return edk_SUCCEEDED;
00135 }
|
|
||||||||||||
|
streamのバッファを拡張する。
dkcMemoryStream.c の 138 行で定義されています。 参照先 BYTE, DKC_MEMORYSTREAM, dkcReallocate(), DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mSize, と NULL.
00139 {
00140 int ra_r = 0;
00141 void *NewPtr = NULL;
00142 void *OldPtr = NULL;
00143
00144 //error check
00145 if(NULL==ptr) return edk_ArgumentException;
00146
00147
00148 //process
00149 OldPtr = ptr->mBuffer;
00150
00151 ra_r = dkcReallocate(&NewPtr,want_size,&OldPtr);
00152 if(DKUTIL_FAILED(ra_r)){
00153 return edk_FAILED;
00154 }
00155
00156 //update...
00157 ptr->mBuffer = (BYTE *)NewPtr;
00158 ptr->mSize = want_size;
00159
00160
00161 return edk_SUCCEEDED;
00162 }
|
|
||||||||||||||||
|
streamをシークする。fseekみたいなもの
dkcMemoryStream.c の 71 行で定義されています。 参照先 DKC_MEMORYSTREAM, dkcMemoryStreamSeekLogic(), edk_ArgumentException, edk_FAILED, edkcMemoryStreamSeekCurrent, edkcMemoryStreamSeekEnd, edkcMemoryStreamSeekSet, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL. 参照元 dkcAllocMemoryStreamCopy(), 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 }
|
|
||||||||||||||||||||
|
dkcMemoryStream.c の 47 行で定義されています。 参照先 DKC_MEMORYSTREAM, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStream::mNowOffset, と dkc_MemoryStream::mSize.
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 }
|
|
||||||||||||
|
DKC_SERIALIZEにシリアライズデータをぶち込む.
dkcMemoryStream.c の 327 行で定義されています。 参照先 DKC_MEMORYSTREAM, DKC_SERIALIZE, dkcmNOT_ASSERT, dkcSerializeWrite(), と NULL. 参照元 dkcStringSerialize().
00328 {
00329 dkcmNOT_ASSERT(NULL==ptr);
00330
00331 dkcSerializeWrite(se,ptr,sizeof(*ptr));
00332 dkcSerializeWrite(se,ptr->mBuffer,ptr->mSize);
00333
00334 }
|
|
||||||||||||||||
|
streamをライトする。fwriteみたいなもの
dkcMemoryStream.c の 213 行で定義されています。 参照先 BYTE, dkc_memcpy(), DKC_MEMORYSTREAM, DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, dkc_MemoryStream::mBuffer, dkc_MemoryStream::mNowOffset, dkc_MemoryStream::mSize, と NULL. 参照元 dkcAllocMemoryStreamCopy(), dkcMemoryStreamDynamicWrite(), と dkcStreamWrite().
00213 {
00214 size_t rest;
00215
00216 if(NULL==ptr) return edk_ArgumentException;
00217
00218
00219 if(ptr->mSize < ptr->mNowOffset + size){return edk_FAILED;}
00220 rest = ptr->mSize - ptr->mNowOffset;
00221
00222 //酷バグ:dkcmNOT_ASSERTはDEBUGモード時にしか展開されない。
00223 /*dkcmNOT_ASSERT(
00224 ));*/
00225 if(DKUTIL_FAILED(dkc_memcpy(
00226 (void *)((BYTE *)ptr->mBuffer + ptr->mNowOffset),
00227 rest,
00228 buffer,size))){
00229 return edk_FAILED;
00230 }
00231
00232 ptr->mNowOffset += size;
00233
00234 return edk_SUCCEEDED;
00235 }
|
1.3.6