* \brief Anonymous Hash Iterator Object. used for traversing the whole array from outside
*/
long Position;
+ int StepWidth;
};
free(Data->Data);
}
+/**
+ * \brief Destructor for nested hashes
+ */
+void HDeleteHash(void *vHash)
+{
+ HashList *FreeMe = (HashList*)vHash;
+ DeleteHash(&FreeMe);
+}
+
/**
* \brief destroy a hashlist and all of its members
* Crashing? do 'print *FreeMe->LookupTable[i]'
return SearchPos;
}
+
+/**
+ * \brief another hashing algorithm; treat it as just a pointer to long.
+ * \param str Our pointer to the long value
+ * \param len the length of the data pointed to; needs to be sizeof int, else we won't use it!
+ * \returns the calculated hash value
+ */
+int Flathash(const char *str, long len)
+{
+ if (len != sizeof (int))
+ return 0;
+ else return *(int*)str;
+}
+
/**
* \brief private abstract wrapper around the hashing algorithm
* \param HKey the hash string
/**
* \brief creates a hash-linear iterator object
+ * \param Hash the list we reference
+ * \param in which step width should we iterate?
+ * If negative, the last position matching the
+ * step-raster is provided.
* \returns the hash iterator
*/
-HashPos *GetNewHashPos(void)
+HashPos *GetNewHashPos(HashList *Hash, int StepWidth)
{
HashPos *Ret;
Ret = (HashPos*)malloc(sizeof(HashPos));
- Ret->Position = 0;
+ if (StepWidth != 0)
+ Ret->StepWidth = StepWidth;
+ else
+ Ret->StepWidth = 1;
+ if (Ret->StepWidth < 0) {
+ Ret->Position = (Hash->nMembersUsed % (-Ret->StepWidth))
+ * (-Ret->StepWidth);
+ }
+ else {
+ Ret->Position = 0;
+ }
return Ret;
}
+/**
+ * \brief retrieve the counter from the itteratoor
+ * \param the Iterator to analyze
+ * \returns the n'th hashposition we point at
+ */
+int GetHashPosCounter(HashPos *At)
+{
+ return At->Position;
+}
+
/**
* \brief frees a linear hash iterator
*/
{
long PayloadPos;
- if ((Hash == NULL) || (Hash->nMembersUsed <= At->Position))
+ if ((Hash == NULL) || (At->Position >= Hash->nMembersUsed))
return 0;
*HKLen = Hash->LookupTable[At->Position]->HKLen;
*HashKey = Hash->LookupTable[At->Position]->HashKey;
PayloadPos = Hash->LookupTable[At->Position]->Position;
*Data = Hash->Members[PayloadPos]->Data;
- At->Position++;
+
+ At->Position += At->StepWidth;
+ if (At->Position > Hash->nMembersUsed) {
+ At->Position = Hash->nMembersUsed;
+ return 0;
+ }
return 1;
}
free(ptr);
}
+/*
+ * Generic function to free a reference.
+ * since a reference actualy isn't needed to be freed, do nothing.
+ */
+void reference_free_handler(void *ptr)
+{
+ return;
+}
+