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

dkcSingleList.c

#include "dkcSingleList.h"
#include "dkcStdio.h"

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

Include dependency graph

ソースコードを見る。

関数

int WINAPI dkcNewSingleList (DKC_SINGLELIST *ptr, const void *data, size_t size)
int WINAPI dkcDeleteSingleList (DKC_SINGLELIST *ptr)
DKC_SINGLELIST *WINAPI dkcAllocSingleList (const void *data, size_t size)
 シングルリスト領域を得る。

int WINAPI dkcFreeSingleList (DKC_SINGLELIST **ptr)
 dkcAllocNewSingleList()で確保したリスト領域と内部バッファを削除。dkcAllocNewSingleListと対。

void WINAPI dkcSingleListChain (DKC_SINGLELIST *ptr, DKC_SINGLELIST *nextp)
int WINAPI dkcSingleListInsert (DKC_SINGLELIST *ptr, const void *data, size_t size)
DKC_SINGLELIST *WINAPI dkcSingleListErase (DKC_SINGLELIST *ptr)
int WINAPI dkcGetSingleListBuffer (DKC_SINGLELIST *ptr, void *data, size_t size)
DKC_BUFFER *WINAPI dkcAllocSingleListBuffer (const DKC_SINGLELIST *ptr)
DKC_SINGLELIST *WINAPI dkcAllocSingleListDeserialize (DKC_DESERIALIZE *se)
 DKC_SERIALIZEから新しいSingleListを作る。.

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

int WINAPI dkcSingleListGetBuffer (DKC_SINGLELIST *ptr, void *data, size_t size)
int WINAPI dkcSingleListSetBuffer (DKC_SINGLELIST *ptr, const void *data, size_t size)
size_t WINAPI dkcSingleListSize (DKC_SINGLELIST *top)
DKC_SINGLELISTdkcSingleListTail (DKC_SINGLELIST *top)
DKC_SINGLELISTdkcSLOBeginLogic (struct dkc_SingleListObject *p)
DKC_SINGLELISTdkcSLOTailLogic (struct dkc_SingleListObject *p)
BOOL dkcSLOEndLogic (const DKC_SINGLELIST *p)
DKC_SINGLELISTdkcSLONextLogic (const DKC_SINGLELIST *p)
BOOL dkcSLOPushBackLogic (struct dkc_SingleListObject *p, const void *data, size_t size)
void dkcSLOEraseLogic (struct dkc_SingleListObject *p, DKC_SINGLELIST *prev, DKC_SINGLELIST *target)
BOOL dkcSLOEmptyLogic (struct dkc_SingleListObject *p)
DKC_SINGLELIST_OBJECT *WINAPI dkcAllocSingleListObject (const void *data, size_t size)
int WINAPI dkcFreeSingleListObject (DKC_SINGLELIST_OBJECT **p)
DKC_SINGLELIST_OBJECT *WINAPI dkcAllocSingleListObjectDeserialize (DKC_DESERIALIZE *se)
void WINAPI dkcSingleListObjectSerialize (const DKC_SINGLELIST_OBJECT *ptr, DKC_SERIALIZE *se)


説明

d金魚 @

dkcSingleList.c で定義されています。


関数

DKC_SINGLELIST* WINAPI dkcAllocSingleList const void *  data,
size_t  size
 

シングルリスト領域を得る。

dkcSingleList.c56 行で定義されています。

参照先 DKC_SINGLELIST, dkcAllocate(), dkcFree(), dkcNewSingleList(), DKUTIL_FAILED, と NULL.

参照元 dkcAllocSingleListDeserialize(), dkcAllocSingleListObject(), と dkcSingleListInsert().

00056                                                                         {
00057     DKC_SINGLELIST *p = NULL;
00058     p = dkcAllocate(sizeof(DKC_SINGLELIST));
00059     //p dkcAllocate(size);
00060     if(DKUTIL_FAILED(dkcNewSingleList(p,data,size))){
00061         goto Error;
00062     }
00063     return p;
00064 Error:
00065     dkcFree(&p);
00066     return NULL;
00067 }

