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); }