gwenhywfar 4.0.3

idlist64.c

Go to the documentation of this file.
00001 /***************************************************************************
00002     begin       : Mon Mar 01 2004
00003     copyright   : (C) 2004 by Martin Preuss
00004     email       : martin@libchipcard.de
00005 
00006  ***************************************************************************
00007  *                                                                         *
00008  *   This library is free software; you can redistribute it and/or         *
00009  *   modify it under the terms of the GNU Lesser General Public            *
00010  *   License as published by the Free Software Foundation; either          *
00011  *   version 2.1 of the License, or (at your option) any later version.    *
00012  *                                                                         *
00013  *   This library is distributed in the hope that it will be useful,       *
00014  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00015  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00016  *   Lesser General Public License for more details.                       *
00017  *                                                                         *
00018  *   You should have received a copy of the GNU Lesser General Public      *
00019  *   License along with this library; if not, write to the Free Software   *
00020  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00021  *   MA  02111-1307  USA                                                   *
00022  *                                                                         *
00023  ***************************************************************************/
00024 
00025 
00026 
00027 #ifdef HAVE_CONFIG_H
00028 # include <config.h>
00029 #endif
00030 
00031 #define DISABLE_DEBUGLOG
00032 
00033 
00034 #include "idlist64_p.h"
00035 #include <gwenhywfar/debug.h>
00036 
00037 
00038 #include <stdlib.h>
00039 #include <assert.h>
00040 #include <string.h>
00041 
00042 
00043 
00044 GWEN_IDTABLE64 *GWEN_IdTable64_new(){
00045   GWEN_IDTABLE64 *idt;
00046 
00047   GWEN_NEW_OBJECT(GWEN_IDTABLE64, idt);
00048   idt->refCount=1;
00049 
00050   idt->freeEntries=GWEN_IDTABLE64_MAXENTRIES;
00051   return idt;
00052 }
00053 
00054 
00055 
00056 void GWEN_IdTable64_free(GWEN_IDTABLE64 *idt){
00057   if (idt) {
00058     assert(idt->refCount);
00059     if (--(idt->refCount)==0) {
00060       GWEN_FREE_OBJECT(idt);
00061     }
00062   }
00063 }
00064 
00065 
00066 
00067 #if 0
00068 void GWEN_IdTable64_Attach(GWEN_IDTABLE64 *idt){
00069   assert(idt);
00070   assert(idt->refCount);
00071   idt->refCount++;
00072 }
00073 #endif
00074 
00075 
00076 
00077 static inline int GWEN_IdTable64_AddId(GWEN_IDTABLE64 *idt, uint64_t id){
00078   unsigned int i;
00079 
00080   for (i=0; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00081     if (idt->entries[i]==0) {
00082       idt->entries[i]=id;
00083       idt->freeEntries--;
00084       return 0;
00085     }
00086   } /* for */
00087   return -1;
00088 }
00089 
00090 
00091 
00092 static inline int GWEN_IdTable64_AppendId(GWEN_IDTABLE64 *idt, uint64_t id){
00093   if (idt->freeEntries) {
00094     unsigned int i;
00095 
00096     i=GWEN_IDTABLE64_MAXENTRIES-idt->freeEntries;
00097     idt->entries[i]=id;
00098     idt->freeEntries--;
00099     return 0;
00100   }
00101   else
00102     return -1;
00103 }
00104 
00105 
00106 
00107 static inline int GWEN_IdTable64_HasId(const GWEN_IDTABLE64 *idt, uint64_t id){
00108   unsigned int i;
00109 
00110   for (i=0; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00111     if (idt->entries[i]==id) {
00112       return 1;
00113     }
00114   } /* for */
00115   return 0;
00116 }
00117 
00118 
00119 
00120 static inline int GWEN_IdTable64_DelId(GWEN_IDTABLE64 *idt, uint64_t id){
00121   unsigned int i;
00122 
00123   for (i=0; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00124     if (idt->entries[i]==id) {
00125       idt->entries[i]=0;
00126       idt->freeEntries++;
00127       return 0;
00128     }
00129   } /* for */
00130   return -1;
00131 }
00132 
00133 
00134 
00135 static inline int GWEN_IdTable64_IsEmpty(const GWEN_IDTABLE64 *idt){
00136   return GWEN_IDTABLE64_MAXENTRIES==idt->freeEntries;
00137 }
00138 
00139 
00140 
00141 static inline int GWEN_IdTable64_IsFull(const GWEN_IDTABLE64 *idt){
00142   return idt->freeEntries==0;
00143 }
00144 
00145 
00146 
00147 static inline unsigned int GWEN_IdTable64_GetCount(const GWEN_IDTABLE64 *idt){
00148   return GWEN_IDTABLE64_MAXENTRIES-idt->freeEntries;
00149 }
00150 
00151 
00152 
00153 static inline uint64_t GWEN_IdTable64_GetFirstId(GWEN_IDTABLE64 *idt){
00154   unsigned int i;
00155 
00156   assert(idt);
00157   idt->current=0;
00158   for (i=0; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00159     if (idt->entries[i]!=0) {
00160       idt->current=i;
00161       return idt->entries[i];
00162     }
00163   } /* for */
00164   return 0;
00165 }
00166 
00167 
00168 
00169 static inline uint64_t GWEN_IdTable64_GetNextId(GWEN_IDTABLE64 *idt){
00170   unsigned int i;
00171 
00172   for (i=idt->current+1; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00173     if (idt->entries[i]!=0) {
00174       idt->current=i;
00175       return idt->entries[i];
00176     }
00177   } /* for */
00178   idt->current=GWEN_IDTABLE64_MAXENTRIES;
00179   return 0;
00180 }
00181 
00182 
00183 
00184 static inline uint64_t GWEN_IdTable64_GetFirstId2(const GWEN_IDTABLE64 *idt,
00185                                                   uint64_t *tabIdx){
00186   unsigned int i;
00187 
00188   for (i=0; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00189     if (idt->entries[i]!=0) {
00190       *tabIdx=i;
00191       return idt->entries[i];
00192     }
00193   } /* for */
00194   return 0;
00195 }
00196 
00197 
00198 
00199 static inline uint64_t GWEN_IdTable64_GetNextId2(const GWEN_IDTABLE64 *idt,
00200                                                  uint64_t *tabIdx){
00201   unsigned int i;
00202 
00203   for (i=(*tabIdx)+1; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00204     if (idt->entries[i]!=0) {
00205       *tabIdx=i;
00206       return idt->entries[i];
00207     }
00208   } /* for */
00209   return 0;
00210 }
00211 
00212 
00213 
00214 
00215 
00216 
00217 GWEN_IDLIST64 *GWEN_IdList64_new(){
00218   GWEN_IDLIST64 *idl;
00219 
00220   GWEN_NEW_OBJECT(GWEN_IDLIST64, idl);
00221   idl->refCount=1;
00222   return idl;
00223 }
00224 
00225 
00226 
00227 void GWEN_IdList64_Attach(GWEN_IDLIST64 *idl) {
00228   assert(idl);
00229   assert(idl->refCount);
00230   idl->refCount++;
00231 }
00232 
00233 
00234 
00235 void GWEN_IdList64_free(GWEN_IDLIST64 *idl){
00236   if (idl) {
00237     assert(idl->refCount);
00238     if (idl->refCount==1) {
00239       GWEN_IdList64_Clear(idl);
00240       idl->refCount=0;
00241       GWEN_FREE_OBJECT(idl);
00242     }
00243     else
00244       idl->refCount--;
00245   }
00246 }
00247 
00248 
00249 
00250 void GWEN_IdList64_AddTable(GWEN_IDLIST64 *idl, GWEN_IDTABLE64 *idt) {
00251   GWEN_IDTABLE64 **tablePtr;
00252   int idx;
00253 
00254   assert(idl);
00255 
00256   tablePtr=idl->pIdTablePointers;
00257   for (idx=0, tablePtr=idl->pIdTablePointers; idx<idl->idTableCount; idx++, tablePtr++) {
00258     if (*tablePtr==NULL)
00259       break;
00260   } /* while */
00261 
00262   if (idx>=idl->idTableCount) {
00263     uint32_t newCount;
00264     GWEN_IDTABLE64 **newPtr;
00265 
00266     /* resize */
00267     newCount=idl->idTableCount+GWEN_IDLIST64_STEP;
00268     newPtr=(GWEN_IDTABLE64 **)realloc(idl->pIdTablePointers, sizeof(GWEN_IDTABLE64*)*newCount);
00269     assert(newPtr);
00270     /* init new pointers */
00271     memset((void*)(newPtr+idl->idTableCount),
00272            0,
00273            sizeof(GWEN_IDTABLE64*)*(newCount-idl->idTableCount));
00274     idl->pIdTablePointers=newPtr;
00275     idl->pIdTablePointers[idl->idTableCount]=idt;
00276     idl->lastTableIdx=idl->idTableCount;
00277     idl->idTableCount=newCount;
00278   }
00279   else {
00280     idl->pIdTablePointers[idx]=idt;
00281     idl->lastTableIdx=idx;
00282   }
00283 }
00284 
00285 
00286 
00287 int GWEN_IdList64_AddId(GWEN_IDLIST64 *idl, uint64_t id){
00288   GWEN_IDTABLE64 *idt=NULL;
00289   GWEN_IDTABLE64 **tablePtr;
00290   int idx;
00291 
00292   assert(idl);
00293 
00294   if (idl->pIdTablePointers==NULL) {
00295     /* create an initial pointer table which can take up to GWEN_IDLIST64_STEP pointers */
00296     idl->pIdTablePointers=(GWEN_IDTABLE64 **) malloc(sizeof(GWEN_IDTABLE64*)*GWEN_IDLIST64_STEP);
00297     assert(idl->pIdTablePointers);
00298     memset(idl->pIdTablePointers, 0, sizeof(GWEN_IDTABLE64*)*GWEN_IDLIST64_STEP);
00299     idl->idTableCount=GWEN_IDLIST64_STEP;
00300   }
00301 
00302   for (idx=0, tablePtr=idl->pIdTablePointers; idx<idl->idTableCount; idx++, tablePtr++) {
00303     idt=*tablePtr;
00304     if (idt && !GWEN_IdTable64_IsFull(idt))
00305       break;
00306   } /* while */
00307 
00308   if (idx>=idl->idTableCount) {
00309     idt=GWEN_IdTable64_new();
00310     GWEN_IdList64_AddTable(idl, idt);
00311   }
00312 
00313   GWEN_IdTable64_AddId(idt, id);
00314   idl->entryCount++;
00315   return 0;
00316 }
00317 
00318 
00319 
00320 int GWEN_IdList64_DelId(GWEN_IDLIST64 *idl, uint64_t id){
00321   if (idl->pIdTablePointers) {
00322     GWEN_IDTABLE64 *idt=NULL;
00323     GWEN_IDTABLE64 **tablePtr;
00324     int idx;
00325 
00326     for (idx=0, tablePtr=idl->pIdTablePointers; idx<idl->idTableCount; idx++, tablePtr++) {
00327       idt=*tablePtr;
00328       if (idt && !GWEN_IdTable64_DelId(idt, id)) {
00329         /* found a table which had this id */
00330         GWEN_IdList64_Clean(idl);
00331         idl->entryCount--;
00332         return 0;
00333       }
00334     }
00335   }
00336 
00337   return -1;
00338 }
00339 
00340 
00341 
00342 int GWEN_IdList64_HasId(const GWEN_IDLIST64 *idl, uint64_t id){
00343   if (idl->pIdTablePointers) {
00344     GWEN_IDTABLE64 *idt=NULL;
00345     GWEN_IDTABLE64 **tablePtr;
00346     int idx;
00347 
00348     for (idx=0, tablePtr=idl->pIdTablePointers; idx<idl->idTableCount; idx++, tablePtr++) {
00349       idt=*tablePtr;
00350       if (idt && GWEN_IdTable64_HasId(idt, id))
00351         return 1;
00352     }
00353   }
00354 
00355   return 0;
00356 }
00357 
00358 
00359 
00360 void GWEN_IdList64_Clean(GWEN_IDLIST64 *idl) {
00361   GWEN_IDTABLE64 *idt=NULL;
00362   GWEN_IDTABLE64 **tablePtr;
00363   int idx;
00364 
00365   for (idx=0, tablePtr=idl->pIdTablePointers; idx<idl->idTableCount; idx++, tablePtr++) {
00366     idt=*tablePtr;
00367     if (idt && GWEN_IdTable64_IsEmpty(idt)) {
00368       GWEN_IdTable64_free(idt);
00369       *tablePtr=NULL;
00370     }
00371   }
00372 }
00373 
00374 
00375 
00376 void GWEN_IdList64_Clear(GWEN_IDLIST64 *idl) {
00377   if (idl->pIdTablePointers) {
00378     GWEN_IDTABLE64 *idt=NULL;
00379     GWEN_IDTABLE64 **tablePtr;
00380     int idx;
00381   
00382     for (idx=0, tablePtr=idl->pIdTablePointers; idx<idl->idTableCount; idx++, tablePtr++) {
00383       idt=*tablePtr;
00384       if (idt) {
00385         GWEN_IdTable64_free(idt);
00386         *tablePtr=NULL;
00387       }
00388     }
00389     free(idl->pIdTablePointers);
00390     idl->pIdTablePointers=NULL;
00391   }
00392   idl->entryCount=0;
00393   idl->nextIdx=0;
00394 }
00395 
00396 
00397 
00398 static int __compAscending(const void *pa, const void *pb) {
00399   uint64_t a=*((const uint64_t*)pa);
00400   uint64_t b=*((const uint64_t*)pb);
00401 
00402   if (a<b)
00403     return -1;
00404   else if (a>b)
00405     return 1;
00406   else
00407     return 0;
00408 }
00409 
00410 
00411 
00412 static int __compDescending(const void *pa, const void *pb) {
00413   uint64_t a=*((const uint64_t*)pa);
00414   uint64_t b=*((const uint64_t*)pb);
00415 
00416   if (a<b)
00417     return 1;
00418   else if (a>b)
00419     return -1;
00420   else
00421     return 0;
00422 }
00423 
00424 
00425 
00426 static int GWEN_IdList64__Sort(GWEN_IDLIST64 *idl, int ascending){
00427   assert(idl);
00428   assert(idl->refCount);
00429   if (idl->pIdTablePointers && idl->entryCount) {
00430     GWEN_IDLIST64_ITERATOR *it;
00431     unsigned int cnt;
00432     uint64_t *ptr;
00433     unsigned int i;
00434   
00435     assert(idl);
00436   
00437     /* count ids */
00438     cnt=idl->entryCount;
00439   
00440     /* move ids to a temporary list */
00441     ptr=(uint64_t*)malloc(sizeof(uint64_t)*cnt);
00442     assert(ptr);
00443   
00444     it=GWEN_IdList64_Iterator_new(idl);
00445     for (i=0; i<cnt; i++) {
00446       uint64_t id;
00447   
00448       if (i==0)
00449         id=GWEN_IdList64_Iterator_GetFirstId(it);
00450       else
00451         id=GWEN_IdList64_Iterator_GetNextId(it);
00452       assert(id);
00453       ptr[i]=id;
00454     } /* for */
00455     GWEN_IdList64_Iterator_free(it);
00456   
00457     /* remove all tables (we will add sorted tables later) */
00458     GWEN_IdList64_Clear(idl);
00459   
00460     if (ascending)
00461       qsort(ptr, cnt, sizeof(uint64_t), __compAscending);
00462     else
00463       qsort(ptr, cnt, sizeof(uint64_t), __compDescending);
00464   
00465     /* move back sorted list of ids from temporary list */
00466     for (i=0; i<cnt; i++) {
00467       GWEN_IdList64_AddId(idl, ptr[i]);
00468     }
00469     free(ptr);
00470   }
00471   return 0;
00472 }
00473 
00474 
00475 
00476 int GWEN_IdList64_Sort(GWEN_IDLIST64 *idl){
00477   return GWEN_IdList64__Sort(idl, 1);
00478 }
00479 
00480 
00481 
00482 int GWEN_IdList64_ReverseSort(GWEN_IDLIST64 *idl){
00483   return GWEN_IdList64__Sort(idl, 0);
00484 }
00485 
00486 
00487 
00488 GWEN_IDLIST64 *GWEN_IdList64_dup(const GWEN_IDLIST64 *idl){
00489   GWEN_IDLIST64 *nidl;
00490   int idx;
00491 
00492   nidl=GWEN_IdList64_new();
00493 
00494   nidl->idTableCount=idl->idTableCount;
00495   nidl->entryCount=idl->entryCount;
00496   if (idl->pIdTablePointers) {
00497     for (idx=0; idx<idl->idTableCount; idx++) {
00498       GWEN_IDTABLE64 *idt;
00499 
00500       idt=idl->pIdTablePointers[idx];
00501       if (idt && !GWEN_IdTable64_IsEmpty(idt)) {
00502         GWEN_IDTABLE64 *nidt;
00503 
00504         nidt=GWEN_IdTable64_new();
00505         memmove(nidt->entries, idt->entries, GWEN_IDTABLE64_MAXENTRIES*sizeof(uint64_t));
00506         nidt->freeEntries=idt->freeEntries;
00507         GWEN_IdList64_AddTable(nidl, nidt);
00508       }
00509     }
00510   }
00511 
00512   return nidl;
00513 }
00514 
00515 
00516 
00517 uint64_t GWEN_IdList64_GetEntryCount(const GWEN_IDLIST64 *idl) {
00518   assert(idl);
00519   assert(idl->refCount);
00520 
00521   return idl->entryCount;
00522 }
00523 
00524 
00525 
00526 uint64_t GWEN_IdList64__GetFirstId(const GWEN_IDLIST64 *idl, uint64_t *pos){
00527   GWEN_IDTABLE64 *idt=NULL;
00528   GWEN_IDTABLE64 **tablePtr;
00529   int idx;
00530   int idIndex=0;
00531 
00532   *pos=0;
00533   for (idx=0, tablePtr=idl->pIdTablePointers; idx<idl->idTableCount; idx++, tablePtr++) {
00534     idt=*tablePtr;
00535     if (idt && !GWEN_IdTable64_IsEmpty(idt)) {
00536       int i;
00537       uint64_t id;
00538 
00539       for (i=0; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00540         if (idt->entries[i]!=0) {
00541           id=idt->entries[i];
00542           *pos=idIndex+i+1;
00543           return id;
00544         }
00545       }
00546     }
00547     idIndex+=GWEN_IDTABLE64_MAXENTRIES;
00548   }
00549 
00550   return 0;
00551 }
00552 
00553 
00554 
00555 uint64_t GWEN_IdList64__GetNextId(const GWEN_IDLIST64 *idl, uint64_t *pos){
00556   if (*pos) {
00557     GWEN_IDTABLE64 *idt;
00558     uint64_t tableNum=*pos / GWEN_IDTABLE64_MAXENTRIES;
00559     uint64_t tableIdx=*pos % GWEN_IDTABLE64_MAXENTRIES;
00560     GWEN_IDTABLE64 **tablePtr;
00561     int idIndex=0;
00562     int idx;
00563 
00564     if (tableNum>idl->idTableCount) {
00565       DBG_ERROR(GWEN_LOGDOMAIN, "Table number out of range");
00566       *pos=0;
00567       return 0;
00568     }
00569 
00570     idIndex=(tableNum*GWEN_IDTABLE64_MAXENTRIES);
00571     for (idx=tableNum, tablePtr=idl->pIdTablePointers+tableNum; idx<idl->idTableCount; idx++, tablePtr++) {
00572       idt=*tablePtr;
00573       if (idt && !GWEN_IdTable64_IsEmpty(idt)) {
00574         int i;
00575         uint64_t id;
00576 
00577         if (idx==tableNum) {
00578           for (i=tableIdx; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00579             if (idt->entries[i]!=0) {
00580               id=idt->entries[i];
00581               *pos=idIndex+i+1;
00582               return id;
00583             }
00584           }
00585         }
00586         else {
00587           for (i=0; i<GWEN_IDTABLE64_MAXENTRIES; i++) {
00588             if (idt->entries[i]!=0) {
00589               id=idt->entries[i];
00590               *pos=idIndex+i+1;
00591               return id;
00592             }
00593           }
00594         }
00595       }
00596       idIndex+=GWEN_IDTABLE64_MAXENTRIES;
00597     }
00598     *pos=0;
00599   }
00600 
00601   return 0;
00602 }
00603 
00604 
00605 
00606 uint64_t GWEN_IdList64_GetFirstId(GWEN_IDLIST64 *idl){
00607   return GWEN_IdList64__GetFirstId(idl, &(idl->nextIdx));
00608 }
00609 
00610 
00611 
00612 uint64_t GWEN_IdList64_GetNextId(GWEN_IDLIST64 *idl){
00613   return GWEN_IdList64__GetNextId(idl, &(idl->nextIdx));
00614 }
00615 
00616 
00617 
00618 uint64_t GWEN_IdList64_GetFirstId2(const GWEN_IDLIST64 *idl, uint64_t *pos){
00619   return GWEN_IdList64__GetFirstId(idl, pos);
00620 }
00621 
00622 
00623 
00624 uint64_t GWEN_IdList64_GetNextId2(const GWEN_IDLIST64 *idl, uint64_t *pos){
00625   return GWEN_IdList64__GetNextId(idl, pos);
00626 }
00627 
00628 
00629 
00630 
00631 
00632 
00633 GWEN_IDLIST64_ITERATOR *GWEN_IdList64_Iterator_new(GWEN_IDLIST64 *idl) {
00634   GWEN_IDLIST64_ITERATOR *it;
00635 
00636   assert(idl);
00637   GWEN_NEW_OBJECT(GWEN_IDLIST64_ITERATOR, it);
00638 
00639   GWEN_IdList64_Attach(idl);
00640   it->list=idl;
00641 
00642   return it;
00643 }
00644 
00645 
00646 
00647 void GWEN_IdList64_Iterator_free(GWEN_IDLIST64_ITERATOR *it) {
00648   if (it) {
00649     GWEN_IdList64_free(it->list);
00650     GWEN_FREE_OBJECT(it);
00651   }
00652 }
00653 
00654 
00655 
00656 uint64_t GWEN_IdList64_Iterator_GetFirstId(GWEN_IDLIST64_ITERATOR *it) {
00657   return GWEN_IdList64__GetFirstId(it->list, &(it->nextIndex));
00658 }
00659 
00660 
00661 
00662 uint64_t GWEN_IdList64_Iterator_GetNextId(GWEN_IDLIST64_ITERATOR *it) {
00663   return GWEN_IdList64__GetNextId(it->list, &(it->nextIndex));
00664 }
00665 
00666 
00667 
00668 int GWEN_IdList64_AppendId(GWEN_IDLIST64 *idl, uint64_t id) {
00669   GWEN_IDTABLE64 *idt=NULL;
00670 
00671   assert(idl);
00672 
00673   if (idl->pIdTablePointers==NULL) {
00674     /* create an initial pointer table which can take up to GWEN_IDLIST64_STEP pointers */
00675     idl->pIdTablePointers=(GWEN_IDTABLE64 **) malloc(sizeof(GWEN_IDTABLE64*)*GWEN_IDLIST64_STEP);
00676     assert(idl->pIdTablePointers);
00677     memset(idl->pIdTablePointers, 0, sizeof(GWEN_IDTABLE64*)*GWEN_IDLIST64_STEP);
00678     idl->idTableCount=GWEN_IDLIST64_STEP;
00679   }
00680 
00681   idt=idl->pIdTablePointers[idl->lastTableIdx];
00682   if (idt==NULL || GWEN_IdTable64_IsFull(idt)) {
00683     idt=GWEN_IdTable64_new();
00684     GWEN_IdList64_AddTable(idl, idt);
00685   }
00686 
00687   GWEN_IdTable64_AppendId(idt, id);
00688   idl->entryCount++;
00689   return 0;
00690 }
00691 
00692 
00693 
00694 uint64_t GWEN_IdList64_GetIdAt(const GWEN_IDLIST64 *idl, uint64_t idx) {
00695   GWEN_IDTABLE64 *idt;
00696   uint64_t tableNum=idx / GWEN_IDTABLE64_MAXENTRIES;
00697   uint64_t tableIdx=idx % GWEN_IDTABLE64_MAXENTRIES;
00698 
00699   assert(idl);
00700   if (tableNum>idl->idTableCount) {
00701     DBG_INFO(GWEN_LOGDOMAIN, "Table index out of range");
00702     return 0;
00703   }
00704 
00705   idt=idl->pIdTablePointers[tableNum];
00706   if (idt==NULL) {
00707     DBG_INFO(GWEN_LOGDOMAIN, "Table index points to an empty table");
00708     return 0;
00709   }
00710 
00711   return idt->entries[tableIdx];
00712 }
00713 
00714 
00715 
00716 
00717 
00718 
00719 
00720 
00721 
00722 
00723