Added full support for custom hash functions.

diff --git a/libhashkit/algorithm.h b/libhashkit/algorithm.h
index f575222e09e5245229ee1c181d0edeeac5186f91..465d0b5d3ff9fe4aa4aaf8590029bea9276085d2 100644 (file)
--- a/libhashkit/algorithm.h
+++ b/libhashkit/algorithm.h
@@ -19,27 +19,68 @@ extern "C" {
 #endif
 
 HASHKIT_API
-uint32_t hashkit_one_at_a_time(const char *key, size_t key_length);
+uint32_t libhashkit_one_at_a_time(const char *key, size_t key_length);
+
 HASHKIT_API
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+uint32_t libhashkit_fnv1_64(const char *key, size_t key_length);
+
 HASHKIT_API
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+uint32_t libhashkit_fnv1a_64(const char *key, size_t key_length);
+
 HASHKIT_API
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+uint32_t libhashkit_fnv1_32(const char *key, size_t key_length);
+
 HASHKIT_API
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+uint32_t libhashkit_fnv1a_32(const char *key, size_t key_length);
+
 HASHKIT_API
-uint32_t hashkit_crc32(const char *key, size_t key_length);
+uint32_t libhashkit_crc32(const char *key, size_t key_length);
+
 #ifdef HAVE_HSIEH_HASH
 HASHKIT_API
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
+uint32_t libhashkit_hsieh(const char *key, size_t key_length);
 #endif
+
 HASHKIT_API
-uint32_t hashkit_murmur(const char *key, size_t key_length);
+uint32_t libhashkit_murmur(const char *key, size_t key_length);
+
 HASHKIT_API
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
+uint32_t libhashkit_jenkins(const char *key, size_t key_length);
+
 HASHKIT_API
-uint32_t hashkit_md5(const char *key, size_t key_length);
+uint32_t libhashkit_md5(const char *key, size_t key_length);
+
+HASHKIT_LOCAL
+uint32_t hashkit_one_at_a_time(const char *key, size_t key_length, void *context);
+
+HASHKIT_LOCAL
+uint32_t hashkit_fnv1_64(const char *key, size_t key_length, void *context);
+
+HASHKIT_LOCAL
+uint32_t hashkit_fnv1a_64(const char *key, size_t key_length, void *context);
+
+HASHKIT_LOCAL
+uint32_t hashkit_fnv1_32(const char *key, size_t key_length, void *context);
+
+HASHKIT_LOCAL
+uint32_t hashkit_fnv1a_32(const char *key, size_t key_length, void *context);
+
+HASHKIT_LOCAL
+uint32_t hashkit_crc32(const char *key, size_t key_length, void *context);
+
+#ifdef HAVE_HSIEH_HASH
+HASHKIT_LOCAL
+uint32_t hashkit_hsieh(const char *key, size_t key_length, void *context);
+#endif
+
+HASHKIT_LOCAL
+uint32_t hashkit_murmur(const char *key, size_t key_length, void *context);
+
+HASHKIT_LOCAL
+uint32_t hashkit_jenkins(const char *key, size_t key_length, void *context);
+
+HASHKIT_LOCAL
+uint32_t hashkit_md5(const char *key, size_t key_length, void *context);
 
 #ifdef __cplusplus
 }

diff --git a/libhashkit/crc32.c b/libhashkit/crc32.c
index 023abbb657c347b1777a52e7d2bd05cf201636a8..6db04783acd5ed3e139d11b0e59737730f0416b7 100644 (file)
--- a/libhashkit/crc32.c
+++ b/libhashkit/crc32.c
@@ -73,7 +73,7 @@ static const uint32_t crc32tab[256] = {
   0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 };
 
