* hash now can return its number of members.

[citadel.git] / libcitadel / lib / hash.c

diff --git a/libcitadel/lib/hash.c b/libcitadel/lib/hash.c
index 33048384031b0276d674cfc9ad4bdd2720f8b219..3908121d90c13a13bf54e3f774f8ee49436dd006 100644 (file)
--- a/libcitadel/lib/hash.c
+++ b/libcitadel/lib/hash.c
@@ -48,6 +48,48 @@ struct HashPos {
        long Position;
 };
 
+
+/**
+ * \brief Iterate over the hash and call PrintEntry. 
+ * \param Hash your Hashlist structure
+ * \param Trans is called so you could for example print 'A:' if the next entries are like that.
+ *        Must be aware to receive NULL in both pointers.
+ * \param PrintEntry print entry one by one
+ * \returns the number of items printed
+ */
+int PrintHash(HashList *Hash, TransitionFunc Trans, PrintHashDataFunc PrintEntry)
+{
+       int i;
+       void *Previous;
+       void *Next;
+       const char* KeyStr;
+
+       for (i=0; i < Hash->nMembersUsed; i++) {
+               if (i==0) {
+                       Previous = NULL;
+               }
+               else {
+                       if (Hash->LookupTable[i - 1] == NULL)
+                               Previous = NULL;
+                       else
+                               Previous = Hash->Members[Hash->LookupTable[i-1]->Position]->Data;
+               }
+               if (Hash->LookupTable[i] == NULL) {
+                       KeyStr = "";
+                       Next = NULL;
+               }
+               else {
+                       Next = Hash->Members[Hash->LookupTable[i]->Position]->Data;
+                       KeyStr = Hash->LookupTable[i]->HashKey;
+               }
+
+               Trans(Previous, Next, i % 2);
+               PrintEntry(KeyStr, Next, i % 2);
+       }
+       return i;
+}
+
+
 /**
  * \brief verify the contents of a hash list; here for debugging purposes.
  * \param Hash your Hashlist structure
@@ -55,7 +97,7 @@ struct HashPos {
  * \param Second Functionpointer to allow you to print your payload
  * \returns 0
  */
-int PrintHash(HashList *Hash, PrintHashContent First, PrintHashContent Second)
+int dbg_PrintHash(HashList *Hash, PrintHashContent First, PrintHashContent Second)
 {
        const char *foo;
        const char *bar;
@@ -121,6 +163,12 @@ HashList *NewHash(int Uniq, HashFunc F)
        return NewList;
 }
 
+int GetCount(HashList *Hash)
+{
+       return Hash->nMembersUsed;
+}
+
+
 /**
  * \brief private destructor for one hash element.
  * \param Data an element to free using the user provided destructor, or just plain free
@@ -240,16 +288,14 @@ static void InsertHashItem(HashList *Hash,
        /** but if we should be sorted into a specific place... */
        if ((Hash->nMembersUsed != 0) && 
            (HashPos != Hash->nMembersUsed) ) {
-               long InsertAt;
                long ItemsAfter;
 
                ItemsAfter = Hash->nMembersUsed - HashPos;
-               InsertAt = HashPos;
                /** make space were we can fill us in */
                if (ItemsAfter > 0)
                {
-                       memmove(&Hash->LookupTable[InsertAt + 1],
-                               &Hash->LookupTable[InsertAt],
+                       memmove(&Hash->LookupTable[HashPos + 1],
+                               &Hash->LookupTable[HashPos],
                                ItemsAfter * sizeof(HashKey*));
                } 
        }
@@ -509,6 +555,20 @@ static int SortByKeys(const void *Key1, const void* Key2)
        return strcasecmp(HKey1->HashKey, HKey2->HashKey);
 }
 
+/**
+ * \brief sorting function for sorting the Hash alphabeticaly reverse by their strings
+ * \param Key1 first item
+ * \param Key2 second item
+ */
+static int SortByKeysRev(const void *Key1, const void* Key2)
+{
+       HashKey *HKey1, *HKey2;
+       HKey1 = *(HashKey**) Key1;
+       HKey2 = *(HashKey**) Key2;
+
+       return strcasecmp(HKey2->HashKey, HKey1->HashKey);
+}
+
 /**
  * \brief sorting function to regain hash-sequence and revert tainted status
  * \param Key1 first item
@@ -529,12 +589,14 @@ static int SortByHashKeys(const void *Key1, const void* Key2)
  * Caution: This taints the hashlist, so accessing it later 
  * will be significantly slower! You can un-taint it by SortByHashKeyStr
  * \param Hash the list to sort
+ * \param Order 0/1 Forward/Backward
  */
-void SortByHashKey(HashList *Hash)
+void SortByHashKey(HashList *Hash, int Order)
 {
        if (Hash->nMembersUsed < 2)
                return;
-       qsort(Hash->LookupTable, Hash->nMembersUsed, sizeof(HashKey*), SortByKeys);
+       qsort(Hash->LookupTable, Hash->nMembersUsed, sizeof(HashKey*), 
+             (Order)?SortByKeys:SortByKeysRev);
        Hash->tainted = 1;
 }