← Back to branch summary

~mordred/libmemcached/fix-weird-link

« back to all changes in this revision

Viewing changes to libhashkit/function.c

  • Committer: Brian Aker
  • Date: 2010-01-20 02:22:17 UTC
  • Revision ID: brian@gaz-20100120022217-71mmf1k83x53urub
Updating tree for new function work in libhashkit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
}