ListIndexed

List

Description: List/Link/Node Primitives

Source file: …\genesis3d\OpenSource\Source\list.h

Contents:

Functions: Start, Stop, Create, Destroy, Push, Pop, Peek, Create, Destroy, AddTail, AddHead, CutHead, CutTail, PeekHead, PeekTail, Next, Prev, CutNode, DeleteNode, FreeNode, NodeData, Find, Create, Destroy, Func, Func, Extend, Create, Destroy, Add, CutMax, CutMin, CutKey, Create, Destroy, AddTail, AddHead, CutMax, CutMin, CutKey, PeekMax, PeekMin, Create, Destroy, Add, CutMax, CutMin, CutKey, Grow, Create, Destroy, Add, DeleteNode, Get, WalkNext, NumMembers, SetData, GetData, Key, Data, StringToKey, CutHead, CutTail, ListLen

Types: List, Link, RadixList, RadixLN, RadixLink, Hash, HashNode, LinkNode, Stack

Macros: view

Overview: view

Additions to Genesis3D v1.6: None

Overview:

Note: you must wrap any calls to this module with List_Start() and List_Stop()

Example--Iterate on a list via :

List* pNode;
List* pList;
for( pNode = List_Next(pList); pNode != pList; pNode = List_Next(pNode) )
{
  //do stuff to pNode
}

Example of LN_Walk use:

void doStuffOnAllNodes(LinkNode* pList)


{
  LinkNode* pNode;
  LN_Walk(pNode,pList) {
    doStuff(pNode);
  }
}

Macros:

#define LISTCALL __fastcall

#define zLN_InitList(List) do { (List)->Next = List; (List)->Prev = List; } while(0)

#define zLN_Cut(Node) do { (Node)->Prev->Next = (Node)->Next; (Node)->Next->Prev = (Node)->Prev; zLN_InitList(Node); } while(0)

#define zLN_Fix(Node) do { (Node)->Prev->Next = Node; (Node)->Next->Prev = Node; } while(0)

#define zLN_AddAfter(Node,List) do { (Node)->Prev = List; (Node)->Next = (List)->Next; LN_Fix(Node); } while(0)

#define zLN_AddBefore(Node,List) do { (Node)->Next = List; (Node)->Prev = (List)->Prev; LN_Fix(Node); } while(0)

#define zLN_Walk_Editting(Node,List,Holder) for( Node = (List)->Next; (Node) != (List) && ((Holder) = (Node)->Next) != NULL ; Node = Holder )

#define zLN_Walk(Node,List) for( Node = (List)->Next; (Node) != (List) ; Node = (Node)->Next )

#define zLN_EmptyList(List) ( (List)->Next == (List) )

#define LN_InitList(List) zLN_InitList((LinkNode* )List)

#define LN_Cut(Node) zLN_Cut((LinkNode* )Node)

#define LN_Fix(Node) zLN_Fix((LinkNode* )Node)

#define LN_AddAfter(Node,List) zLN_AddAfter((LinkNode* )Node,(LinkNode* )List)

#define LN_AddBefore(Node,List) zLN_AddBefore((LinkNode* )Node,(LinkNode* )List)

#define LN_Walk(Node,List) zLN_Walk((LinkNode* )Node,(LinkNode* )List)

#define LN_Walk_Editting(Node,List,Holder) zLN_Walk_Editting((LinkNode* )Node,(LinkNode* )List,((LinkNode* )Holder))

#define LN_EmptyList(List) zLN_EmptyList((LinkNode* )List)

#define LN_Prev(Node) (void * )(((LinkNode* )Node)->Prev)

#define LN_Next(Node) (void * )(((LinkNode* )Node)->Next)

#define LN_Null(node) LN_InitList(node)

#define LN_AddHead(list,node) LN_AddAfter(node,list)

#define LN_AddTail(list,node) LN_AddBefore(node,list)

#define LN_IsEmpty LN_EmptyList

#ifdef _DEBUG

#define Stack_Push Stack_Push_Func

#define Stack_Pop Stack_Pop_Func

#else

#define Stack_Push(pStack,Data) *((pStack)->Head)++ = (void * )(Data), ( (pStack)->Head != (pStack)->End ) || Stack_Extend(pStack)

#define Stack_Pop(pStack) ( ((pStack)->Head == (pStack)->Buffer) ? NULL :* ( -- ((pStack)->Head) ) )

#endif

Types:

NOTE: For most of the types below, the contents of these structures have been intentionally left out of the interface, by the designers of this module. Think of them as a handle only.

typedef struct List List;

typedef struct Stack Stack;

typedef struct Link Link;

typedef struct LinkNode LinkNode;

typedef struct RadixList RadixList;

typedef struct RadixLN RadixLN;

typedef struct RadixLink RadixLink;

typedef struct Hash Hash;

typedef struct HashNode HashNode;

LinkNode

struct LinkNode {

LinkNode* Next;

LinkNode* Prev;

};

Stack

//Note: this struct is exposed only in release mode! Don't look into it! Only defined if: #ifndef _DEBUG