DKC_BUFFER* WINAPI dkcAllocSingleListBuffer const DKC_SINGLELIST ptr  ) 
 

戻り値:
シングルリストの一つの要素が確保しているバッファの中のデータのコピーを返す。

dkcSingleList.c130 行で定義されています。

参照先 DKC_BUFFER, DKC_SINGLELIST, dkcAllocBuffer(), dkc_SingleList::mBuff, dkc_SingleList::mSize, と NULL.

00131 {
00132     DKC_BUFFER *p;
00133     if(NULL==ptr) return NULL;
00134     p = dkcAllocBuffer(ptr->mBuff,ptr->mSize);
00135     return p;
00136 }

DKC_SINGLELIST* WINAPI dkcAllocSingleListDeserialize DKC_DESERIALIZE se  ) 
 

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

dkcSingleList.c140 行で定義されています。

参照先 DKC_DESERIALIZE, DKC_SINGLELIST, dkcAllocSingleList(), dkcDeserializeRead(), dkcmNOT_ASSERT, dkcSingleListChain(), DKUTIL_MEMZERO, edkcSerializeIDSingleList, dkc_SingleList::mBuff, dkc_SingleList::mSize, と NULL.

参照元 dkcAllocSingleListObjectDeserialize().

00141 {
00142     DKC_SINGLELIST *p,*tp,*beginp;
00143     DKC_SINGLELIST t;
00144     size_t read,c,i;
00145     UINT sig;
00146 
00147     dkcmNOT_ASSERT(NULL==se);
00148     DKUTIL_MEMZERO(&t,sizeof(t));
00149     //シグネチャを取得
00150     dkcDeserializeRead(se,&sig,sizeof(sig),&read);
00151     //そんな馬鹿な!判定
00152     if(read != sizeof(sig) || edkcSerializeIDSingleList != sig)
00153     {
00154         return NULL;
00155     }
00156     //数を取得
00157     dkcDeserializeRead(se,&c,sizeof(c),&read);
00158     
00159     //構造体を取得。
00160     dkcDeserializeRead(se,&t,sizeof(DKC_SINGLELIST),&read);
00161     p = dkcAllocSingleList(NULL,t.mSize);
00162     //バッファ領域を取得。
00163     dkcDeserializeRead(se,p->mBuff,p->mSize,&read);
00164     
00165     beginp = p;
00166     for(i=0;i<c;i++)
00167     {
00168         //構造体を取得。
00169         dkcDeserializeRead(se,&t,sizeof(DKC_SINGLELIST),&read);
00170         //保存。
00171         tp = p;
00172         //リスト生成
00173         p = dkcAllocSingleList(NULL,t.mSize);
00174         //バッファ領域を取得。
00175         dkcDeserializeRead(se,p->mBuff,p->mSize,&read);
00176         //チェイン
00177         dkcSingleListChain(tp,p);
00178         
00179     }
00180     return beginp;
00181 }

DKC_SINGLELIST_OBJECT* WINAPI dkcAllocSingleListObject const void *  data,
size_t  size
 

dkcSingleList.c315 行で定義されています。

参照先 dkc_SingleListObject::begin, DKC_SINGLELIST_OBJECT, dkcAllocate(), dkcAllocSingleList(), dkcFree(), dkcFreeSingleList(), dkcSingleListGetBuffer(), dkcSingleListSetBuffer(), dkcSLOBeginLogic(), dkcSLOEmptyLogic(), dkcSLOEndLogic(), dkcSLOEraseLogic(), dkcSLONextLogic(), dkcSLOPushBackLogic(), dkcSLOTailLogic(), dkc_SingleListObject::empty, dkc_SingleListObject::end, dkc_SingleListObject::erase, dkc_SingleListObject::mBegin, dkc_SingleListObject::mTail, dkc_SingleListObject::next, NULL, dkc_SingleListObject::push_back, と dkc_SingleListObject::tail.

参照元 dkcAllocSingleListObjectDeserialize().