-uint32_t hashkit_crc32(const char *key, size_t key_length)
+uint32_t hashkit_crc32(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   uint64_t x;
   uint32_t crc= UINT32_MAX;

diff --git a/libhashkit/fnv.c b/libhashkit/fnv.c
index c4ad06683839a33eb97e50df2ff8ed33ec16c72b..ee3754d84371a0590e18328189d0d10b078375d3 100644 (file)
--- a/libhashkit/fnv.c
+++ b/libhashkit/fnv.c
@@ -14,7 +14,7 @@ static uint64_t FNV_64_PRIME= UINT64_C(0x100000001b3);
 static uint32_t FNV_32_INIT= 2166136261UL;
 static uint32_t FNV_32_PRIME= 16777619;
 
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length)
+uint32_t hashkit_fnv1_64(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   /* Thanks to pierre@demartines.com for the pointer */
   uint64_t hash= FNV_64_INIT;
@@ -28,7 +28,7 @@ uint32_t hashkit_fnv1_64(const char *key, size_t key_length)
   return (uint32_t)hash;
 }
 
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length)
+uint32_t hashkit_fnv1a_64(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   uint32_t hash= (uint32_t) FNV_64_INIT;
 
@@ -42,7 +42,7 @@ uint32_t hashkit_fnv1a_64(const char *key, size_t key_length)
   return hash;
 }
 
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length)
+uint32_t hashkit_fnv1_32(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   uint32_t hash= FNV_32_INIT;
 
@@ -56,7 +56,7 @@ uint32_t hashkit_fnv1_32(const char *key, size_t key_length)
   return hash;
 }
 
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length)
+uint32_t hashkit_fnv1a_32(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   uint32_t hash= FNV_32_INIT;
 

diff --git a/libhashkit/hashkit.c b/libhashkit/hashkit.c
index 64158f989f671f1b003b79c1b92cd9478b6de07c..cd33c4e7689e0dbc33141ee7007430b896a5deac 100644 (file)
--- a/libhashkit/hashkit.c
+++ b/libhashkit/hashkit.c
@@ -76,7 +76,7 @@ hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *source)
 
 uint32_t hashkit_generate_value(const hashkit_st *self, const char *key, size_t key_length)
 {
-  return self->base_hash.function(key, key_length);
+  return self->base_hash.function(key, key_length, self->base_hash.context);
 }
 
 hashkit_return_t hashkit_set_base_function(hashkit_st *self, hashkit_hash_algorithm_t hash_algorithm)
