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

   1 /*
   2     +--------------------------------------------------------------------+
   3     | libmemcached - C/C++ Client Library for memcached                  |
   4     +--------------------------------------------------------------------+
   5     | Redistribution and use in source and binary forms, with or without |
   6     | modification, are permitted under the terms of the BSD license.    |
   7     | You should have received a copy of the license in a bundled file   |
   8     | named LICENSE; in case you did not receive a copy you can review   |
   9     | the terms online at: https://opensource.org/licenses/BSD-3-Clause  |
  10     +--------------------------------------------------------------------+
  11     | Copyright (c) 2006-2014 Brian Aker   https://datadifferential.com/ |
  12     | Copyright (c) 2020 Michael Wallner   <mike@php.net>                |
  13     +--------------------------------------------------------------------+
  14 */
  15
  16 #include "libhashkit/common.h"
  17
  18 static hashkit_return_t _set_function(struct hashkit_st::hashkit_function_st *self,
  19                                       hashkit_hash_algorithm_t hash_algorithm) {
  20   if (self == NULL) {
  21     return HASHKIT_INVALID_ARGUMENT;
  22   }
  23
  24   switch (hash_algorithm) {
  25   case HASHKIT_HASH_MD5: self->function = hashkit_md5; break;
  26
  27   case HASHKIT_HASH_CRC: self->function = hashkit_crc32; break;
  28
  29   case HASHKIT_HASH_FNV1_64:
  30     if (libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64)) {
  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       self->function = hashkit_fnv1a_64;
  39       break;
  40     }
  41     return HASHKIT_INVALID_ARGUMENT;
  42
  43   case HASHKIT_HASH_FNV1_32: self->function = hashkit_fnv1_32; break;
  44
  45   case HASHKIT_HASH_FNV1A_32: self->function = hashkit_fnv1a_32; break;
  46
  47   case HASHKIT_HASH_HSIEH:
  48     if (libhashkit_has_algorithm(HASHKIT_HASH_HSIEH)) {
  49       self->function = hashkit_hsieh;
  50       break;
  51     }
  52     return HASHKIT_INVALID_ARGUMENT;
  53
  54   case HASHKIT_HASH_MURMUR3:
  55     if (libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3)) {
  56       self->function = hashkit_murmur3;
  57       break;
  58     }
  59     return HASHKIT_INVALID_ARGUMENT;
  60   case HASHKIT_HASH_MURMUR:
  61     if (libhashkit_has_algorithm(HASHKIT_HASH_MURMUR)) {
  62       self->function = hashkit_murmur;
  63       break;
  64     }
  65     return HASHKIT_INVALID_ARGUMENT;
  66
  67   case HASHKIT_HASH_JENKINS: self->function = hashkit_jenkins; break;
  68
  69   case HASHKIT_HASH_CUSTOM: return HASHKIT_INVALID_ARGUMENT;
  70
  71   case HASHKIT_HASH_DEFAULT: self->function = hashkit_one_at_a_time; break;
  72
  73   case HASHKIT_HASH_MAX: self->function = hashkit_one_at_a_time; return HASHKIT_INVALID_HASH;
  74   }
  75
  76   self->context = NULL;
  77
  78   return HASHKIT_SUCCESS;
  79 }
  80
  81 hashkit_return_t hashkit_set_function(hashkit_st *self, hashkit_hash_algorithm_t hash_algorithm) {
  82   return _set_function(&self->base_hash, hash_algorithm);
  83 }
  84
  85 hashkit_return_t hashkit_set_distribution_function(hashkit_st *self,
  86                                                    hashkit_hash_algorithm_t hash_algorithm) {
  87   return _set_function(&self->distribution_hash, hash_algorithm);
  88 }
  89
  90 static hashkit_return_t _set_custom_function(struct hashkit_st::hashkit_function_st *self,
  91                                              hashkit_hash_fn function, void *context) {
  92   if (self == NULL) {
  93     return HASHKIT_INVALID_ARGUMENT;
  94   }
  95
  96   if (function) {
  97     self->function = function;
  98     self->context = context;
  99
 100     return HASHKIT_SUCCESS;
 101   }
 102
 103   return HASHKIT_FAILURE;
 104 }
 105
 106 hashkit_return_t hashkit_set_custom_function(hashkit_st *self, hashkit_hash_fn function,
 107                                              void *context) {
 108   if (self == NULL) {
 109     return HASHKIT_INVALID_ARGUMENT;
 110   }
 111
 112   return _set_custom_function(&self->base_hash, function, context);
 113 }
 114
 115 hashkit_return_t hashkit_set_custom_distribution_function(hashkit_st *self,
 116                                                           hashkit_hash_fn function, void *context) {
 117   if (self == NULL) {
 118     return HASHKIT_INVALID_ARGUMENT;
 119   }
 120
 121   return _set_custom_function(&self->distribution_hash, function, context);
 122 }
 123
 124 static hashkit_hash_algorithm_t get_function_type(const hashkit_hash_fn function) {
 125   if (function == hashkit_one_at_a_time) {
 126     return HASHKIT_HASH_DEFAULT;
 127   } else if (function == hashkit_md5) {
 128     return HASHKIT_HASH_MD5;
 129   } else if (function == hashkit_crc32) {
 130     return HASHKIT_HASH_CRC;
 131   } else if (function == hashkit_fnv1_64) {
 132     return HASHKIT_HASH_FNV1_64;
 133   } else if (function == hashkit_fnv1a_64) {
 134     return HASHKIT_HASH_FNV1A_64;
 135   } else if (function == hashkit_fnv1_32) {
 136     return HASHKIT_HASH_FNV1_32;
 137   } else if (function == hashkit_fnv1a_32) {
 138     return HASHKIT_HASH_FNV1A_32;
 139   } else if (function == hashkit_hsieh) {
 140     return HASHKIT_HASH_HSIEH;
 141   } else if (function == hashkit_murmur) {
 142     return HASHKIT_HASH_MURMUR;
 143   } else if (function == hashkit_murmur3) {
 144     return HASHKIT_HASH_MURMUR3;
 145   } else if (function == hashkit_jenkins) {
 146     return HASHKIT_HASH_JENKINS;
 147   }
 148
 149   return HASHKIT_HASH_CUSTOM;
 150 }
 151
 152 hashkit_hash_algorithm_t hashkit_get_function(const hashkit_st *self) {
 153   if (self == NULL) {
 154     return HASHKIT_HASH_DEFAULT;
 155   }
 156
 157   return get_function_type(self->base_hash.function);
 158 }
 159
 160 hashkit_hash_algorithm_t hashkit_get_distribution_function(const hashkit_st *self) {
 161   if (self == NULL) {
 162     return HASHKIT_HASH_DEFAULT;
 163   }
 164
 165   return get_function_type(self->distribution_hash.function);
 166 }