Changeset 3562


Ignore:
Timestamp:
Aug 27, 2007, 12:31:38 AM (18 years ago)
Author:
bird
Message:

Made is possible to redefine the AVLNODE members, thus allowing a structure to be used by more than one kAvl instance (i.e. be in more than one tree). Define the callback and enumdata our selves.

Location:
trunk/kStuff/include/k
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/kStuff/include/k/kAvlTmpl/kAvlBase.h

    r3560 r3562  
    3434 *  \#define KAVL_EQUAL_ALLOWED
    3535 *  Define this to tell us that equal keys are allowed.
    36  *  Then Equal keys will be put in a list pointed to by KAVLNODECORE::pList.
     36 *  Then Equal keys will be put in a list pointed to by KAVLNODE::pList.
    3737 *  This is by default not defined.
    3838 *
     
    6565 *  three are only required when KAVL_RANGE is defined.
    6666 *
    67  *  \#define KAVLNODECORE
    68  *  Define this to the name (typedef) of the AVL core node structure. This
    69  *  structure must have a pLeft, pRight, Key and uchHeight member.
    70  *  If KAVL_RANGE is defined a  KeyLast is also required.
    71  *  If KAVL_EQUAL_ALLOWED is defined a pList member is required.
     67 *  \#define KAVLNODE
     68 *  Define this to the name (typedef) of the AVL node structure. This
     69 *  structure must have a mpLeft, mpRight, mKey and mHeight member.
     70 *  If KAVL_RANGE is defined a mKeyLast is also required.
     71 *  If KAVL_EQUAL_ALLOWED is defined a mpList member is required.
     72 *  It's possible to use other member names by redefining the names.
    7273 *
    7374 *  \#define KAVLTREEPTR
    7475 *  Define this to the name (typedef) of the tree pointer type. This is
    7576 *  required when KAVL_OFFSET is defined. When not defined it defaults
    76  *  to KAVLNODECORE *.
     77 *  to KAVLNODE *.
    7778 *
    7879 *  \#define KAVL_FN
     
    9293 *  the instantiated template should have. For instance an inlined scope
    9394 *  (private or public) should K_DECL_INLINE(rettype) here.
    94  *
    95  *  typedef KAVL_TYPE(PFN,CALLBACK)
    96  *  kAVLDoWithAll requires KAVL_TYPE(PFN,CALLBACK) to be a function pointer
    97  *  to a callback suitable for the DoWithAll method.
    98  *
    9995 *
    10096 *  This version of the kAVL tree offers the option of inlining the entire
     
    115111*   Defined Constants And Macros                                               *
    116112*******************************************************************************/
    117 #define KAVL_HEIGHTOF(pNode) ((unsigned char)((pNode) != NULL ? (pNode)->uchHeight : 0))
     113#define KAVL_HEIGHTOF(pNode) ((KU8)((pNode) != NULL ? (pNode)->mHeight : 0))
    118114
    119115/** @def KAVL_GET_POINTER
     
    157153
    158154#ifndef KAVLTREEPTR
    159 # define KAVLTREEPTR                        KAVLNODECORE *
     155# define KAVLTREEPTR                        KAVLNODE *
    160156#endif
    161157
    162158#ifdef KAVL_OFFSET
    163 # define KAVL_GET_POINTER(pp)               ( (KAVLNODECORE *)((KIPTR)(pp) + *(pp)) )
     159# define KAVL_GET_POINTER(pp)               ( (KAVLNODE *)((KIPTR)(pp) + *(pp)) )
    164160# define KAVL_GET_POINTER_NULL(pp)          ( *(pp) != KAVL_NULL ? KAVL_GET_POINTER(pp) : NULL )
    165161# define KAVL_SET_POINTER(pp, p)            ( (*(pp)) = ((KIPTR)(p) - (KIPTR)(pp)) )
     
    203199*   Structures and Typedefs                                                    *
    204200*******************************************************************************/
    205 /*
    206  * Two stacks that's used to avoid recursive calls.
     201/**
     202 * Stack used to avoid recursive calls during insert and removal.
    207203 */
    208204typedef struct
     
    211207    KAVLTREEPTR    *aEntries[KAVL_MAX_STACK];
    212208} KAVL_INT(STACK);
    213 
    214 typedef struct
    215 {
    216     unsigned        cEntries;
    217     KAVLNODECORE   *aEntries[KAVL_MAX_STACK];
    218     char            achFlags[KAVL_MAX_STACK];
    219 } KAVL_INT(STACK2);
    220209
    221210
     
    275264    {
    276265        KAVLTREEPTR     *ppNode = pStack->aEntries[--pStack->cEntries];
    277         KAVLNODECORE    *pNode = KAVL_GET_POINTER(ppNode);
    278         KAVLNODECORE    *pLeftNode = KAVL_GET_POINTER_NULL(&pNode->pLeft);
    279         unsigned char    uchLeftHeight = KAVL_HEIGHTOF(pLeftNode);
    280         KAVLNODECORE    *pRightNode = KAVL_GET_POINTER_NULL(&pNode->pRight);
    281         unsigned char    uchRightHeight = KAVL_HEIGHTOF(pRightNode);
    282 
    283         if (uchRightHeight + 1 < uchLeftHeight)
     266        KAVLNODE        *pNode = KAVL_GET_POINTER(ppNode);
     267        KAVLNODE        *pLeftNode = KAVL_GET_POINTER_NULL(&pNode->mpLeft);
     268        KU8              uLeftHeight = KAVL_HEIGHTOF(pLeftNode);
     269        KAVLNODE        *pRightNode = KAVL_GET_POINTER_NULL(&pNode->mpRight);
     270        KU8              uRightHeight = KAVL_HEIGHTOF(pRightNode);
     271
     272        if (uRightHeight + 1 < uLeftHeight)
    284273        {
    285             KAVLNODECORE    *pLeftLeftNode = KAVL_GET_POINTER_NULL(&pLeftNode->pLeft);
    286             KAVLNODECORE    *pLeftRightNode = KAVL_GET_POINTER_NULL(&pLeftNode->pRight);
    287             unsigned char    uchLeftRightHeight = KAVL_HEIGHTOF(pLeftRightNode);
    288 
    289             if (KAVL_HEIGHTOF(pLeftLeftNode) >= uchLeftRightHeight)
     274            KAVLNODE    *pLeftLeftNode = KAVL_GET_POINTER_NULL(&pLeftNode->mpLeft);
     275            KAVLNODE    *pLeftRightNode = KAVL_GET_POINTER_NULL(&pLeftNode->mpRight);
     276            KU8          uLeftRightHeight = KAVL_HEIGHTOF(pLeftRightNode);
     277
     278            if (KAVL_HEIGHTOF(pLeftLeftNode) >= uLeftRightHeight)
    290279            {
    291                 KAVL_SET_POINTER_NULL(&pNode->pLeft, &pLeftNode->pRight);
    292                 KAVL_SET_POINTER(&pLeftNode->pRight, pNode);
    293                 pLeftNode->uchHeight = (unsigned char)(1 + (pNode->uchHeight = (unsigned char)(1 + uchLeftRightHeight)));
     280                KAVL_SET_POINTER_NULL(&pNode->mpLeft, &pLeftNode->mpRight);
     281                KAVL_SET_POINTER(&pLeftNode->mpRight, pNode);
     282                pLeftNode->mHeight = (KU8)(1 + (pNode->mHeight = (KU8)(1 + uLeftRightHeight)));
    294283                KAVL_SET_POINTER(ppNode, pLeftNode);
    295284            }
    296285            else
    297286            {
    298                 KAVL_SET_POINTER_NULL(&pLeftNode->pRight, &pLeftRightNode->pLeft);
    299                 KAVL_SET_POINTER_NULL(&pNode->pLeft, &pLeftRightNode->pRight);
    300                 KAVL_SET_POINTER(&pLeftRightNode->pLeft, pLeftNode);
    301                 KAVL_SET_POINTER(&pLeftRightNode->pRight, pNode);
    302                 pLeftNode->uchHeight = pNode->uchHeight = uchLeftRightHeight;
    303                 pLeftRightNode->uchHeight = uchLeftHeight;
     287                KAVL_SET_POINTER_NULL(&pLeftNode->mpRight, &pLeftRightNode->mpLeft);
     288                KAVL_SET_POINTER_NULL(&pNode->mpLeft, &pLeftRightNode->mpRight);
     289                KAVL_SET_POINTER(&pLeftRightNode->mpLeft, pLeftNode);
     290                KAVL_SET_POINTER(&pLeftRightNode->mpRight, pNode);
     291                pLeftNode->mHeight = pNode->mHeight = uLeftRightHeight;
     292                pLeftRightNode->mHeight = uLeftHeight;
    304293                KAVL_SET_POINTER(ppNode, pLeftRightNode);
    305294            }
    306295        }
    307         else if (uchLeftHeight + 1 < uchRightHeight)
     296        else if (uLeftHeight + 1 < uRightHeight)
    308297        {
    309             KAVLNODECORE    *pRightLeftNode = KAVL_GET_POINTER_NULL(&pRightNode->pLeft);
    310             unsigned char    uchRightLeftHeight = KAVL_HEIGHTOF(pRightLeftNode);
    311             KAVLNODECORE    *pRightRightNode = KAVL_GET_POINTER_NULL(&pRightNode->pRight);
    312 
    313             if (KAVL_HEIGHTOF(pRightRightNode) >= uchRightLeftHeight)
     298            KAVLNODE    *pRightLeftNode = KAVL_GET_POINTER_NULL(&pRightNode->mpLeft);
     299            KU8          uRightLeftHeight = KAVL_HEIGHTOF(pRightLeftNode);
     300            KAVLNODE    *pRightRightNode = KAVL_GET_POINTER_NULL(&pRightNode->mpRight);
     301
     302            if (KAVL_HEIGHTOF(pRightRightNode) >= uRightLeftHeight)
    314303            {
    315                 KAVL_SET_POINTER_NULL(&pNode->pRight, &pRightNode->pLeft);
    316                 KAVL_SET_POINTER(&pRightNode->pLeft, pNode);
    317                 pRightNode->uchHeight = (unsigned char)(1 + (pNode->uchHeight = (unsigned char)(1 + uchRightLeftHeight)));
     304                KAVL_SET_POINTER_NULL(&pNode->mpRight, &pRightNode->mpLeft);
     305                KAVL_SET_POINTER(&pRightNode->mpLeft, pNode);
     306                pRightNode->mHeight = (KU8)(1 + (pNode->mHeight = (KU8)(1 + uRightLeftHeight)));
    318307                KAVL_SET_POINTER(ppNode, pRightNode);
    319308            }
    320309            else
    321310            {
    322                 KAVL_SET_POINTER_NULL(&pRightNode->pLeft, &pRightLeftNode->pRight);
    323                 KAVL_SET_POINTER_NULL(&pNode->pRight, &pRightLeftNode->pLeft);
    324                 KAVL_SET_POINTER(&pRightLeftNode->pRight, pRightNode);
    325                 KAVL_SET_POINTER(&pRightLeftNode->pLeft, pNode);
    326                 pRightNode->uchHeight = pNode->uchHeight = uchRightLeftHeight;
    327                 pRightLeftNode->uchHeight = uchRightHeight;
     311                KAVL_SET_POINTER_NULL(&pRightNode->mpLeft, &pRightLeftNode->mpRight);
     312                KAVL_SET_POINTER_NULL(&pNode->mpRight, &pRightLeftNode->mpLeft);
     313                KAVL_SET_POINTER(&pRightLeftNode->mpRight, pRightNode);
     314                KAVL_SET_POINTER(&pRightLeftNode->mpLeft, pNode);
     315                pRightNode->mHeight = pNode->mHeight = uRightLeftHeight;
     316                pRightLeftNode->mHeight = uRightHeight;
    328317                KAVL_SET_POINTER(ppNode, pRightLeftNode);
    329318            }
     
    331320        else
    332321        {
    333             register unsigned char uchHeight = (unsigned char)(K_MAX(uchLeftHeight, uchRightHeight) + 1);
    334             if (uchHeight == pNode->uchHeight)
     322            KU8 uHeight = (KU8)(K_MAX(uLeftHeight, uRightHeight) + 1);
     323            if (uHeight == pNode->mHeight)
    335324                break;
    336             pNode->uchHeight = uchHeight;
     325            pNode->mHeight = uHeight;
    337326        }
    338327    }
     
    359348 *            Rebalance the tree.
    360349 */
    361 KAVL_DECL(KBOOL) KAVL_FN(Insert)(KAVLTREEPTR *ppTree, KAVLNODECORE *pNode)
     350KAVL_DECL(KBOOL) KAVL_FN(Insert)(KAVLTREEPTR *ppTree, KAVLNODE *pNode)
    362351{
    363     KAVL_INT(STACK)        AVLStack;
    364     KAVLTREEPTR            *ppCurNode = ppTree;
    365     register KAVLKEY        Key = pNode->Key;
     352    KAVL_INT(STACK)     AVLStack;
     353    KAVLTREEPTR        *ppCurNode = ppTree;
     354    register KAVLKEY    Key = pNode->mKey;
    366355#ifdef KAVL_RANGE
    367     register KAVLKEY        KeyLast = pNode->KeyLast;
    368 #endif
    369     register KAVLNODECORE  *pCurNode;
    370 
    371     AVLStack.cEntries = 0;
     356    register KAVLKEY    KeyLast = pNode->mKeyLast;
     357#endif
    372358
    373359#ifdef KAVL_RANGE
    374360    if (Key > KeyLast)
    375361        return false;
    376 #else
    377     K_NOREF(Key);
    378 #endif
    379 
     362#endif
     363
     364    AVLStack.cEntries = 0;
    380365    while (*ppCurNode != KAVL_NULL)
    381366    {
    382         pCurNode = KAVL_GET_POINTER(ppCurNode);
     367        register KAVLNODE *pCurNode = KAVL_GET_POINTER(ppCurNode);
    383368
    384369        kHlpAssert(AVLStack.cEntries < KAVL_MAX_STACK);
    385370        AVLStack.aEntries[AVLStack.cEntries++] = ppCurNode;
    386371#ifdef KAVL_EQUAL_ALLOWED
    387         if (KAVL_R_IS_IDENTICAL(pCurNode->Key, Key, pCurNode->KeyLast, KeyLast))
     372        if (KAVL_R_IS_IDENTICAL(pCurNode->mKey, Key, pCurNode->mKeyLast, KeyLast))
    388373        {
    389374            /*
    390375             * If equal then we'll use a list of equal nodes.
    391376             */
    392             pNode->pLeft = pNode->pRight = KAVL_NULL;
    393             pNode->uchHeight = 0;
    394             KAVL_SET_POINTER_NULL(&pNode->pList, &pCurNode->pList);
    395             KAVL_SET_POINTER(&pCurNode->pList, pNode);
     377            pNode->mpLeft = pNode->mpRight = KAVL_NULL;
     378            pNode->mHeight = 0;
     379            KAVL_SET_POINTER_NULL(&pNode->mpList, &pCurNode->mpList);
     380            KAVL_SET_POINTER(&pCurNode->mpList, pNode);
    396381            return K_TRUE;
    397382        }
    398383#endif
    399384#ifdef KAVL_CHECK_FOR_EQUAL_INSERT
    400         if (KAVL_R_IS_INTERSECTING(pCurNode->Key, Key, pCurNode->KeyLast, KeyLast))
     385        if (KAVL_R_IS_INTERSECTING(pCurNode->mKey, Key, pCurNode->mKeyLast, KeyLast))
    401386            return K_FALSE;
    402387#endif
    403         if (KAVL_G(pCurNode->Key, Key))
    404             ppCurNode = &pCurNode->pLeft;
     388        if (KAVL_G(pCurNode->mKey, Key))
     389            ppCurNode = &pCurNode->mpLeft;
    405390        else
    406             ppCurNode = &pCurNode->pRight;
     391            ppCurNode = &pCurNode->mpRight;
    407392    }
    408393
    409     pNode->pLeft = pNode->pRight = KAVL_NULL;
     394    pNode->mpLeft = pNode->mpRight = KAVL_NULL;
    410395#ifdef KAVL_EQUAL_ALLOWED
    411     pNode->pList = KAVL_NULL;
    412 #endif
    413     pNode->uchHeight = 1;
     396    pNode->mpList = KAVL_NULL;
     397#endif
     398    pNode->mHeight = 1;
    414399    KAVL_SET_POINTER(ppCurNode, pNode);
    415400
     
    458443 *            return pointer to the removed node (if found).
    459444 */
    460 KAVL_DECL(KAVLNODECORE *) KAVL_FN(Remove)(KAVLTREEPTR *ppTree, KAVLKEY Key)
     445KAVL_DECL(KAVLNODE *) KAVL_FN(Remove)(KAVLTREEPTR *ppTree, KAVLKEY Key)
    461446{
    462     KAVL_INT(STACK)         AVLStack;
    463     KAVLTREEPTR             *ppDeleteNode = ppTree;
    464     register KAVLNODECORE   *pDeleteNode;
     447    KAVL_INT(STACK)     AVLStack;
     448    KAVLTREEPTR        *ppDeleteNode = ppTree;
     449    register KAVLNODE  *pDeleteNode;
    465450
    466451    AVLStack.cEntries = 0;
    467 
    468452    for (;;)
    469453    {
     
    474458        kHlpAssert(AVLStack.cEntries < KAVL_MAX_STACK);
    475459        AVLStack.aEntries[AVLStack.cEntries++] = ppDeleteNode;
    476         if (KAVL_E(pDeleteNode->Key, Key))
     460        if (KAVL_E(pDeleteNode->mKey, Key))
    477461            break;
    478462
    479         if (KAVL_G(pDeleteNode->Key, Key))
    480             ppDeleteNode = &pDeleteNode->pLeft;
     463        if (KAVL_G(pDeleteNode->mKey, Key))
     464            ppDeleteNode = &pDeleteNode->mpLeft;
    481465        else
    482             ppDeleteNode = &pDeleteNode->pRight;
     466            ppDeleteNode = &pDeleteNode->mpRight;
    483467    }
    484468
    485     if (pDeleteNode->pLeft != KAVL_NULL)
     469    if (pDeleteNode->mpLeft != KAVL_NULL)
    486470    {
    487471        /* find the rightmost node in the left tree. */
    488         const unsigned          iStackEntry = AVLStack.cEntries;
    489         KAVLTREEPTR            *ppLeftLeast = &pDeleteNode->pLeft;
    490         register KAVLNODECORE  *pLeftLeast = KAVL_GET_POINTER(ppLeftLeast);
    491 
    492         while (pLeftLeast->pRight != KAVL_NULL)
     472        const unsigned      iStackEntry = AVLStack.cEntries;
     473        KAVLTREEPTR        *ppLeftLeast = &pDeleteNode->mpLeft;
     474        register KAVLNODE  *pLeftLeast = KAVL_GET_POINTER(ppLeftLeast);
     475
     476        while (pLeftLeast->mpRight != KAVL_NULL)
    493477        {
    494478            kHlpAssert(AVLStack.cEntries < KAVL_MAX_STACK);
    495479            AVLStack.aEntries[AVLStack.cEntries++] = ppLeftLeast;
    496             ppLeftLeast = &pLeftLeast->pRight;
     480            ppLeftLeast = &pLeftLeast->mpRight;
    497481            pLeftLeast  = KAVL_GET_POINTER(ppLeftLeast);
    498482        }
    499483
    500484        /* link out pLeftLeast */
    501         KAVL_SET_POINTER_NULL(ppLeftLeast, &pLeftLeast->pLeft);
     485        KAVL_SET_POINTER_NULL(ppLeftLeast, &pLeftLeast->mpLeft);
    502486
    503487        /* link it in place of the delete node. */
    504         KAVL_SET_POINTER_NULL(&pLeftLeast->pLeft, &pDeleteNode->pLeft);
    505         KAVL_SET_POINTER_NULL(&pLeftLeast->pRight, &pDeleteNode->pRight);
    506         pLeftLeast->uchHeight = pDeleteNode->uchHeight;
     488        KAVL_SET_POINTER_NULL(&pLeftLeast->mpLeft, &pDeleteNode->mpLeft);
     489        KAVL_SET_POINTER_NULL(&pLeftLeast->mpRight, &pDeleteNode->mpRight);
     490        pLeftLeast->mHeight = pDeleteNode->mHeight;
    507491        KAVL_SET_POINTER(ppDeleteNode, pLeftLeast);
    508         AVLStack.aEntries[iStackEntry] = &pLeftLeast->pLeft;
     492        AVLStack.aEntries[iStackEntry] = &pLeftLeast->mpLeft;
    509493    }
    510494    else
    511495    {
    512         KAVL_SET_POINTER_NULL(ppDeleteNode, &pDeleteNode->pRight);
     496        KAVL_SET_POINTER_NULL(ppDeleteNode, &pDeleteNode->mpRight);
    513497        AVLStack.cEntries--;
    514498    }
  • trunk/kStuff/include/k/kAvlTmpl/kAvlDoWithAll.h

    r3560 r3562  
    2525 */
    2626
     27/*******************************************************************************
     28*   Structures and Typedefs                                                    *
     29*******************************************************************************/
     30/** The callback typedef. */
     31typedef int (* KAVL_TYPE(PFN,CALLBACK))(KAVLNODE *, void *);
     32
     33/**
     34 * Stack used by DoWithAll to avoid recusive function calls.
     35 */
     36typedef struct
     37{
     38    unsigned        cEntries;
     39    KAVLNODE       *aEntries[KAVL_MAX_STACK];
     40    char            achFlags[KAVL_MAX_STACK];
     41} KAVL_INT(STACK2);
     42
    2743
    2844/**
     
    3854KAVL_DECL(int) KAVL_FN(DoWithAll)(KAVLTREEPTR *ppTree, KBOOL fFromLeft, KAVL_TYPE(PFN,CALLBACK) pfnCallBack, void *pvUser)
    3955{
    40     KAVL_INT(STACK2)   AVLStack;
    41     KAVLNODECORE       *pNode;
    42     unsigned            rc;
     56    KAVL_INT(STACK2)    AVLStack;
     57    KAVLNODE           *pNode;
     58    int                 rc;
    4359
    4460    if (*ppTree == KAVL_NULL)
     
    5874            if (!AVLStack.achFlags[AVLStack.cEntries - 1]++)
    5975            {
    60                 if (pNode->pLeft != KAVL_NULL)
     76                if (pNode->mpLeft != KAVL_NULL)
    6177                {
    6278                    AVLStack.achFlags[AVLStack.cEntries] = 0; /* 0 first, 1 last */
    63                     AVLStack.aEntries[AVLStack.cEntries++] = KAVL_GET_POINTER(&pNode->pLeft);
     79                    AVLStack.aEntries[AVLStack.cEntries++] = KAVL_GET_POINTER(&pNode->mpLeft);
    6480                    continue;
    6581                }
     
    7389            /* right */
    7490            AVLStack.cEntries--;
    75             if (pNode->pRight != KAVL_NULL)
     91            if (pNode->mpRight != KAVL_NULL)
    7692            {
    7793                AVLStack.achFlags[AVLStack.cEntries] = 0;
    78                 AVLStack.aEntries[AVLStack.cEntries++] = KAVL_GET_POINTER(&pNode->pRight);
     94                AVLStack.aEntries[AVLStack.cEntries++] = KAVL_GET_POINTER(&pNode->mpRight);
    7995            }
    8096        } /* while */
     
    86102            pNode = AVLStack.aEntries[AVLStack.cEntries - 1];
    87103
    88 
    89104            /* right */
    90105            if (!AVLStack.achFlags[AVLStack.cEntries - 1]++)
    91106            {
    92                 if (pNode->pRight != KAVL_NULL)
     107                if (pNode->mpRight != KAVL_NULL)
    93108                {
    94109                    AVLStack.achFlags[AVLStack.cEntries] = 0;  /* 0 first, 1 last */
    95                     AVLStack.aEntries[AVLStack.cEntries++] = KAVL_GET_POINTER(&pNode->pRight);
     110                    AVLStack.aEntries[AVLStack.cEntries++] = KAVL_GET_POINTER(&pNode->mpRight);
    96111                    continue;
    97112                }
     
    105120            /* left */
    106121            AVLStack.cEntries--;
    107             if (pNode->pLeft != KAVL_NULL)
     122            if (pNode->mpLeft != KAVL_NULL)
    108123            {
    109124                AVLStack.achFlags[AVLStack.cEntries] = 0;
    110                 AVLStack.aEntries[AVLStack.cEntries++] = KAVL_GET_POINTER(&pNode->pLeft);
     125                AVLStack.aEntries[AVLStack.cEntries++] = KAVL_GET_POINTER(&pNode->mpLeft);
    111126            }
    112127        } /* while */
  • trunk/kStuff/include/k/kAvlTmpl/kAvlEnum.h

    r3560 r3562  
    2525 */
    2626
     27/*******************************************************************************
     28*   Structures and Typedefs                                                    *
     29*******************************************************************************/
     30/**
     31 * Enumeration control data.
     32 *
     33 * This is initialized by BeginEnum and used by GetNext to figure out what
     34 * to do next.
     35 */
     36typedef struct KAVL_TYPE(,ENUMDATA)
     37{
     38    KBOOL               fFromLeft;
     39    KI8                 cEntries;
     40    KU8                 achFlags[KAVL_MAX_STACK];
     41    KAVLNODE *          aEntries[KAVL_MAX_STACK];
     42} KAVL_TYPE(,ENUMDATA), *KAVL_TYPE(P,ENUMDATA);
     43
     44
    2745/**
    2846 * Get the next node in the tree enumeration.
    29  * @returns   Pointer to the first node in the tree.
    30  * @param     pEnumData  Pointer to enumeration control data.
    31  * @status    completely implemented.
    32  * @author    knut st. osmundsen
     47 *
     48 * @returns Pointer to the first node in the tree.
     49 * @param   pEnumData   Pointer to enumeration control data.
    3350 */
    34 KAVL_DECL(KAVLNODECORE *) KAVL_FN(GetNextNode)(KAVL_TYPE(,ENUMDATA) *pEnumData)
     51KAVL_DECL(KAVLNODE *) KAVL_FN(GetNext)(KAVL_TYPE(,ENUMDATA) *pEnumData)
    3552{
    3653    if (pEnumData->fFromLeft)
     
    3855        while (pEnumData->cEntries > 0)
    3956        {
    40             KAVLNODECORE *pNode = pEnumData->aEntries[pEnumData->cEntries - 1];
     57            KAVLNODE *pNode = pEnumData->aEntries[pEnumData->cEntries - 1];
    4158
    4259            /* left */
     
    4461            {
    4562                pEnumData->achFlags[pEnumData->cEntries - 1]++;
    46                 if (pNode->pLeft != KAVL_NULL)
     63                if (pNode->mpLeft != KAVL_NULL)
    4764                {
    4865                    pEnumData->achFlags[pEnumData->cEntries] = 0; /* 0 left, 1 center, 2 right */
    49                     pEnumData->aEntries[pEnumData->cEntries++] = KAVL_GET_POINTER(&pNode->pLeft);
     66                    pEnumData->aEntries[pEnumData->cEntries++] = KAVL_GET_POINTER(&pNode->mpLeft);
    5067                    continue;
    5168                }
     
    6178            /* right */
    6279            pEnumData->cEntries--;
    63             if (pNode->pRight != KAVL_NULL)
     80            if (pNode->mpRight != KAVL_NULL)
    6481            {
    6582                pEnumData->achFlags[pEnumData->cEntries] = 0;
    66                 pEnumData->aEntries[pEnumData->cEntries++] = KAVL_GET_POINTER(&pNode->pRight);
     83                pEnumData->aEntries[pEnumData->cEntries++] = KAVL_GET_POINTER(&pNode->mpRight);
    6784            }
    6885        } /* while */
     
    7289        while (pEnumData->cEntries > 0)
    7390        {
    74             KAVLNODECORE *pNode = pEnumData->aEntries[pEnumData->cEntries - 1];
     91            KAVLNODE *pNode = pEnumData->aEntries[pEnumData->cEntries - 1];
    7592
    7693            /* right */
     
    7895            {
    7996                pEnumData->achFlags[pEnumData->cEntries - 1]++;
    80                 if (pNode->pRight != KAVL_NULL)
     97                if (pNode->mpRight != KAVL_NULL)
    8198                {
    8299                    pEnumData->achFlags[pEnumData->cEntries] = 0;  /* 0 right, 1 center, 2 left */
    83                     pEnumData->aEntries[pEnumData->cEntries++] = KAVL_GET_POINTER(&pNode->pRight);
     100                    pEnumData->aEntries[pEnumData->cEntries++] = KAVL_GET_POINTER(&pNode->mpRight);
    84101                    continue;
    85102                }
     
    95112            /* left */
    96113            pEnumData->cEntries--;
    97             if (pNode->pLeft != KAVL_NULL)
     114            if (pNode->mpLeft != KAVL_NULL)
    98115            {
    99116                pEnumData->achFlags[pEnumData->cEntries] = 0;
    100                 pEnumData->aEntries[pEnumData->cEntries++] = KAVL_GET_POINTER(&pNode->pLeft);
     117                pEnumData->aEntries[pEnumData->cEntries++] = KAVL_GET_POINTER(&pNode->mpLeft);
    101118            }
    102119        } /* while */
     
    116133 *                      K_FALSE: Right to left.
    117134 */
    118 KAVL_DECL(KAVLNODECORE *) KAVL_FN(BeginEnumTree)(KAVLTREEPTR *ppTree, KAVL_TYPE(,ENUMDATA) *pEnumData, KBOOL fFromLeft)
     135KAVL_DECL(KAVLNODE *) KAVL_FN(BeginEnum)(KAVLTREEPTR *ppTree, KAVL_TYPE(,ENUMDATA) *pEnumData, KBOOL fFromLeft)
    119136{
    120137    if (*ppTree != KAVL_NULL)
     
    128145        pEnumData->cEntries = 0;
    129146
    130     return KAVL_FN(GetNextNode)(pEnumData);
     147    return KAVL_FN(GetNext)(pEnumData);
    131148}
    132149
  • trunk/kStuff/include/k/kAvlTmpl/kAvlGet.h

    r3560 r3562  
    3333 * @param     Key     Key value of the node which is to be found.
    3434 */
    35 KAVL_DECL(KAVLNODECORE *) KAVL_FN(Get)(KAVLTREEPTR *ppTree, KAVLKEY Key)
     35KAVL_DECL(KAVLNODE *) KAVL_FN(Get)(KAVLTREEPTR *ppTree, KAVLKEY Key)
    3636{
    37     KAVLNODECORE *pNode;
     37    KAVLNODE *pNode;
    3838    if (*ppTree == KAVL_NULL)
    3939        return NULL;
    4040
    4141    pNode = KAVL_GET_POINTER(ppTree);
    42     while (KAVL_NE(pNode->Key, Key))
     42    while (KAVL_NE(pNode->mKey, Key))
    4343    {
    44         if (KAVL_G(pNode->Key, Key))
     44        if (KAVL_G(pNode->mKey, Key))
    4545        {
    46             if (pNode->pLeft == KAVL_NULL)
     46            if (pNode->mpLeft == KAVL_NULL)
    4747                return NULL;
    48             pNode = KAVL_GET_POINTER(&pNode->pLeft);
     48            pNode = KAVL_GET_POINTER(&pNode->mpLeft);
    4949        }
    5050        else
    5151        {
    52             if (pNode->pRight == KAVL_NULL)
     52            if (pNode->mpRight == KAVL_NULL)
    5353                return NULL;
    54             pNode = KAVL_GET_POINTER(&pNode->pRight);
     54            pNode = KAVL_GET_POINTER(&pNode->mpRight);
    5555        }
    5656    }
  • trunk/kStuff/include/k/kAvlTmpl/kAvlGetBestFit.h

    r3560 r3562  
    3838 *          <= (below): the node where you last turned right.
    3939 */
    40 KAVL_DECL(KAVLNODECORE *) KAVL_FN(GetBestFit)(KAVLTREEPTR *ppTree, KAVLKEY Key, KBOOL fAbove)
     40KAVL_DECL(KAVLNODE *) KAVL_FN(GetBestFit)(KAVLTREEPTR *ppTree, KAVLKEY Key, KBOOL fAbove)
    4141{
    42     register KAVLNODECORE *pNode;
    43     KAVLNODECORE *pNodeLast;
     42    register KAVLNODE  *pNode;
     43    KAVLNODE          *pNodeLast;
    4444
    4545    if (*ppTree == KAVL_NULL)
     
    4949    pNodeLast = NULL;
    5050    if (fAbove)
    51     {   /* pNode->Key >= Key */
    52         while (KAVL_NE(pNode->Key, Key))
     51    {   /* pNode->mKey >= Key */
     52        while (KAVL_NE(pNode->mKey, Key))
    5353        {
    54             if (KAVL_G(pNode->Key, Key))
     54            if (KAVL_G(pNode->mKey, Key))
    5555            {
    56                 if (pNode->pLeft == KAVL_NULL)
     56                if (pNode->mpLeft == KAVL_NULL)
    5757                    return pNode;
    5858                pNodeLast = pNode;
    59                 pNode = KAVL_GET_POINTER(&pNode->pLeft);
     59                pNode = KAVL_GET_POINTER(&pNode->mpLeft);
    6060            }
    6161            else
    6262            {
    63                 if (pNode->pRight == KAVL_NULL)
     63                if (pNode->mpRight == KAVL_NULL)
    6464                    return pNodeLast;
    65                 pNode = KAVL_GET_POINTER(&pNode->pRight);
     65                pNode = KAVL_GET_POINTER(&pNode->mpRight);
    6666            }
    6767        }
    6868    }
    6969    else
    70     {   /* pNode->Key <= Key */
    71         while (KAVL_NE(pNode->Key, Key))
     70    {   /* pNode->mKey <= Key */
     71        while (KAVL_NE(pNode->mKey, Key))
    7272        {
    73             if (KAVL_G(pNode->Key, Key))
     73            if (KAVL_G(pNode->mKey, Key))
    7474            {
    75                 if (pNode->pLeft == KAVL_NULL)
     75                if (pNode->mpLeft == KAVL_NULL)
    7676                    return pNodeLast;
    77                 pNode = KAVL_GET_POINTER(&pNode->pLeft);
     77                pNode = KAVL_GET_POINTER(&pNode->mpLeft);
    7878            }
    7979            else
    8080            {
    81                 if (pNode->pRight == KAVL_NULL)
     81                if (pNode->mpRight == KAVL_NULL)
    8282                    return pNode;
    8383                pNodeLast = pNode;
    84                 pNode = KAVL_GET_POINTER(&pNode->pRight);
     84                pNode = KAVL_GET_POINTER(&pNode->mpRight);
    8585            }
    8686        }
  • trunk/kStuff/include/k/kAvlTmpl/kAvlGetWithParent.h

    r3560 r3562  
    3636 * @param     Key       Key value of the node which is to be found.
    3737 */
    38 KAVL_DECL(KAVLNODECORE *) KAVL_FN(GetWithParent)(KAVLTREEPTR *ppTree, KAVLNODECORE **ppParent, KAVLKEY Key)
     38KAVL_DECL(KAVLNODE *) KAVL_FN(GetWithParent)(KAVLTREEPTR *ppTree, KAVLNODE **ppParent, KAVLKEY Key)
    3939{
    40     register KAVLNODECORE *pNode = KAVL_GET_POINTER_NULL(ppTree);
    41     register KAVLNODECORE *pParent = NULL;
     40    register KAVLNODE *pNode = KAVL_GET_POINTER_NULL(ppTree);
     41    register KAVLNODE *pParent = NULL;
    4242
    4343    while (     pNode != NULL
    44            &&   KAVL_NE(pNode->Key, Key))
     44           &&   KAVL_NE(pNode->mKey, Key))
    4545    {
    4646        pParent = pNode;
    47         if (KAVL_G(pNode->Key, Key))
    48             pNode = KAVL_GET_POINTER_NULL(&pNode->pLeft);
     47        if (KAVL_G(pNode->mKey, Key))
     48            pNode = KAVL_GET_POINTER_NULL(&pNode->mpLeft);
    4949        else
    50             pNode = KAVL_GET_POINTER_NULL(&pNode->pRight);
     50            pNode = KAVL_GET_POINTER_NULL(&pNode->mpRight);
    5151    }
    5252
  • trunk/kStuff/include/k/kAvlTmpl/kAvlRemove2.h

    r3560 r3562  
    3636 *          easier to manage.
    3737 */
    38 KAVL_DECL(KAVLNODECORE *) KAVL_FN(Remove2)(KAVLTREEPTR *ppTree, KAVLNODECORE *pNode)
     38KAVL_DECL(KAVLNODE *) KAVL_FN(Remove2)(KAVLTREEPTR *ppTree, KAVLNODE *pNode)
    3939{
    4040#ifdef KAVL_EQUAL_ALLOWED
     
    4242     * Find the right node by key and see if it's what we want.
    4343     */
    44     KAVLNODECORE *pParent;
    45     KAVLNODECORE *pCurNode = KAVL_FN(GetWithParent)(ppTree, pNode->Key, &pParent);
     44    KAVLNODE *pParent;
     45    KAVLNODE *pCurNode = KAVL_FN(GetWithParent)(ppTree, pNode->mKey, &pParent);
    4646    if (!pCurNode)
    4747        return NULL;
     
    5151         * It's not the one we want, but it could be in the duplicate list.
    5252         */
    53         while (pCurNode->pList != KAVL_NULL)
     53        while (pCurNode->mpList != KAVL_NULL)
    5454        {
    55             KAVLNODECORE *pNext = KAVL_GET_POINTER(&pCurNode->pList);
     55            KAVLNODE *pNext = KAVL_GET_POINTER(&pCurNode->mpList);
    5656            if (pNext == pNode)
    5757            {
    58                 KAVL_SET_POINTER_NULL(&pCurNode->pList, KAVL_GET_POINTER_NULL(&pNode->pList));
    59                 pNode->pList = KAVL_NULL;
     58                KAVL_SET_POINTER_NULL(&pCurNode->mpList, KAVL_GET_POINTER_NULL(&pNode->mpList));
     59                pNode->mpList = KAVL_NULL;
    6060                return pNode;
    6161            }
     
    7272     * insert the first duplicate in our place.
    7373     */
    74     if (pNode->pList == KAVL_NODE)
    75         KAVL_FN(Remove)(ppTree, pNode->Key);
     74    if (pNode->mpList == KAVL_NODE)
     75        KAVL_FN(Remove)(ppTree, pNode->mKey);
    7676    else
    7777    {
    78         KAVLNODECORE *pNewUs = KAVL_GET_POINTER(&pNode->pList);
     78        KAVLNODE *pNewUs = KAVL_GET_POINTER(&pNode->mpList);
    7979
    80         pNewUs->uchHeight = pNode->uchHeight;
     80        pNewUs->mHeight = pNode->mHeight;
    8181
    82         if (pNode->pLeft != KAVL_NULL)
    83             KAVL_SET_POINTER(&pNewUs->pLeft, KAVL_GET_POINTER(&pNode->pLeft))
     82        if (pNode->mpLeft != KAVL_NULL)
     83            KAVL_SET_POINTER(&pNewUs->mpLeft, KAVL_GET_POINTER(&pNode->mpLeft))
    8484        else
    85             pNewUs->pLeft = KAVL_NULL;
     85            pNewUs->mpLeft = KAVL_NULL;
    8686
    87         if (pNode->pRight != KAVL_NULL)
    88             KAVL_SET_POINTER(&pNewUs->pRight, KAVL_GET_POINTER(&pNode->pRight))
     87        if (pNode->mpRight != KAVL_NULL)
     88            KAVL_SET_POINTER(&pNewUs->mpRight, KAVL_GET_POINTER(&pNode->mpRight))
    8989        else
    90             pNewUs->pRight = KAVL_NULL;
     90            pNewUs->mpRight = KAVL_NULL;
    9191
    9292        if (pParent)
    9393        {
    94             if (KAVL_GET_POINTER_NULL(&pParent->pLeft) == pNode)
    95                 KAVL_SET_POINTER(&pParent->pLeft, pNewUs);
     94            if (KAVL_GET_POINTER_NULL(&pParent->mpLeft) == pNode)
     95                KAVL_SET_POINTER(&pParent->mpLeft, pNewUs);
    9696            else
    97                 KAVL_SET_POINTER(&pParent->pRight, pNewUs);
     97                KAVL_SET_POINTER(&pParent->mpRight, pNewUs);
    9898        }
    9999        else
     
    109109     * of wrong nodes but just uses this API for his convenience.
    110110     */
    111     KAVLNODECORE *pRemovedNode = KAVL_FN(Remove)(ppTree, pNode->Key);
     111    KAVLNODE *pRemovedNode = KAVL_FN(Remove)(ppTree, pNode->mKey);
    112112    if (pRemovedNode == pNode)
    113113        return pRemovedNode;
  • trunk/kStuff/include/k/kAvlTmpl/kAvlRemoveBestFit.h

    r3560 r3562  
    3939 *          code size, and the likelyhood for bugs.
    4040 */
    41 KAVL_DECL(KAVLNODECORE *) KAVL_FN(RemoveBestFit)(KAVLTREEPTR *ppTree, KAVLKEY Key, KBOOL fAbove)
     41KAVL_DECL(KAVLNODE *) KAVL_FN(RemoveBestFit)(KAVLTREEPTR *ppTree, KAVLKEY Key, KBOOL fAbove)
    4242{
    4343    /*
     
    4646     * removing the in-tree node as this is way cheaper.
    4747     */
    48     KAVLNODECORE *pNode = KAVL_FN(GetBestFit)(ppTree, Key, fAbove);
     48    KAVLNODE *pNode = KAVL_FN(GetBestFit)(ppTree, Key, fAbove);
    4949    if (pNode != NULL)
    5050    {
    5151#ifdef KAVL_EQUAL_ALLOWED
    52         if (pNode->pList != KAVL_NULL)
     52        if (pNode->mpList != KAVL_NULL)
    5353        {
    54             KAVLANODECORE *pRet = KAVL_GET_POINTER(&pNode->pList);
    55             KAVL_SET_POINTER_NULL(&pNode->pList, &pRet->pList);
     54            KAVLNODE *pRet = KAVL_GET_POINTER(&pNode->mpList);
     55            KAVL_SET_POINTER_NULL(&pNode->mpList, &pRet->mpList);
    5656            return pRet;
    5757        }
    5858#endif
    59         pNode = KAVL_FN(Remove)(ppTree, pNode->Key);
     59        pNode = KAVL_FN(Remove)(ppTree, pNode->mKey);
    6060    }
    6161    return pNode;
  • trunk/kStuff/include/k/kAvlTmpl/kAvlUndef.h

    r3560 r3562  
    3535#undef KAVL_STD_KEY_COMP
    3636#undef KAVLKEY
    37 #undef KAVLNODECORE
     37#undef KAVLNODE
    3838#undef KAVLTREEPTR
    3939#undef KAVL_FN
     
    4141#undef KAVL_INT
    4242#undef KAVL_DECL
     43#undef mKey
     44#undef mKeyLast
     45#undef mHeight
     46#undef mpLeft
     47#undef mpRight
     48#undef mpList
    4349
    4450/*
  • trunk/kStuff/include/k/kAvlU32.h

    r3561 r3562  
    3030typedef struct KAVLU32
    3131{
    32     KU32                Key;
    33     KU8                 uchHeight;
    34     struct KAVLU32     *pLeft;
    35     struct KAVLU32     *pRight;
     32    KU32                mKey;
     33    KU8                 mHeight;
     34    struct KAVLU32     *mpLeft;
     35    struct KAVLU32     *mpRight;
    3636} KAVLU32, *PKAVLU32, **PPKAVLU32;
    37 
    38 typedef struct
    39 {
    40     KBOOL               fFromLeft;
    41     KI8                 cEntries;
    42     KU8                 achFlags[32];
    43     PKAVLU32            aEntries[32];
    44 } KAVLU32ENUMDATA, *PKAVLU32ENUMDATA;
    45 
    46 typedef int (* PFNKAVLU32CALLBACK)(KAVLU32 *, void *);
    4737
    4838/*#define KAVL_EQUAL_ALLOWED*/
     
    5343#define KAVL_STD_KEY_COMP
    5444#define KAVLKEY                 KU32
    55 #define KAVLNODECORE            KAVLU32
     45#define KAVLNODE            KAVLU32
    5646#define KAVL_FN(name)           kAvlU32 ## name
    5747#define KAVL_TYPE(prefix,name)  prefix ## KAVLU32 ## name
  • trunk/kStuff/include/k/kAvloU32.h

    r3561 r3562  
    2828#define ___k_kAvloU32_h___
    2929
    30 typedef KU32 KAVLOU32PTR;
     30typedef KI32 KAVLOU32PTR;
    3131
    3232typedef struct KAVLOU32
    3333{
    34     KU32                Key;
    35     KU8                 uchHeight;
    36     KAVLOU32PTR         pLeft;
    37     KAVLOU32PTR         pRight;
     34    KU32                u32;
     35    KU8                 cFloorsToGo;
     36    KAVLOU32PTR         offLeft;
     37    KAVLOU32PTR         offRight;
    3838} KAVLOU32, *PKAVLOU32, **PPKAVLOU32;
    3939
    40 typedef struct
    41 {
    42     KBOOL               fFromLeft;
    43     KI8                 cEntries;
    44     KU8                 achFlags[32];
    45     PKAVLOU32           aEntries[32];
    46 } KAVLOU32ENUMDATA, *PKAVLOU32ENUMDATA;
    47 
    48 typedef int (* PFNKAVLOU32CALLBACK)(KAVLOU32 *, void *);
     40#define mKey                    u32
     41#define mHeight                 cFloorsToGo
     42#define mpLeft                  offLeft
     43#define mpRight                 offRight
    4944
    5045/*#define KAVL_EQUAL_ALLOWED*/
     
    5651#define KAVLKEY                 KU32
    5752#define KAVLTREEPTR             KAVLOU32PTR
    58 #define KAVLNODECORE            KAVLOU32
     53#define KAVLNODE                KAVLOU32
    5954#define KAVL_FN(name)           kAvloU32 ## name
    6055#define KAVL_TYPE(prefix,name)  prefix ## KAVLOU32 ## name
  • trunk/kStuff/include/k/kAvlrU32.h

    r3561 r3562  
    3030typedef struct KAVLRU32
    3131{
    32     KU32                Key;
    33     KU32                KeyLast;
    34     struct KAVLRU32    *pLeft;
    35     struct KAVLRU32    *pRight;
    36     KU8                 uchHeight;
     32    KU32                u32Start;
     33    KU32                u32Last;
     34    struct KAVLRU32    *mpLeft;
     35    struct KAVLRU32    *mpRight;
     36    KU8                 mHeight;
    3737} KAVLRU32, *PKAVLRU32, **PPKAVLRU32;
    3838
    39 typedef struct
    40 {
    41     KBOOL               fFromLeft;
    42     KI8                 cEntries;
    43     KU8                 achFlags[32];
    44     PKAVLRU32           aEntries[32];
    45 } KAVLRU32ENUMDATA, *PKAVLRU32ENUMDATA;
    46 
    47 typedef int (* PFNKAVLRU32CALLBACK)(KAVLRU32 *, void *);
     39#define mKey                    u32Start
     40#define mKeyLast                u32Last
    4841
    4942/*#define KAVL_EQUAL_ALLOWED*/
     
    5447#define KAVL_STD_KEY_COMP
    5548#define KAVLKEY                 KU32
    56 #define KAVLNODECORE            KAVLRU32
     49#define KAVLNODE                KAVLRU32
    5750#define KAVL_FN(name)           kAvlrU32 ## name
    5851#define KAVL_TYPE(prefix,name)  prefix ## KAVLRU32 ## name
Note: See TracChangeset for help on using the changeset viewer.