00001
00007 #define DKUTIL_C_SINGLE_LIST_C
00008 #include "dkcSingleList.h"
00009 #include "dkcStdio.h"
00010
00011
00012
00013 static int WINAPI dkcNewSingleList(DKC_SINGLELIST *ptr,const void *data,size_t size)
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 }
00035
00043 static int WINAPI dkcDeleteSingleList(DKC_SINGLELIST *ptr){
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 }
00054
00055
00056 DKC_SINGLELIST * WINAPI dkcAllocSingleList(const void *data,size_t size){
00057 DKC_SINGLELIST *p = NULL;
00058 p = (DKC_SINGLELIST *)dkcAllocate(sizeof(DKC_SINGLELIST));
00059
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 }
00068
00069
00070 int WINAPI dkcFreeSingleList(DKC_SINGLELIST **ptr){
00071 if(NULL==ptr) return edk_FAILED;
00072 if(DKUTIL_FAILED(dkcDeleteSingleList(*ptr))){
00073 return edk_FAILED;
00074 }
00075
00076 return edk_SUCCEEDED;
00077 }
00078
00079 void WINAPI dkcSingleListChain(DKC_SINGLELIST *ptr,DKC_SINGLELIST *nextp)
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 }
00099 int WINAPI dkcSingleListInsert(DKC_SINGLELIST *ptr,const void *data,size_t size){
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 }
00111
00112 DKC_SINGLELIST * WINAPI dkcSingleListErase(DKC_SINGLELIST *ptr){
00113 DKC_SINGLELIST *t = NULL;
00114 if(NULL==ptr) return NULL;
00115
00116
00117 dkcFree((void **)&ptr->mBuff);
00118 t = ptr->mNext;
00119 dkcFree((void **)&ptr);
00120 return t;
00121 }
00122
00123 int WINAPI dkcGetSingleListBuffer(DKC_SINGLELIST *ptr,void *data,size_t size){
00124 if(NULL==ptr) return edk_ArgumentException;
00125 if(NULL==ptr->mBuff) return edk_FAILED;
00126
00127 return dkc_memcpy(data,size,ptr->mBuff,ptr->mSize);
00128 }
00129
00130 DKC_BUFFER* WINAPI dkcAllocSingleListBuffer(const DKC_SINGLELIST *ptr)
00131 {
00132 DKC_BUFFER *p;
00133 if(NULL==ptr) return NULL;
00134 p = dkcAllocBuffer(ptr->mBuff,ptr->mSize);
00135 return p;
00136 }
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218 int WINAPI dkcSingleListGetBuffer(DKC_SINGLELIST *ptr,void *data,size_t size)
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 }
00225
00226 int WINAPI dkcSingleListSetBuffer(DKC_SINGLELIST *ptr,const void *data,size_t size)
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 }
00249 size_t WINAPI dkcSingleListSize(DKC_SINGLELIST *top)
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 }
00260
00261 static DKC_SINGLELIST *dkcSingleListTail(DKC_SINGLELIST *top){
00262 DKC_SINGLELIST *it = top;
00263 for(;;)
00264 {
00265 if(NULL == it->mNext) break;
00266 it = it->mNext;
00267
00268 }
00269 return it;
00270 }
00271
00272
00273
00274
00275 static DKC_SINGLELIST *dkcSLOBeginLogic(struct dkc_SingleListObject *p){
00276
00277 return p->mBegin;
00278 }
00279 static DKC_SINGLELIST *dkcSLOTailLogic(struct dkc_SingleListObject *p){
00280 return p->mTail;
00281 }
00282 static BOOL dkcSLOEndLogic(const DKC_SINGLELIST *p){
00283 return (NULL==p);
00284 }
00285 static DKC_SINGLELIST *dkcSLONextLogic(const DKC_SINGLELIST *p){
00286 return p->mNext;
00287 }
00288
00289 static BOOL dkcSLOPushBackLogic(struct dkc_SingleListObject *p,const void *data,size_t size)
00290 {
00291 BOOL result;
00292 result = DKUTIL_SUCCEEDED_BOOL(dkcSingleListInsert(p->mTail,data,size));
00293 if(TRUE==result){
00294 p->mTail = p->mTail->mNext;
00295 }
00296 return result;
00297 }
00298 static void dkcSLOEraseLogic(struct dkc_SingleListObject *p,DKC_SINGLELIST *prev,DKC_SINGLELIST *target)
00299 {
00300 if(p->mTail == p->mBegin){
00301 return;
00302 }else if(p->mTail == target){
00303 prev->mNext = dkcSingleListErase(target);
00304 p->mTail = prev;
00305 }else if(p->mBegin == target){
00306 prev->mNext = dkcSingleListErase(target);
00307 p->mBegin = prev->mNext;
00308 }else{
00309 prev->mNext = dkcSingleListErase(target);
00310 }
00311 }
00312 static BOOL dkcSLOEmptyLogic(struct dkc_SingleListObject *p){
00313 return (p->mBegin == p->mTail);
00314 }
00315
00316 DKC_SINGLELIST_OBJECT *WINAPI dkcAllocSingleListObject(const void *data,size_t size){
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 }
00350
00351 int WINAPI dkcFreeSingleListObject(DKC_SINGLELIST_OBJECT **p)
00352 {
00353 if(NULL==p || NULL==*p) return edk_ArgumentException;
00354 dkcFreeSingleList(&(*p)->mBegin);
00355 return dkcFree((void **)p);
00356 }
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418