void ListSortNamedItems(ListNode *List)
{
ListNode *Curr=NULL, *Prev=NULL;
int sorted=0;
while (! sorted)
{
sorted=1;
Prev=NULL;
Curr=ListGetNext(List);
while (Curr)
{
if (Prev !=NULL)
{
if (strcmp(Prev->Tag,Curr->Tag) < 0)
{
sorted=0;
ListSwapItems(Prev,Curr);
}
}
Prev=Curr;
Curr=ListGetNext(Curr);
}
}
}
void ListSort(ListNode *List, void *Data, int (*LessThanFunc)(void *, void *, void *))
{
ListNode *Curr=NULL, *Prev=NULL;
int sorted=0;
while (! sorted)
{
sorted=1;
Prev=NULL;
Curr=ListGetNext(List);
while (Curr)
{
if (Prev !=NULL)
{
if ( (*LessThanFunc)(Data,Curr->Item,Prev->Item) )
{
sorted=0;
ListSwapItems(Prev,Curr);
}
}
Prev=Curr;
Curr=ListGetNext(Curr);
}
}
}
ListNode *ListFindNamedItem(ListNode *Head, const char *Name)
{
ListNode *Curr;
int result;
if (! StrLen(Name)) return(NULL);
Curr=ListGetNext(Head);
while (Curr)
{
if (Curr->Jump)
{
if (Head->Flags & LIST_FLAG_CASE) result=strcmp(Curr->Jump->Tag,Name);
else result=strcasecmp(Curr->Jump->Tag,Name);
if (result < 0) Curr=Curr->Jump;
}
if (Curr->Tag)
{
if (Head->Flags & LIST_FLAG_CASE)
{
if (strcmp(Curr->Tag,Name)==0)
{
if (Head->Flags & LIST_FLAG_SELFORG) ListSwapItems(Curr->Prev, Curr);
return(Curr);
}
}
else if (strcasecmp(Curr->Tag,Name)==0)
{
if (Head->Flags & LIST_FLAG_SELFORG) ListSwapItems(Curr->Prev, Curr);
return(Curr);
}
}
Curr=ListGetNext(Curr);
}
return(Curr);
}
ListNode *ListFindItem(ListNode *Head, void *Item)
{
ListNode *Curr;
if (! Item) return(NULL);
Curr=ListGetNext(Head);
while (Curr)
{
if (Curr->Item==Item)
{
if (Head->Flags & LIST_FLAG_SELFORG) ListSwapItems(Curr->Prev, Curr);
return(Curr);
}
Curr=ListGetNext(Curr);
}
return(Curr);
}
ListNode *ListFindNamedItemInsert(ListNode *Root, const char *Name)
{
ListNode *Prev, *Curr, *Next, *Head;
int result=0, count=0;
int hops=0, jumps=0, miss=0;
unsigned long long val;
if (! Root) return(Root);
if (! StrValid(Name)) return(Root);
if (Root->Flags & LIST_FLAG_MAP_HEAD) Head=MapGetChain(Root, Name);
else Head=Root;
//Dont use 'ListGetNext' internally
Curr=Head->Next;
if (! Curr) return(Head);
//if LIST_FLAG_CACHE is set, then the general purpose 'Side' pointer of the head node points to a cached item
if ((Root->Flags & LIST_FLAG_CACHE) && Head->Side && Head->Side->Tag)
{
//use next to hold Head->Side for less typing!
Next=Head->Side;
if (Root->Flags & LIST_FLAG_CASE) result=strcmp(Next->Tag,Name);
else result=strcasecmp(Next->Tag,Name);
if (result==0) return(Next);
//if result < 0 AND ITS AN ORDERED LIST then it means the cached item is ahead of our insert point, so we might as well jump to it
else if ((Root->Flags & LIST_FLAG_ORDERED) && (result < 0)) Curr=Next;
}
//Check last item in list
Prev=Head->Prev;
if (Prev && (Prev != Head) && Prev->Tag)
{
if (Head->Flags & LIST_FLAG_CASE) result=strcmp(Prev->Tag,Name);
else result=strcasecmp(Prev->Tag,Name);
if (result == 0) return(Prev);
if ((Head->Flags & LIST_FLAG_ORDERED) && (result < 1)) return(Prev);
}
Prev=Head;
while (Curr)
{
Next=Curr->Next;
if (Curr->Tag)
{
if (Root->Flags & LIST_FLAG_CASE) result=strcmp(Curr->Tag,Name);
else result=strcasecmp(Curr->Tag,Name);
if (result==0)
{
if (Root->Flags & LIST_FLAG_SELFORG) ListSwapItems(Curr->Prev, Curr);
return(Curr);
}
if ((result > 0) && (Root->Flags & LIST_FLAG_ORDERED)) return(Prev);
//Can only get here if it's not a match
if (Root->Flags & LIST_FLAG_TIMEOUT)
{
val=ListNodeGetTime(Curr);
if ((val > 0) && (val < GetTime(TIME_CACHED)))
{
Destroy(Curr->Item);
ListDeleteNode(Curr);
}
}
}
hops++;
count++;
Prev=Curr;
Curr=Next;
}
return(Prev);
}
ListNode *ListFindNamedItemInsert(ListNode *Head, const char *Name)
{
ListNode *Prev, *Curr, *Start=NULL;
int result=0, count=0;
int hops=0, jumps=0, miss=0;
if (! Head) return(Head);
if (! StrLen(Name)) return(Head);
Curr=ListGetNext(Head);
if (! Curr) return(Head);
//Check last item in list
Prev=Head->Prev;
if (Prev && (Prev != Head) && Prev->Tag)
{
if (Head->Flags & LIST_FLAG_CASE) result=strcmp(Prev->Tag,Name);
else result=strcasecmp(Prev->Tag,Name);
if ((Head->Flags & LIST_FLAG_ORDERED) && (result < 1)) return(Prev);
}
/*
if ((Head->Flags & LIST_FLAG_CACHE) && (Head->Jump))
{
Prev=Head->Jump;
if (Prev->Tag)
{
if (Head->Flags & LIST_FLAG_CASE) result=strcmp(Prev->Tag,Name);
else result=strcasecmp(Prev->Tag,Name);
if (result < 1) Curr=Prev;
}
}
*/
Prev=Head;
while (Curr)
{
if (Curr->Jump && Curr->Jump->Tag)
{
if (Head->Flags & LIST_FLAG_CASE) result=strcmp(Curr->Jump->Tag,Name);
else result=strcasecmp(Curr->Jump->Tag,Name);
if (result < 1)
{
if ((result < 0) && Curr->Jump->Next) Curr->Jump=Curr->Jump->Next;
Curr=Curr->Jump;
jumps++;
count=0;
}
else miss++;
} else if (! Start) Start=Curr;
if (Curr->Tag)
{
if (Head->Flags & LIST_FLAG_CASE) result=strcmp(Curr->Tag,Name);
else result=strcasecmp(Curr->Tag,Name);
if (result==0)
{
if (Head->Flags & LIST_FLAG_SELFORG) ListSwapItems(Curr->Prev, Curr);
if (Head->Flags & LIST_FLAG_CACHE) Head->Jump=Curr;
return(Curr);
}
if ((result > 0) && (Head->Flags & LIST_FLAG_ORDERED))
{
return(Prev);
}
}
hops++;
count++;
Prev=Curr;
Curr=ListGetNext(Curr);
}
return(Prev);
}