00315                                                                                     {
00316     DKC_SINGLELIST_OBJECT *p = NULL;
00317 
00318     p = dkcAllocate(sizeof(DKC_SINGLELIST_OBJECT));
00319     if(NULL==p) return NULL;
00320     
00321 
00322     p->mBegin = dkcAllocSingleList(data,size);
00323     if(NULL==p->mBegin) goto Error;
00324     p->mTail = p->mBegin;
00325 
00326 
00327     p->begin = dkcSLOBeginLogic;
00328     p->tail = dkcSLOTailLogic;
00329     p->end = dkcSLOEndLogic;
00330     p->next = dkcSLONextLogic;
00331     
00332     p->setbuffer = dkcSingleListSetBuffer;
00333     p->getbuffer = dkcSingleListGetBuffer;
00334     p->push_back = dkcSLOPushBackLogic;
00335     p->erase = dkcSLOEraseLogic;
00336 
00337     p->empty = dkcSLOEmptyLogic;
00338 
00339     
00340 
00341     return p;
00342 Error:
00343     if(p){
00344         dkcFreeSingleList(&p->mBegin);
00345     }
00346     dkcFree(&p);
00347     return NULL;
00348 }

DKC_SINGLELIST_OBJECT* WINAPI dkcAllocSingleListObjectDeserialize DKC_DESERIALIZE se  ) 
 

dkcSingleList.c357 行で定義されています。

参照先 DKC_DESERIALIZE, DKC_SINGLELIST, DKC_SINGLELIST_OBJECT, dkcAllocSingleListDeserialize(), dkcAllocSingleListObject(), dkcDeserializeRead(), dkcFreeSingleList(), dkcmNOT_ASSERT, dkcSingleListTail(), edkcSerializeIDSingleListObject, と NULL.

00358 {
00359     int sig;
00360     size_t read;
00361     DKC_SINGLELIST_OBJECT t,*plistobj;
00362     DKC_SINGLELIST *li;
00363 
00364     //シグネチャを取得
00365     dkcDeserializeRead(se,&sig,sizeof(sig),&read);
00366     //そんな馬鹿な!判定
00367     if(read != sizeof(sig) || edkcSerializeIDSingleListObject != sig)
00368     {
00369         return NULL;
00370     }
00371     //objectを取得
00372     dkcDeserializeRead(se,&t,sizeof(t),&read);
00373     
00374     if(read != sizeof(t)){//なぜ、もう読み込めないのだ!
00375         return NULL;
00376     }
00377     //single listを復元ナリ
00378     li = dkcAllocSingleListDeserialize(se);
00379     if(li == NULL) return NULL;
00380 
00381     //objectをAlloc
00382     plistobj = dkcAllocSingleListObject(NULL,0);
00383 #   ifdef DEBUG
00384     dkcmNOT_ASSERT(NULL== plistobj);
00385 #   endif
00386     if(NULL == plistobj) goto Error;
00387 
00388     //内部のリストは解放しておく^^;結構強引な処理
00389     dkcFreeSingleList(&plistobj->mBegin);
00390 
00391     plistobj->mBegin = li;
00392     plistobj->mTail = dkcSingleListTail(li);
00393 
00394     //多分、これでOK!?
00395     return plistobj;
00396 Error:
00397     dkcFreeSingleList(&li);
00398     return NULL;
00399 }

int WINAPI dkcDeleteSingleList DKC_SINGLELIST ptr  )  [static]
 

DKC_SINGLELISTをデリート (リンクしてあるリストも削除します。 一つだけの要素を削除したい場合はdkcEraseSingleListを使ってください。)

覚え書き:
必ず使用したあとはこれを呼んでください。

dkcSingleList.c43 行で定義されています。

参照先 DKC_SINGLELIST, dkcSingleListErase(), edk_ArgumentException, edk_SUCCEEDED, dkc_SingleList::mBuff, と NULL.

参照元 dkcFreeSingleList().