struct Stack {

void ** Buffer;

void ** End;

void ** Head;

int members;

};

Functions:

geBoolean List_Start(void);

You must call this before calling any other function in this module

geBoolean List_Stop(void);

After working with functions in this module, you must end with a call to this.

extern Link* LISTCALL Link_Create(void);

extern void LISTCALL Link_Destroy(Link* pLink);

extern void LISTCALL Link_Push(Link* pLink, void * Data);

extern void * LISTCALL Link_Pop(Link* pLink);

extern void * LISTCALL Link_Peek(Link* pLink);

extern List* LISTCALL List_Create(void);

extern void LISTCALL List_Destroy(List* pList);

extern List* LISTCALL List_AddTail(List* pList, void * Data);

extern List* LISTCALL List_AddHead(List* pList, void * Data);

extern void * LISTCALL List_CutHead(List* pList);

Returns a pointer to the node created(?)

extern void * LISTCALL List_CutTail(List* pList);

Returns a pointer to the node created(?)

extern void * LISTCALL List_PeekHead(List* pList);

Returns a pointer to the node created (?)

extern void * LISTCALL List_PeekTail(List* pList);

Returns a pointer to the node created(?)

extern List* LISTCALL List_Next(List* pNode);

extern List* LISTCALL List_Prev(List* pNode);

extern void LISTCALL List_CutNode(List* pNode);

extern void LISTCALL List_DeleteNode(List* pNode);

extern void LISTCALL List_FreeNode(List* pNode);

extern void * LISTCALL List_NodeData(List* pNode);

extern List* List_Find(List* pList, void * Data);

extern Stack* LISTCALL Stack_Create(void);

extern void LISTCALL Stack_Destroy(Stack* pStack);

extern void LISTCALL Stack_Push_Func(Stack* pStack, void * Data);

extern void * LISTCALL Stack_Pop_Func(Stack* pStack);

extern int LISTCALL Stack_Extend(Stack* pStack);

Returns new length

extern RadixList* RadixList_Create(int RadixListMax);

extern void RadixList_Destroy(RadixList* pRadixList);

extern List* RadixList_Add(RadixList* pRadixList, void * Data, int Key);

Returns a pointer to the node created

extern void * RadixList_CutMax(RadixList* pRadixList, int * pMaxKey);

extern void * RadixList_CutMin(RadixList* pRadixList, int * pMinKey);

extern void * RadixList_CutKey(RadixList* pRadixList, int Key);

extern RadixLN* RadixLN_Create(int RadixLNMax);

extern void RadixLN_Destroy(RadixLN* pRadixLN);

extern void RadixLN_AddTail(RadixLN* pRadixLN,LinkNode* LN, int Key);

extern void RadixLN_AddHead(RadixLN* pRadixLN,LinkNode* LN, int Key);

extern LinkNode* RadixLN_CutMax(RadixLN* pRadixLN, int * pMaxKey);

extern LinkNode* RadixLN_CutMin(RadixLN* pRadixLN, int * pMinKey);

extern LinkNode* RadixLN_CutKey(RadixLN* pRadixLN, int Key);

extern LinkNode* RadixLN_PeekMax(RadixLN* pRadixLN, int * pMaxKey);

extern LinkNode* RadixLN_PeekMin(RadixLN* pRadixLN, int * pMinKey);

extern RadixLink* RadixLink_Create(int RadixLinkMax);

extern void RadixLink_Destroy(RadixLink* pRadixLink);

extern void RadixLink_Add(RadixLink* pRadixLink, void * Data, int Key);

extern void * RadixLink_CutMax(RadixLink* pRadixLink, int * pMaxKey);

extern void * RadixLink_CutMin(RadixLink* pRadixLink, int * pMinKey);

extern void * RadixLink_CutKey(RadixLink* pRadixLink, int Key);

extern void RadixLink_Grow(RadixLink* pRadixLink, int NewMax);

extern Hash* Hash_Create(void);

extern void Hash_Destroy(Hash* pHash);

HashNode* LISTCALL Hash_Add(Hash* pHash, uint32 Key, uint32 Data);

void LISTCALL Hash_DeleteNode(Hash* pHash,HashNode* pNode);

HashNode* LISTCALL Hash_Get(Hash* pHash, uint32 Key, uint32* pData);

// pdata is optional

HashNode* LISTCALL Hash_WalkNext(Hash* pHash,HashNode* pCur);

//use pCur == NULL to start walking

uint32 LISTCALL Hash_NumMembers(Hash* pHash);

void HashNode_SetData(HashNode* pNode, uint32 Data);

void HashNode_GetData(HashNode* pNode, uint32* pKey, uint32* pData);

uint32 HashNode_Key(HashNode* pNode);

uint32 HashNode_Data(HashNode* pNode);

uint32 Hash_StringToKey(const char * String);

LinkNode* LISTCALL LN_CutHead(LinkNode* pList);

LinkNode* LISTCALL LN_CutTail(LinkNode* pList);

int LN_ListLen(LinkNode* pList);