メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

# dkcSingleList.c

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

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

ソースコードを見る。

## マクロ定義
#define | DKUTIL_C_SINGLE_LIST_C
## 関数
static int WINAPI | dkcNewSingleList (DKC_SINGLELIST *ptr, const void *data, size_t size)
static 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)
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)
static DKC_SINGLELIST * | dkcSingleListTail (DKC_SINGLELIST *top)
static DKC_SINGLELIST * | dkcSLOBeginLogic (struct dkc_SingleListObject *p)
static DKC_SINGLELIST * | dkcSLOTailLogic (struct dkc_SingleListObject *p)
static BOOL | dkcSLOEndLogic (const DKC_SINGLELIST *p)
static DKC_SINGLELIST * | dkcSLONextLogic (const DKC_SINGLELIST *p)
static BOOL | dkcSLOPushBackLogic (struct dkc_SingleListObject *p, const void *data, size_t size)
static void | dkcSLOEraseLogic (struct dkc_SingleListObject *p, DKC_SINGLELIST *prev, DKC_SINGLELIST *target)
static BOOL | dkcSLOEmptyLogic (struct dkc_SingleListObject *p)
DKC_SINGLELIST_OBJECT *WINAPI | dkcAllocSingleListObject (const void *data, size_t size)
int WINAPI | dkcFreeSingleListObject (DKC_SINGLELIST_OBJECT **p)

## 説明

作者:
  d金魚 @

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

## マクロ定義

#define DKUTIL_C_SINGLE_LIST_C

| dkcSingleList.c の 7 行で定義されています。

## 関数

DKC_SINGLELIST* WINAPI dkcAllocSingleList | ( | const void * | data,
|  | size_t | size
| ) |

| シングルリスト領域を得る。 dkcSingleList.c の 56 行で定義されています。 参照先 dkcAllocate(), dkcFree(), dkcNewSingleList(), と NULL. 参照元 dkcAllocSingleListObject(), と dkcSingleListInsert().
    00056                                                                         {
    00057     DKC_SINGLELIST *p = NULL;
    00058     p = (DKC_SINGLELIST *)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((void **)&p);
    00066     return NULL;
    00067 }

DKC_BUFFER* WINAPI dkcAllocSingleListBuffer | ( | const DKC_SINGLELIST * | ptr | ) |

| 戻り値: シングルリストの一つの要素が確保しているバッファの中のデータのコピーを返す。 dkcSingleList.c の 130 行で定義されています。 参照先 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_OBJECT* WINAPI dkcAllocSingleListObject | ( | const void * | data,
|  | size_t | size
| ) |

| dkcSingleList.c の 316 行で定義されています。 参照先 dkc_SingleListObject::begin, 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.
    00316                                                                                     {
    00317     DKC_SINGLELIST_OBJECT *p = NULL;
    00318
    00319     p = (DKC_SINGLELIST_OBJECT *)dkcAllocate(sizeof(DKC_SINGLELIST_OBJECT));
    00320     if(NULL==p) return NULL;
    00321
    00322
    00323     p->mBegin = dkcAllocSingleList(data,size);
    00324     if(NULL==p->mBegin) goto Error;
    00325     p->mTail = p->mBegin;
    00326
    00327
    00328     p->begin = dkcSLOBeginLogic;
    00329     p->tail = dkcSLOTailLogic;
    00330     p->end = dkcSLOEndLogic;
    00331     p->next = dkcSLONextLogic;
    00332
    00333     p->setbuffer = dkcSingleListSetBuffer;
    00334     p->getbuffer = dkcSingleListGetBuffer;
    00335     p->push_back = dkcSLOPushBackLogic;
    00336     p->erase = dkcSLOEraseLogic;
    00337
    00338     p->empty = dkcSLOEmptyLogic;
    00339
    00340
    00341
    00342     return p;
    00343 Error:
    00344     if(p){
    00345         dkcFreeSingleList(&p->mBegin);
    00346     }
    00347     dkcFree((void **)&p);
    00348     return NULL;
    00349 }

static int WINAPI dkcDeleteSingleList | ( | DKC_SINGLELIST * | ptr | ) | `[static]`

