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

   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 <libhashkit/common.h>
  10
  11 static hashkit_return_t _set_function(struct hashkit_st::hashkit_function_st *self, hashkit_hash_algorithm_t hash_algorithm)
  12 {
  13   if (self == NULL)
  14   {
  15     return HASHKIT_INVALID_ARGUMENT;
  16   }
  17
  18   switch (hash_algorithm)
  19   {
  20   case HASHKIT_HASH_MD5:
  21     self->function= hashkit_md5;
  22     break;
  23
  24   case HASHKIT_HASH_CRC:
  25     self->function= hashkit_crc32;
  26     break;
  27
  28   case HASHKIT_HASH_FNV1_64:
  29     if (libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64))
  30     {
  31       self->function= hashkit_fnv1_64;
  32       break;
  33     }
  34     return HASHKIT_INVALID_ARGUMENT;
  35
  36   case HASHKIT_HASH_FNV1A_64:
  37     if (libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64))
  38     {
  39       self->function= hashkit_fnv1a_64;
  40       break;
  41     }
  42     return HASHKIT_INVALID_ARGUMENT;
  43
  44   case HASHKIT_HASH_FNV1_32:
  45     self->function= hashkit_fnv1_32;
  46     break;
  47
  48   case HASHKIT_HASH_FNV1A_32:
  49     self->function= hashkit_fnv1a_32;
  50     break;
  51
  52   case HASHKIT_HASH_HSIEH:
  53     if (libhashkit_has_algorithm(HASHKIT_HASH_HSIEH))
  54     {
  55       self->function= hashkit_hsieh;
  56       break;
  57     }
  58     return HASHKIT_INVALID_ARGUMENT;
  59
  60   case HASHKIT_HASH_MURMUR3:
  61     if (libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3))
  62     {
  63       self->function= hashkit_murmur3;
  64       break;
  65     }
  66     return HASHKIT_INVALID_ARGUMENT;
  67   case HASHKIT_HASH_MURMUR:
  68     if (libhashkit_has_algorithm(HASHKIT_HASH_MURMUR))
  69     {
  70       self->function= hashkit_murmur;
  71       break;
  72     }
  73     return HASHKIT_INVALID_ARGUMENT;
  74
  75   case HASHKIT_HASH_JENKINS:
  76     self->function= hashkit_jenkins;
  77     break;
  78
  79   case HASHKIT_HASH_CUSTOM:
  80     return HASHKIT_INVALID_ARGUMENT;
  81
  82   case HASHKIT_HASH_DEFAULT:
  83     self->function= hashkit_one_at_a_time;
  84     break;
  85
  86   case HASHKIT_HASH_MAX:
  87     self->function= hashkit_one_at_a_time;
  88     return HASHKIT_INVALID_HASH;
  89   }
  90
  91   self->context= NULL;
  92
  93   return HASHKIT_SUCCESS;
  94 }
  95
  96 hashkit_return_t hashkit_set_function(hashkit_st *self, hashkit_hash_algorithm_t hash_algorithm)
  97 {
  98   return _set_function(&self->base_hash, hash_algorithm);
  99 }
 100
 101 hashkit_return_t hashkit_set_distribution_function(hashkit_st *self, hashkit_hash_algorithm_t hash_algorithm)
 102 {
 103   return _set_function(&self->distribution_hash, hash_algorithm);
 104 }
 105
 106 static hashkit_return_t _set_custom_function(struct hashkit_st::hashkit_function_st *self, hashkit_hash_fn function, void *context)
 107 {
 108   if (self == NULL)
 109   {
 110     return HASHKIT_INVALID_ARGUMENT;
 111   }
 112
 113   if (function)
 114   {
 115     self->function= function;
 116     self->context= context;
 117
 118     return HASHKIT_SUCCESS;
 119   }
 120
 121   return HASHKIT_FAILURE;
 122 }
 123
 124 hashkit_return_t hashkit_set_custom_function(hashkit_st *self, hashkit_hash_fn function, void *context)
 125 {
 126   if (self == NULL)
 127   {
 128     return HASHKIT_INVALID_ARGUMENT;
 129   }
 130
 131
 132   return _set_custom_function(&self->base_hash, function, context);
 133 }
 134
 135 hashkit_return_t hashkit_set_custom_distribution_function(hashkit_st *self, hashkit_hash_fn function, void *context)
 136 {
 137   if (self == NULL)
 138   {
 139     return HASHKIT_INVALID_ARGUMENT;
 140   }
 141
 142   return _set_custom_function(&self->distribution_hash, function, context);
 143 }
 144
 145 static hashkit_hash_algorithm_t get_function_type(const hashkit_hash_fn function)
 146 {
 147   if (function == hashkit_one_at_a_time)
 148   {
 149     return HASHKIT_HASH_DEFAULT;
 150   }
 151   else if (function == hashkit_md5)
 152   {
 153     return HASHKIT_HASH_MD5;
 154   }
 155   else if (function == hashkit_crc32)
 156   {
 157     return HASHKIT_HASH_CRC;
 158   }
 159   else if (function == hashkit_fnv1_64)
 160   {
 161     return HASHKIT_HASH_FNV1_64;
 162   }
 163   else if (function == hashkit_fnv1a_64)
 164   {
 165     return HASHKIT_HASH_FNV1A_64;
 166   }
 167   else if (function == hashkit_fnv1_32)
 168   {
 169     return HASHKIT_HASH_FNV1_32;
 170   }
 171   else if (function == hashkit_fnv1a_32)
 172   {
 173     return HASHKIT_HASH_FNV1A_32;
 174   }
 175   else if (function == hashkit_hsieh)
 176   {
 177     return HASHKIT_HASH_HSIEH;
 178   }
 179   else if (function == hashkit_murmur)
 180   {
 181     return HASHKIT_HASH_MURMUR;
 182   }
 183   else if (function == hashkit_jenkins)
 184   {
 185     return HASHKIT_HASH_JENKINS;
 186   }
 187
 188   return HASHKIT_HASH_CUSTOM;
 189 }
 190
 191 hashkit_hash_algorithm_t hashkit_get_function(const hashkit_st *self)
 192 {
 193   if (self == NULL)
 194   {
 195     return HASHKIT_HASH_DEFAULT;
 196   }
 197
 198   return get_function_type(self->base_hash.function);
 199 }
 200
 201 hashkit_hash_algorithm_t hashkit_get_distribution_function(const hashkit_st *self)
 202 {
 203   if (self == NULL)
 204   {
 205     return HASHKIT_HASH_DEFAULT;
 206   }
 207
 208   return get_function_type(self->distribution_hash.function);
 209 }