00043                                                           {
00044     DKC_SINGLELIST *p = NULL;
00045     if(NULL==ptr) return edk_ArgumentException;
00046     if(NULL==ptr->mBuff) return edk_ArgumentException;
00047     
00048     for(p = ptr;;){
00049         p = dkcSingleListErase(p);
00050         if(p==NULL) break;
00051     }
00052     return edk_SUCCEEDED;
00053 }

int WINAPI dkcFreeSingleList DKC_SINGLELIST **  ptr  ) 
 

dkcAllocNewSingleList()で確保したリスト領域と内部バッファを削除。dkcAllocNewSingleListと対。

DKC_SINGLELISTをデリート (リンクしてあるリストも削除します。 一つだけの要素を削除したい場合はdkcEraseSingleListを使ってください。)

覚え書き:
必ず使用したあとはこれを呼んでください。

dkcSingleList.c70 行で定義されています。

参照先 DKC_SINGLELIST, dkcDeleteSingleList(), DKUTIL_FAILED, edk_FAILED, edk_SUCCEEDED, と NULL.

参照元 dkcAllocSingleListObject(), dkcAllocSingleListObjectDeserialize(), と dkcFreeSingleListObject().

00070                                                   {
00071     if(NULL==ptr) return edk_FAILED;
00072     if(DKUTIL_FAILED(dkcDeleteSingleList(*ptr))){
00073         return edk_FAILED;
00074     }
00075     //dkcFree(*ptr);
00076     return edk_SUCCEEDED;
00077 }

int WINAPI dkcFreeSingleListObject DKC_SINGLELIST_OBJECT **  p  ) 
 

dkcSingleList.c350 行で定義されています。

参照先 DKC_SINGLELIST_OBJECT, dkcFree(), dkcFreeSingleList(), edk_ArgumentException, と NULL.

00351 {
00352     if(NULL==p || NULL==*p) return edk_ArgumentException;
00353     dkcFreeSingleList(&(*p)->mBegin);
00354     return dkcFree(p);
00355 }

int WINAPI dkcGetSingleListBuffer DKC_SINGLELIST ptr,
void *  data,
size_t  size
 

dkcSingleList.c123 行で定義されています。

参照先 dkc_memcpy(), DKC_SINGLELIST, edk_ArgumentException, edk_FAILED, dkc_SingleList::mBuff, dkc_SingleList::mSize, と NULL.

00123                                                                              {
00124     if(NULL==ptr) return edk_ArgumentException;
00125     if(NULL==ptr->mBuff) return edk_FAILED;
00126     //if(ptr->mSize < size) return edk_BufferOverFlow;
00127     return dkc_memcpy(data,size,ptr->mBuff,ptr->mSize);
00128 }

int WINAPI dkcNewSingleList DKC_SINGLELIST ptr,
const void *  data,
size_t  size
[static]
 

dkcSingleList.c13 行で定義されています。

参照先 dkc_memcpy(), DKC_SINGLELIST, dkcAllocate(), DKUTIL_FAILED, edk_ArgumentException, edk_FAILED, edk_OutOfMemory, edk_SUCCEEDED, dkc_SingleList::mBuff, dkc_SingleList::mNext, dkc_SingleList::mSize, と NULL.

参照元 dkcAllocSingleList().

00014 {
00015     void *p = NULL;
00016     if(NULL==ptr) return edk_ArgumentException;
00017     if(ptr->mBuff) return edk_ArgumentException;
00018     if(ptr->mNext) return edk_FAILED;
00019 
00020     p = dkcAllocate(size);
00021     if(NULL==p) return edk_OutOfMemory;
00022     
00023     if(NULL != data && 0 != size){
00024         if(DKUTIL_FAILED(dkc_memcpy(p,size,data,size))){
00025             return edk_FAILED;
00026         }
00027     }
00028 
00029     ptr->mBuff = p;
00030     ptr->mSize = size;
00031     ptr->mNext = NULL;
00032 
00033     return edk_SUCCEEDED;
00034 }

void WINAPI dkcSingleListChain DKC_SINGLELIST ptr,
DKC_SINGLELIST nextp
 

dkcSingleList.c79 行で定義されています。

