00001
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 = 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 = dkcAllocate(sizeof(DKC_SINGLELIST));
00059
00060 if(DKUTIL_FAILED(dkcNewSingleList(p,data,size))){
00061 goto Error;
00062 }
00063 return p;
00064 Error:
00065 dkcFree(&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(&ptr->mBuff);
00118 t = ptr->mNext;
00119 dkcFree(&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 DKC_SINGLELIST * WINAPI dkcAllocSingleListDeserialize(DKC_DESERIALIZE *se)
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 }
00182
00183
00184 void WINAPI dkcSingleListSerialize(const DKC_SINGLELIST *ptr,DKC_SERIALIZE *se)
00185 {
00186 DKC_SINGLELIST *tp = (DKC_SINGLELIST *)ptr;
00187 size_t c;
00188 UINT sig;
00189
00190 dkcmNOT_ASSERT(NULL==ptr);
00191
00192 sig = edkcSerializeIDSingleList;
00193
00194 dkcSerializeWrite(se,&sig,sizeof(sig));
00195
00196 for(c=0;;c++)
00197 {
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 }
00217 int WINAPI dkcSingleListGetBuffer(DKC_SINGLELIST *ptr,void *data,size_t size)
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 }
00224
00225 int WINAPI dkcSingleListSetBuffer(DKC_SINGLELIST *ptr,const void *data,size_t size)
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 }
00248 size_t WINAPI dkcSingleListSize(DKC_SINGLELIST *top)
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 }
00259
00260 static DKC_SINGLELIST *dkcSingleListTail(DKC_SINGLELIST *top){
00261 DKC_SINGLELIST *it = top;
00262 for(;;)
00263 {
00264 if(NULL == it->mNext) break;
00265 it = it->mNext;
00266
00267 }
00268 return it;
00269 }
00270
00271
00272
00273
00274 static DKC_SINGLELIST *dkcSLOBeginLogic(struct dkc_SingleListObject *p){
00275
00276 return p->mBegin;
00277 }
00278 static DKC_SINGLELIST *dkcSLOTailLogic(struct dkc_SingleListObject *p){
00279 return p->mTail;
00280 }
00281 static BOOL dkcSLOEndLogic(const DKC_SINGLELIST *p){
00282 return (NULL==p);
00283 }
00284 static DKC_SINGLELIST *dkcSLONextLogic(const DKC_SINGLELIST *p){
00285 return p->mNext;
00286 }
00287
00288 static BOOL dkcSLOPushBackLogic(struct dkc_SingleListObject *p,const void *data,size_t size)
00289 {
00290 BOOL result;
00291 result = DKUTIL_SUCCEEDED_BOOL(dkcSingleListInsert(p->mTail,data,size));
00292 if(TRUE==result){
00293 p->mTail = p->mTail->mNext;
00294 }
00295 return result;
00296 }
00297 static void dkcSLOEraseLogic(struct dkc_SingleListObject *p,DKC_SINGLELIST *prev,DKC_SINGLELIST *target)
00298 {
00299 if(p->mTail == p->mBegin){
00300 return;
00301 }else if(p->mTail == target){
00302 prev->mNext = dkcSingleListErase(target);
00303 p->mTail = prev;
00304 }else if(p->mBegin == target){
00305 prev->mNext = dkcSingleListErase(target);
00306 p->mBegin = prev->mNext;
00307 }else{
00308 prev->mNext = dkcSingleListErase(target);
00309 }
00310 }
00311 static BOOL dkcSLOEmptyLogic(struct dkc_SingleListObject *p){
00312 return (p->mBegin == p->mTail);
00313 }
00314
00315 DKC_SINGLELIST_OBJECT *WINAPI dkcAllocSingleListObject(const void *data,size_t size){
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 }
00349
00350 int WINAPI dkcFreeSingleListObject(DKC_SINGLELIST_OBJECT **p)
00351 {
00352 if(NULL==p || NULL==*p) return edk_ArgumentException;
00353 dkcFreeSingleList(&(*p)->mBegin);
00354 return dkcFree(p);
00355 }
00356
00357 DKC_SINGLELIST_OBJECT * WINAPI dkcAllocSingleListObjectDeserialize(DKC_DESERIALIZE *se)
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
00372 dkcDeserializeRead(se,&t,sizeof(t),&read);
00373
00374 if(read != sizeof(t)){
00375 return NULL;
00376 }
00377
00378 li = dkcAllocSingleListDeserialize(se);
00379 if(li == NULL) return NULL;
00380
00381
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
00395 return plistobj;
00396 Error:
00397 dkcFreeSingleList(&li);
00398 return NULL;
00399 }
00400
00401
00402
00403 void WINAPI dkcSingleListObjectSerialize(const DKC_SINGLELIST_OBJECT *ptr,DKC_SERIALIZE *se)
00404 {
00405 int sig;
00406
00407 sig = edkcSerializeIDSingleListObject;
00408
00409 dkcSerializeWrite(se,&sig,sizeof(sig));
00410
00411 dkcSerializeWrite(se,ptr,sizeof(DKC_SINGLELIST_OBJECT));
00412
00413
00414 dkcSingleListSerialize(ptr->mBegin,se);
00415 }
00416