@@ -146,29 +146,29 @@ uint32_t libhashkit_generate_value(const char *key, size_t key_length, hashkit_h
   switch (hash_algorithm)
   {
   case HASHKIT_HASH_DEFAULT:
-    return hashkit_one_at_a_time(key, key_length);
+    return libhashkit_one_at_a_time(key, key_length);
   case HASHKIT_HASH_MD5:
-    return hashkit_md5(key, key_length);
+    return libhashkit_md5(key, key_length);
   case HASHKIT_HASH_CRC:
-    return hashkit_crc32(key, key_length);
+    return libhashkit_crc32(key, key_length);
   case HASHKIT_HASH_FNV1_64:
-    return hashkit_fnv1_64(key, key_length);
+    return libhashkit_fnv1_64(key, key_length);
   case HASHKIT_HASH_FNV1A_64:
-    return hashkit_fnv1a_64(key, key_length);
+    return libhashkit_fnv1a_64(key, key_length);
   case HASHKIT_HASH_FNV1_32:
-    return hashkit_fnv1_32(key, key_length);
+    return libhashkit_fnv1_32(key, key_length);
   case HASHKIT_HASH_FNV1A_32:
-    return hashkit_fnv1a_32(key, key_length);
+    return libhashkit_fnv1a_32(key, key_length);
   case HASHKIT_HASH_HSIEH:
 #ifdef HAVE_HSIEH_HASH
-    return hashkit_hsieh(key, key_length);
+    return libhashkit_hsieh(key, key_length);
 #else
     return 1;
 #endif
   case HASHKIT_HASH_MURMUR:
-    return hashkit_murmur(key, key_length);
+    return libhashkit_murmur(key, key_length);
   case HASHKIT_HASH_JENKINS:
-    return hashkit_jenkins(key, key_length);
+    return libhashkit_jenkins(key, key_length);
   case HASHKIT_HASH_MAX:
   default:
 #ifdef HAVE_DEBUG

diff --git a/libhashkit/hsieh.c b/libhashkit/hsieh.c
index 9060bba030e2f40441f91f58446fb59e38227443..46cc241e330125249466b225e96976e817d634ad 100644 (file)
--- a/libhashkit/hsieh.c
+++ b/libhashkit/hsieh.c
@@ -17,7 +17,7 @@
                       +(uint32_t)(((const uint8_t *)(d))[0]) )
 #endif
 
-uint32_t hashkit_hsieh(const char *key, size_t key_length)
+uint32_t hashkit_hsieh(const char *key, size_t key_length, void *context__attribute__((unused)))
 {
   uint32_t hash = 0, tmp;
   int rem;

diff --git a/libhashkit/include.am b/libhashkit/include.am
index f8aa79f58d9bead690a25f8be5946fb4c5b3b1e9..7bcd78019a54785e51f1c5ee92e4e722222bde7b 100644 (file)
--- a/libhashkit/include.am
+++ b/libhashkit/include.am
@@ -23,8 +23,9 @@ noinst_HEADERS+= \
                 libhashkit/common.h
 
 libhashkit_libhashkit_la_SOURCES= \
-                                 libhashkit/crc32.c \
+                                 libhashkit/algorithm.c \
                                  libhashkit/behavior.c \
+                                 libhashkit/crc32.c \
                                  libhashkit/fnv.c \
                                  libhashkit/hashkit.c \
                                  libhashkit/jenkins.c \

diff --git a/libhashkit/jenkins.c b/libhashkit/jenkins.c
index 29d9454e3b229ed0ea872e9d92ef6340ff804aa3..b684d7a061de50bc6d11af0a12fb3e6a09ebab66 100644 (file)
--- a/libhashkit/jenkins.c
+++ b/libhashkit/jenkins.c
@@ -56,7 +56,7 @@ use a bitmask.  For example, if you need only 10 bits, do
 In which case, the hash table should have hashsize(10) elements.
 */
 
-uint32_t hashkit_jenkins(const char *key, size_t length)
+uint32_t hashkit_jenkins(const char *key, size_t length, void *context __attribute__((unused)))
 {
   uint32_t a,b,c;                                          /* internal state */
   union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */

diff --git a/libhashkit/md5.c b/libhashkit/md5.c
index d550c77300c94d493da827251bf65de6a525ca7f..a968548d6c8958df8a6499048143a09be37122ab 100644 (file)
--- a/libhashkit/md5.c
+++ b/libhashkit/md5.c
@@ -352,7 +352,7 @@ unsigned int len)
    (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
 }
 
-uint32_t hashkit_md5(const char *key, size_t key_length)
+uint32_t hashkit_md5(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   unsigned char results[16];
 

diff --git a/libhashkit/murmur.c b/libhashkit/murmur.c
index cd5e6419ab001c5cfdd3800e118e723585c8355b..a18ac403c9b716ef7f4879748b7c63994f643f4a 100644 (file)
--- a/libhashkit/murmur.c
+++ b/libhashkit/murmur.c
@@ -17,7 +17,7 @@
 
 #include "common.h"
 
-uint32_t hashkit_murmur(const char *key, size_t length)
+uint32_t hashkit_murmur(const char *key, size_t length, void *context __attribute__((unused)))
 {
   /* 
     'm' and 'r' are mixing constants generated offline.  They're not

diff --git a/libhashkit/one_at_a_time.c b/libhashkit/one_at_a_time.c
index ab106f1d69e0ca111f8fcf67b7299fde529c5f7e..579d0445b39fa65ebe9570c40e2dfc001778e27c 100644 (file)
--- a/libhashkit/one_at_a_time.c
+++ b/libhashkit/one_at_a_time.c
@@ -13,7 +13,7 @@ http://en.wikipedia.org/wiki/Jenkins_hash_function
 
 #include "common.h"
 
-uint32_t hashkit_one_at_a_time(const char *key, size_t key_length)
+uint32_t hashkit_one_at_a_time(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   const char *ptr= key;
   uint32_t value= 0;

diff --git a/libhashkit/types.h b/libhashkit/types.h
index fadb4d939322704d3955830c019951466afe056b..b3ea7346b28dafe2a84ef15aec9a5a67ed0aab8f 100644 (file)
--- a/libhashkit/types.h
+++ b/libhashkit/types.h
@@ -48,7 +48,7 @@ typedef enum
 
 
 typedef struct hashkit_st hashkit_st;
-typedef uint32_t (*hashkit_hash_fn)(const char *key, size_t key_length);
+typedef uint32_t (*hashkit_hash_fn)(const char *key, size_t key_length, void *context);
 
 #ifdef __cplusplus
 }

diff --git a/tests/hashkit_functions.c b/tests/hashkit_functions.c
index 0e4a894da8f55d78f7ea1cfd0ab6f7866bc116e2..d97b40c8cf57d8401ab4952548692b1b2c2f8a3a 100644 (file)
--- a/tests/hashkit_functions.c
+++ b/tests/hashkit_functions.c
@@ -122,7 +122,7 @@ static test_return_t one_at_a_time_run (hashkit_st *hashk __attribute__((unused)
   {
     uint32_t hash_val;
 
-    hash_val= hashkit_one_at_a_time(*ptr, strlen(*ptr));
+    hash_val= libhashkit_one_at_a_time(*ptr, strlen(*ptr));
     test_true(one_at_a_time_values[x] == hash_val);
   }
 
@@ -138,7 +138,7 @@ static test_return_t md5_run (hashkit_st *hashk __attribute__((unused)))
   {
     uint32_t hash_val;
 
-    hash_val= hashkit_md5(*ptr, strlen(*ptr));
+    hash_val= libhashkit_md5(*ptr, strlen(*ptr));
     test_true(md5_values[x] == hash_val);
   }
 
@@ -154,7 +154,7 @@ static test_return_t crc_run (hashkit_st *hashk __attribute__((unused)))
   {
     uint32_t hash_val;
 
-    hash_val= hashkit_crc32(*ptr, strlen(*ptr));
+    hash_val= libhashkit_crc32(*ptr, strlen(*ptr));
     assert(crc_values[x] == hash_val);
   }
 
@@ -170,7 +170,7 @@ static test_return_t fnv1_64_run (hashkit_st *hashk __attribute__((unused)))
   {
     uint32_t hash_val;
 
-    hash_val= hashkit_fnv1_64(*ptr, strlen(*ptr));
+    hash_val= libhashkit_fnv1_64(*ptr, strlen(*ptr));
     assert(fnv1_64_values[x] == hash_val);
   }
 
@@ -186,7 +186,7 @@ static test_return_t fnv1a_64_run (hashkit_st *hashk __attribute__((unused)))
   {
     uint32_t hash_val;
 
-    hash_val= hashkit_fnv1a_64(*ptr, strlen(*ptr));
+    hash_val= libhashkit_fnv1a_64(*ptr, strlen(*ptr));
     assert(fnv1a_64_values[x] == hash_val);
   }
 
@@ -203,7 +203,7 @@ static test_return_t fnv1_32_run (hashkit_st *hashk __attribute__((unused)))
   {
     uint32_t hash_val;
 
-    hash_val= hashkit_fnv1_32(*ptr, strlen(*ptr));
+    hash_val= libhashkit_fnv1_32(*ptr, strlen(*ptr));
     assert(fnv1_32_values[x] == hash_val);
   }
 
@@ -219,7 +219,7 @@ static test_return_t fnv1a_32_run (hashkit_st *hashk __attribute__((unused)))
   {
     uint32_t hash_val;
 
-    hash_val= hashkit_fnv1a_32(*ptr, strlen(*ptr));
+    hash_val= libhashkit_fnv1a_32(*ptr, strlen(*ptr));
     assert(fnv1a_32_values[x] == hash_val);
   }
 
@@ -236,7 +236,7 @@ static test_return_t hsieh_run (hashkit_st *hashk __attribute__((unused)))
     uint32_t hash_val;
 
 #ifdef HAVE_HSIEH_HASH
-    hash_val= hashkit_hsieh(*ptr, strlen(*ptr));
+    hash_val= libhashkit_hsieh(*ptr, strlen(*ptr));
 #else
     hash_val= 1;
 #endif
@@ -258,7 +258,7 @@ static test_return_t murmur_run (hashkit_st *hashk __attribute__((unused)))
   {
     uint32_t hash_val;
 
-    hash_val= hashkit_murmur(*ptr, strlen(*ptr));
+    hash_val= libhashkit_murmur(*ptr, strlen(*ptr));
     assert(murmur_values[x] == hash_val);
   }
 
@@ -276,7 +276,7 @@ static test_return_t jenkins_run (hashkit_st *hashk __attribute__((unused)))
   {
     uint32_t hash_val;
 
-    hash_val= hashkit_jenkins(*ptr, strlen(*ptr));
+    hash_val= libhashkit_jenkins(*ptr, strlen(*ptr));
     assert(jenkins_values[x] == hash_val);
   }
 
@@ -373,6 +373,12 @@ static test_return_t hashkit_set_base_function_test(hashkit_st *hashk)
   return TEST_SUCCESS;
 }
 
+static uint32_t hash_test_function(const char *string, size_t string_length, void *context)
+{
+  (void)context;
+  return libhashkit_md5(string, string_length);
+}
+
 static test_return_t hashkit_set_base_function_custom_test(hashkit_st *hashk)
 {
   hashkit_return_t rc;
@@ -380,7 +386,7 @@ static test_return_t hashkit_set_base_function_custom_test(hashkit_st *hashk)
   const char **ptr;
 
 
-  rc= hashkit_set_base_function_custom(hashk, hashkit_md5, NULL);
+  rc= hashkit_set_base_function_custom(hashk, hash_test_function, NULL);
   test_true(rc == HASHKIT_SUCCESS);
 
   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)