参照先 DKC_SINGLELIST, dkcmNOT_ASSERT, dkc_SingleList::mNext, と NULL.

参照元 dkcAllocSingleListDeserialize(), と dkcSingleListInsert().

00080 {
00081     DKC_SINGLELIST *t=NULL;
00082 
00083     //バカヤロー条件
00084     dkcmNOT_ASSERT(NULL==ptr || NULL==nextp);
00085 
00086     if(ptr->mNext)
00087     {//次へのポインタがあった場合
00088         t = ptr->mNext;//保存。
00089         ptr->mNext = nextp;//ぶち込む。
00090         nextp->mNext = t;//保存していたのをぶち込む
00091 
00092     }else
00093     {//次へのポインタがなかった場合。
00094         ptr->mNext = nextp;//すぐぶち込む。
00095     }
00096 
00097 
00098 }

DKC_SINGLELIST* WINAPI dkcSingleListErase DKC_SINGLELIST ptr  ) 
 

引数:
ptr[in] 削除したい要素へのポインタ
戻り値:
削除した要素に次への要素を指しているポインタがあった場合、そのポインタを返す。 NULLの場合は、次への要素を指しているポインタは無かった。

dkcSingleList.c112 行で定義されています。

参照先 DKC_SINGLELIST, dkcFree(), dkc_SingleList::mBuff, dkc_SingleList::mNext, と NULL.

参照元 dkcDeleteSingleList(), と dkcSLOEraseLogic().

00112                                                                {
00113     DKC_SINGLELIST *t = NULL;
00114     if(NULL==ptr) return NULL;
00115     //if(NULL==ptr->mBuff) return NULL;//メモリリークの原因になるかも?
00116     
00117     dkcFree(&ptr->mBuff);
00118     t = ptr->mNext;
00119     dkcFree(&ptr);
00120     return t;
00121 }

int WINAPI dkcSingleListGetBuffer DKC_SINGLELIST ptr,
void *  data,
size_t  size
 

リスト構造体内に保存しているデータをもらう

dkcSingleList.c217 行で定義されています。

参照先 dkc_memcpy(), DKC_SINGLELIST, edk_FAILED, dkc_SingleList::mBuff, dkc_SingleList::mSize, と NULL.

参照元 dkcAllocSingleListObject().

00218 {
00219     if(NULL==ptr || NULL==data || 0==size){
00220         return edk_FAILED;
00221     }
00222     return dkc_memcpy(data,size,ptr->mBuff,ptr->mSize);
00223 }

int WINAPI dkcSingleListInsert DKC_SINGLELIST ptr,
const void *  data,
size_t  size
 

覚え書き:
ptrの次に新しいデータを挿入する。 新しいデータの次にptrの次へのデータが挿入される。 図: 1: ptr->next1->next2; 2: ptr->new data->next1->next2;

dkcSingleList.c99 行で定義されています。

参照先 DKC_SINGLELIST, dkcAllocSingleList(), dkcmNOT_ASSERT, dkcSingleListChain(), edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, dkc_SingleList::mNext, と NULL.

参照元 dkcSLOPushBackLogic().

00099                                                                                 {
00100     DKC_SINGLELIST *p;
00101     if(NULL==ptr) return edk_ArgumentException;
00102     
00103     p = dkcAllocSingleList(data,size);
00104     if(NULL==p) return edk_FAILED;
00105     dkcmNOT_ASSERT(p->mNext);//念のため。
00106     
00107     dkcSingleListChain(ptr,p);
00108 
00109     return edk_SUCCEEDED;
00110 }

void WINAPI dkcSingleListObjectSerialize const DKC_SINGLELIST_OBJECT ptr,
DKC_SERIALIZE se
 

dkcSingleList.c403 行で定義されています。

参照先 DKC_SERIALIZE, DKC_SINGLELIST_OBJECT, dkcSerializeWrite(), dkcSingleListSerialize(), edkcSerializeIDSingleListObject, と dkc_SingleListObject::mBegin.