| DKC_SINGLELISTをデリート (リンクしてあるリストも削除します。 一つだけの要素を削除したい場合はdkcEraseSingleListを使ってください。） 覚え書き: 必ず使用したあとはこれを呼んでください。 dkcSingleList.c の 43 行で定義されています。 参照先 dkcSingleListErase(), 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.c の 70 行で定義されています。 参照先 dkcDeleteSingleList(), と NULL. 参照元 dkcAllocSingleListObject(), と dkcFreeSingleListObject().
    00070                                                   {
    00071     if(NULL==ptr) return edk_FAILED;
    00072     if(DKUTIL_FAILED(dkcDeleteSingleList(*ptr))){
    00073         return edk_FAILED;
    00074     }
    00075     //dkcFree((void **)*ptr);
    00076     return edk_SUCCEEDED;
    00077 }

int WINAPI dkcFreeSingleListObject | ( | DKC_SINGLELIST_OBJECT ** | p | ) |

| dkcSingleList.c の 351 行で定義されています。 参照先 dkcFree(), dkcFreeSingleList(), と NULL.
    00352 {
    00353     if(NULL==p || NULL==*p) return edk_ArgumentException;
    00354     dkcFreeSingleList(&(*p)->mBegin);
    00355     return dkcFree((void **)p);
    00356 }

int WINAPI dkcGetSingleListBuffer | ( | DKC_SINGLELIST * | ptr,
|  | void * | data,
|  | size_t | size
| ) |

| dkcSingleList.c の 123 行で定義されています。 参照先 dkc_memcpy(), 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 }

static int WINAPI dkcNewSingleList | ( | DKC_SINGLELIST * | ptr,
|  | const void * | data,
|  | size_t | size
| ) | `[static]`

| dkcSingleList.c の 13 行で定義されています。 参照先 BYTE, dkc_memcpy(), dkcAllocate(), 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 = (BYTE *)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.c の 79 行で定義されています。 参照先 dkcmNOT_ASSERT, dkc_SingleList::mNext, と NULL. 参照元 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.c の 112 行で定義されています。 参照先 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((void **)&ptr->mBuff);
    00118     t = ptr->mNext;
    00119     dkcFree((void **)&ptr);
    00120     return t;
    00121 }

int WINAPI dkcSingleListGetBuffer | ( | DKC_SINGLELIST * | ptr,
|  | void * | data,
|  | size_t | size
| ) |

| リスト構造体内に保存しているデータをもらう dkcSingleList.c の 218 行で定義されています。 参照先 dkc_memcpy(), dkc_SingleList::mBuff, dkc_SingleList::mSize, と NULL. 参照元 dkcAllocSingleListObject().
    00219 {
    00220     if(NULL==ptr || NULL==data || 0==size){
    00221         return edk_FAILED;
    00222     }
    00223     return dkc_memcpy(data,size,ptr->mBuff,ptr->mSize);
    00224 }

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.c の 99 行で定義されています。 参照先 dkcAllocSingleList(), dkcmNOT_ASSERT, dkcSingleListChain(), 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 }

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

| シングルリストの一つの要素が持っているバッファにデータを書き込む（上書きする） 足りないバッファサイズはリサイズされる。 dkcSingleList.c の 226 行で定義されています。 参照先 BYTE, dkc_memcpy(), dkcReallocate(), dkc_SingleList::mBuff, dkc_SingleList::mSize, と NULL. 参照元 dkcAllocSingleListObject().
    00227 {
    00228     void *NewPtr;
    00229
    00230     if(NULL==ptr || NULL==data || 0==size){
    00231         return edk_FAILED;
    00232     }
    00233
    00234     if(ptr->mSize < size){
    00235         if(DKUTIL_FAILED(dkcReallocate(&NewPtr,size,(void **)&(ptr->mBuff)))){
    00236             return edk_FAILED;
    00237         }
    00238
    00239         ptr->mBuff =(BYTE *) NewPtr;
    00240         ptr->mSize = size;
    00241     }
    00242
    00243     if(DKUTIL_FAILED(dkc_memcpy(ptr->mBuff,ptr->mSize,data,size))){
    00244         return edk_FAILED;
    00245     }
    00246
    00247     return edk_SUCCEEDED;
    00248 }

size_t WINAPI dkcSingleListSize | ( | DKC_SINGLELIST * | top | ) |

  | 引数:
  | top[in] | リストの先端
