git.m6w6.name Git - awesomized/libmemcached/blob - libhashkit/function.c

   1 /* HashKit
   2  * Copyright (C) 2010 Brian Aker
   3  * All rights reserved.
   4  *
   5  * Use and distribution licensed under the BSD license.  See
   6  * the COPYING file in the parent directory for full text.
   7  */
   8
   9 #include "common.h"
  10
  11 uint32_t hashkit_generate_value(const hashkit_st *self, const char *key, size_t key_length)
  12 {
  13   return self->base_hash.function(key, key_length, self->base_hash.context);
  14 }
  15
  16 static hashkit_return_t _set_function(struct hashkit_function_st *self, hashkit_hash_algorithm_t hash_algorithm)
  17 {
  18   switch (hash_algorithm)
  19   {
  20   case HASHKIT_HASH_DEFAULT:
  21     self->function= hashkit_one_at_a_time;
  22     break;
  23   case HASHKIT_HASH_MD5:
  24     self->function= hashkit_md5;
  25     break;
  26   case HASHKIT_HASH_CRC:
  27     self->function= hashkit_crc32;
  28     break;
  29   case HASHKIT_HASH_FNV1_64:
  30     self->function= hashkit_fnv1_64;
  31     break;
  32   case HASHKIT_HASH_FNV1A_64:
  33     self->function= hashkit_fnv1a_64;
  34     break;
  35   case HASHKIT_HASH_FNV1_32:
  36     self->function= hashkit_fnv1_32;
  37     break;
  38   case HASHKIT_HASH_FNV1A_32:
  39     self->function= hashkit_fnv1a_32;
  40     break;
  41   case HASHKIT_HASH_HSIEH:
  42 #ifdef HAVE_HSIEH_HASH
  43     self->function= hashkit_hsieh;
  44     break;
  45 #else
  46     return HASHKIT_FAILURE;
  47 #endif
  48   case HASHKIT_HASH_MURMUR:
  49     self->function= hashkit_murmur;
  50     break;
  51   case HASHKIT_HASH_JENKINS:
  52     self->function= hashkit_jenkins;
  53     break;
  54   case HASHKIT_HASH_CUSTOM:
  55   case HASHKIT_HASH_MAX:
  56   default:
  57     return HASHKIT_FAILURE;
  58     break;
  59   }
  60
  61   self->context= NULL;
  62
  63   return HASHKIT_SUCCESS;
  64 }
  65
  66 hashkit_return_t hashkit_set_function(hashkit_st *self, hashkit_hash_algorithm_t hash_algorithm)
  67 {
  68   return _set_function(&self->base_hash, hash_algorithm);
  69 }
  70
  71 hashkit_return_t hashkit_set_distribution_function(hashkit_st *self, hashkit_hash_algorithm_t hash_algorithm)
  72 {
  73   return _set_function(&self->distribution_hash, hash_algorithm);
  74 }
  75
  76 static hashkit_return_t _set_custom_function(struct hashkit_function_st *self, hashkit_hash_fn function, void *context)
  77 {
  78   if (function)
  79   {
  80     self->function= function;
  81     self->context= context;
  82
  83     return HASHKIT_SUCCESS;
  84   }
  85
  86   return HASHKIT_FAILURE;
  87 }
  88
  89 hashkit_return_t hashkit_set_custom_function(hashkit_st *self, hashkit_hash_fn function, void *context)
  90 {
  91   return _set_custom_function(&self->base_hash, function, context);
  92 }
  93
  94 hashkit_return_t hashkit_set_custom_distribution_function(hashkit_st *self, hashkit_hash_fn function, void *context)
  95 {
  96   return _set_custom_function(&self->distribution_hash, function, context);
  97 }
  98
  99 static hashkit_hash_algorithm_t get_function_type(const hashkit_hash_fn function)
 100 {
 101   if (function == hashkit_one_at_a_time)
 102   {
 103     return HASHKIT_HASH_DEFAULT;
 104   }
 105   else if (function == hashkit_md5)
 106   {
 107     return HASHKIT_HASH_MD5;
 108   }
 109   else if (function == hashkit_crc32)
 110   {
 111     return HASHKIT_HASH_CRC;
 112   }
 113   else if (function == hashkit_fnv1_64)
 114   {
 115     return HASHKIT_HASH_FNV1_64;
 116   }
 117   else if (function == hashkit_fnv1a_64)
 118   {
 119     return HASHKIT_HASH_FNV1A_64;
 120   }
 121   else if (function == hashkit_fnv1_32)
 122   {
 123     return HASHKIT_HASH_FNV1_32;
 124   }
 125   else if (function == hashkit_fnv1a_32)
 126   {
 127     return HASHKIT_HASH_FNV1A_32;
 128   }
 129 #ifdef HAVE_HSIEH_HASH
 130   else if (function == hashkit_hsieh)
 131   {
 132     return HASHKIT_HASH_HSIEH;
 133   }
 134 #endif
 135   else if (function == hashkit_murmur)
 136   {
 137     return HASHKIT_HASH_MURMUR;
 138   }
 139   else if (function == hashkit_jenkins)
 140   {
 141     return HASHKIT_HASH_JENKINS;
 142   }
 143
 144   return HASHKIT_HASH_CUSTOM;
 145 }
 146
 147 hashkit_hash_algorithm_t hashkit_get_function(const hashkit_st *self)
 148 {
 149   return get_function_type(self->base_hash.function);
 150 }
 151
 152 hashkit_hash_algorithm_t hashkit_get_distribution_function(const hashkit_st *self)
 153 {
 154   return get_function_type(self->distribution_hash.function);
 155 }
 156
 157 uint32_t libhashkit_generate_value(const char *key, size_t key_length, hashkit_hash_algorithm_t hash_algorithm)
 158 {
 159   switch (hash_algorithm)
 160   {
 161   case HASHKIT_HASH_DEFAULT:
 162     return libhashkit_one_at_a_time(key, key_length);
 163   case HASHKIT_HASH_MD5:
 164     return libhashkit_md5(key, key_length);
 165   case HASHKIT_HASH_CRC:
 166     return libhashkit_crc32(key, key_length);
 167   case HASHKIT_HASH_FNV1_64:
 168     return libhashkit_fnv1_64(key, key_length);
 169   case HASHKIT_HASH_FNV1A_64:
 170     return libhashkit_fnv1a_64(key, key_length);
 171   case HASHKIT_HASH_FNV1_32:
 172     return libhashkit_fnv1_32(key, key_length);
 173   case HASHKIT_HASH_FNV1A_32:
 174     return libhashkit_fnv1a_32(key, key_length);
 175   case HASHKIT_HASH_HSIEH:
 176 #ifdef HAVE_HSIEH_HASH
 177     return libhashkit_hsieh(key, key_length);
 178 #else
 179     return 1;
 180 #endif
 181   case HASHKIT_HASH_MURMUR:
 182     return libhashkit_murmur(key, key_length);
 183   case HASHKIT_HASH_JENKINS:
 184     return libhashkit_jenkins(key, key_length);
 185   case HASHKIT_HASH_CUSTOM:
 186   case HASHKIT_HASH_MAX:
 187   default:
 188 #ifdef HAVE_DEBUG
 189     fprintf(stderr, "hashkit_hash_t was extended but libhashkit_generate_value was not updated\n");
 190     fflush(stderr);
 191     assert(0);
 192 #endif
 193     break;
 194   }
 195
 196   return 1;
 197 }