00404 {
00405     int sig;
00406 
00407     sig = edkcSerializeIDSingleListObject;
00408     //シグネチャ保存
00409     dkcSerializeWrite(se,&sig,sizeof(sig));
00410     //objectを保存
00411     dkcSerializeWrite(se,ptr,sizeof(DKC_SINGLELIST_OBJECT));
00412 
00413     //シングルリストをシリアライズ
00414     dkcSingleListSerialize(ptr->mBegin,se);
00415 }

void WINAPI dkcSingleListSerialize const DKC_SINGLELIST ptr,
DKC_SERIALIZE se
 

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

dkcSingleList.c184 行で定義されています。

参照先 DKC_SERIALIZE, DKC_SINGLELIST, dkcmNOT_ASSERT, dkcSerializeWrite(), edkcSerializeIDSingleList, dkc_SingleList::mBuff, dkc_SingleList::mNext, dkc_SingleList::mSize, と NULL.

参照元 dkcSingleListObjectSerialize().

00185 {
00186     DKC_SINGLELIST *tp = (DKC_SINGLELIST *)ptr;
00187     size_t c; //counter
00188     UINT sig;//signature
00189     //size_t i; //for counter
00190     dkcmNOT_ASSERT(NULL==ptr);
00191     
00192     sig = edkcSerializeIDSingleList;
00193     //シグネチャを保存
00194     dkcSerializeWrite(se,&sig,sizeof(sig));
00195 
00196     for(c=0;;c++)//c=0はSerialize,Deserialize統一しないと行けない。
00197     {//liner count... very slow...
00198         if(NULL == tp->mNext) break;
00199         tp = tp->mNext;
00200     }
00201     //数を入れる。
00202     dkcSerializeWrite(se,&c,sizeof(c));
00203     
00204     tp = (DKC_SINGLELIST *)ptr;
00205     for(;;){
00206         //構造体を入れる。
00207         dkcSerializeWrite(se,tp,sizeof(DKC_SINGLELIST));
00208         //バッファ領域を入れる。
00209         dkcSerializeWrite(se,tp->mBuff,tp->mSize);
00210         if(NULL == tp->mNext){
00211             break;
00212         }
00213         tp = tp->mNext;//次へのポインタ
00214     }
00215 
00216 }

int WINAPI dkcSingleListSetBuffer DKC_SINGLELIST ptr,
const void *  data,
size_t  size
 

シングルリストの一つの要素が持っているバッファにデータを書き込む(上書きする) 足りないバッファサイズはリサイズされる。

dkcSingleList.c225 行で定義されています。

参照先 dkc_memcpy(), DKC_SINGLELIST, dkcReallocate(), DKUTIL_FAILED, edk_FAILED, edk_SUCCEEDED, dkc_SingleList::mBuff, dkc_SingleList::mSize, と NULL.

参照元 dkcAllocSingleListObject().

00226 {
00227     void *NewPtr;
00228 
00229     if(NULL==ptr || NULL==data || 0==size){
00230         return edk_FAILED;
00231     }
00232 
00233     if(ptr->mSize < size){
00234         if(DKUTIL_FAILED(dkcReallocate(&NewPtr,size,&(ptr->mBuff)))){
00235             return edk_FAILED;
00236         }
00237 
00238         ptr->mBuff = NewPtr;
00239         ptr->mSize = size;
00240     }
00241 
00242     if(DKUTIL_FAILED(dkc_memcpy(ptr->mBuff,ptr->mSize,data,size))){
00243         return edk_FAILED;
00244     }
00245 
00246     return edk_SUCCEEDED;
00247 }

size_t WINAPI dkcSingleListSize DKC_SINGLELIST top  ) 
 

引数:
top[in] リストの先端
戻り値:
リストのようその数

dkcSingleList.c248 行で定義されています。

参照先 DKC_SINGLELIST, dkc_SingleList::mNext, と NULL.

00249 {
00250     DKC_SINGLELIST *it = top;
00251     size_t count = 0;
00252     for(;it != NULL;)
00253     {
00254         count++;
00255         it = it->mNext;
00256     }
00257     return count;
00258 }