戻り値: リストのようその数 dkcSingleList.c の 249 行で定義されています。 参照先 dkc_SingleList::mNext, と NULL.
    00250 {
    00251     DKC_SINGLELIST *it = top;
    00252     size_t count = 0;
    00253     for(;it != NULL;)
    00254     {
    00255         count++;
    00256         it = it->mNext;
    00257     }
    00258     return count;
    00259 }

static DKC_SINGLELIST* dkcSingleListTail | ( | DKC_SINGLELIST * | top | ) | `[static]`

| dkcSingleList.c の 261 行で定義されています。 参照先 dkc_SingleList::mNext, と NULL.
    00261                                                              {
    00262     DKC_SINGLELIST *it = top;
    00263     for(;;)
    00264     {
    00265         if(NULL == it->mNext) break;
    00266         it = it->mNext;
    00267
    00268     }
    00269     return it;
    00270 }

static DKC_SINGLELIST* dkcSLOBeginLogic | ( | struct dkc_SingleListObject * | p | ) | `[static]`

| dkcSingleList.c の 275 行で定義されています。 参照先 dkc_SingleListObject::mBegin. 参照元 dkcAllocSingleListObject().
    00275                                                                        {
    00276     //return p->mBegin->mNext;//beginには何も入っていないから。
    00277     return p->mBegin;
    00278 }

static BOOL dkcSLOEmptyLogic | ( | struct dkc_SingleListObject * | p | ) | `[static]`

| dkcSingleList.c の 312 行で定義されています。 参照先 dkc_SingleListObject::mBegin, と dkc_SingleListObject::mTail. 参照元 dkcAllocSingleListObject().
    00312                                                             {
    00313     return (p->mBegin == p->mTail);
    00314 }

static BOOL dkcSLOEndLogic | ( | const DKC_SINGLELIST * | p | ) | `[static]`

| dkcSingleList.c の 282 行で定義されています。 参照先 NULL. 参照元 dkcAllocSingleListObject().
    00282                                                    {
    00283     return (NULL==p);
    00284 }

static void dkcSLOEraseLogic | ( | struct dkc_SingleListObject * | p,
|  | DKC_SINGLELIST * | prev,
|  | DKC_SINGLELIST * | target
| ) | `[static]`

| dkcSingleList.c の 298 行で定義されています。 参照先 dkcSingleListErase(), dkc_SingleListObject::mBegin, dkc_SingleList::mNext, と dkc_SingleListObject::mTail. 参照元 dkcAllocSingleListObject().
    00299 {
    00300     if(p->mTail == p->mBegin){
    00301         return;//何もない。
    00302     }else if(p->mTail == target){
    00303         prev->mNext = dkcSingleListErase(target);//多分NULLが返ってくる。
    00304         p->mTail = prev;//tail更新
    00305     }else if(p->mBegin == target){
    00306         prev->mNext = dkcSingleListErase(target);
    00307         p->mBegin = prev->mNext;//top 更新
    00308     }else{
    00309         prev->mNext = dkcSingleListErase(target);
    00310     }
    00311 }

static DKC_SINGLELIST* dkcSLONextLogic | ( | const DKC_SINGLELIST * | p | ) | `[static]`

| dkcSingleList.c の 285 行で定義されています。 参照先 dkc_SingleList::mNext. 参照元 dkcAllocSingleListObject().
    00285                                                                {
    00286     return p->mNext;
    00287 }

static BOOL dkcSLOPushBackLogic | ( | struct dkc_SingleListObject * | p,
|  | const void * | data,
|  | size_t | size
| ) | `[static]`

| dkcSingleList.c の 289 行で定義されています。 参照先 dkcSingleListInsert(), dkc_SingleList::mNext, dkc_SingleListObject::mTail, と TRUE. 参照元 dkcAllocSingleListObject().
    00290 {
    00291     BOOL result;
    00292     result = DKUTIL_SUCCEEDED_BOOL(dkcSingleListInsert(p->mTail,data,size));
    00293     if(TRUE==result){//成功だ！
    00294         p->mTail = p->mTail->mNext;//tail更新
    00295     }
    00296     return result;
    00297 }

static DKC_SINGLELIST* dkcSLOTailLogic | ( | struct dkc_SingleListObject * | p | ) | `[static]`

| dkcSingleList.c の 279 行で定義されています。 参照先 dkc_SingleListObject::mTail. 参照元 dkcAllocSingleListObject().
    00279                                                                       {
    00280     return p->mTail;
    00281 }