DKC_SINGLELIST* dkcSingleListTail DKC_SINGLELIST top  )  [static]
 

dkcSingleList.c260 行で定義されています。

参照先 DKC_SINGLELIST, dkc_SingleList::mNext, と NULL.

参照元 dkcAllocSingleListObjectDeserialize().

00260                                                              {
00261     DKC_SINGLELIST *it = top;
00262     for(;;)
00263     {
00264         if(NULL == it->mNext) break;
00265         it = it->mNext;
00266         
00267     }
00268     return it;
00269 }

DKC_SINGLELIST* dkcSLOBeginLogic struct dkc_SingleListObject p  )  [static]
 

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

参照先 DKC_SINGLELIST, と dkc_SingleListObject::mBegin.

参照元 dkcAllocSingleListObject().

00274                                                                        {
00275     //return p->mBegin->mNext;//beginには何も入っていないから。
00276     return p->mBegin;
00277 }

BOOL dkcSLOEmptyLogic struct dkc_SingleListObject p  )  [static]
 

dkcSingleList.c311 行で定義されています。

参照先 BOOL, dkc_SingleListObject::mBegin, と dkc_SingleListObject::mTail.

参照元 dkcAllocSingleListObject().

00311                                                             {
00312     return (p->mBegin == p->mTail);
00313 }

BOOL dkcSLOEndLogic const DKC_SINGLELIST p  )  [static]
 

dkcSingleList.c281 行で定義されています。

参照先 BOOL, DKC_SINGLELIST, と NULL.

参照元 dkcAllocSingleListObject().

00281                                                    {
00282     return (NULL==p);
00283 }

void dkcSLOEraseLogic struct dkc_SingleListObject p,
DKC_SINGLELIST prev,
DKC_SINGLELIST target
[static]
 

dkcSingleList.c297 行で定義されています。

参照先 DKC_SINGLELIST, dkcSingleListErase(), dkc_SingleListObject::mBegin, dkc_SingleList::mNext, と dkc_SingleListObject::mTail.

参照元 dkcAllocSingleListObject().

00298 {
00299     if(p->mTail == p->mBegin){
00300         return;//何もない。
00301     }else if(p->mTail == target){
00302         prev->mNext = dkcSingleListErase(target);//多分NULLが返ってくる。
00303         p->mTail = prev;//tail更新
00304     }else if(p->mBegin == target){
00305         prev->mNext = dkcSingleListErase(target);
00306         p->mBegin = prev->mNext;//top 更新
00307     }else{
00308         prev->mNext = dkcSingleListErase(target);
00309     }
00310 }

DKC_SINGLELIST* dkcSLONextLogic const DKC_SINGLELIST p  )  [static]
 

dkcSingleList.c284 行で定義されています。

参照先 DKC_SINGLELIST, と dkc_SingleList::mNext.

参照元 dkcAllocSingleListObject().

00284                                                                {
00285     return p->mNext;
00286 }

BOOL dkcSLOPushBackLogic struct dkc_SingleListObject p,
const void *  data,
size_t  size
[static]
 

dkcSingleList.c288 行で定義されています。

参照先 BOOL, dkcSingleListInsert(), DKUTIL_SUCCEEDED_BOOL, dkc_SingleList::mNext, dkc_SingleListObject::mTail, と TRUE.

参照元 dkcAllocSingleListObject().

00289 {
00290     BOOL result;
00291     result = DKUTIL_SUCCEEDED_BOOL(dkcSingleListInsert(p->mTail,data,size));
00292     if(TRUE==result){//成功だ!
00293         p->mTail = p->mTail->mNext;//tail更新
00294     }
00295     return result;
00296 }

DKC_SINGLELIST* dkcSLOTailLogic struct dkc_SingleListObject p  )  [static]
 

dkcSingleList.c278 行で定義されています。

参照先 DKC_SINGLELIST, と dkc_SingleListObject::mTail.

参照元 dkcAllocSingleListObject().

00278                                                                       {
00279     return p->mTail;
00280 }


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