GCS  0.2.3
gu_digest.hpp
1 // Copyright (C) 2013 Codership Oy <info@codership.com>
8 #ifndef GU_DIGEST_HPP
9 #define GU_DIGEST_HPP
10 
11 #include "gu_hash.h"
12 #include "gu_vec16.h"
13 #include "gu_byteswap.hpp"
14 #include "gu_serializable.hpp"
15 #include "gu_macros.hpp"
16 
17 namespace gu
18 {
19 
20 /* Just making MMH3 not derive from Digest reduced TrxHandle size from
21  * 4560 bytes to 4256. 304 bytes of vtable pointers... */
22 class MMH3
23 {
24 public:
25 
26  MMH3 () : ctx_() { gu_mmh128_init (&ctx_); }
27 
28  ~MMH3 () {}
29 
30  template <typename T> static int
31  digest (const void* const in, size_t size, T& out)
32  {
33  byte_t tmp[16];
34  gu_mmh128(in, size, tmp);
35  int const s(std::min(sizeof(T), sizeof(tmp)));
36  ::memcpy (&out, tmp, s);
37  return s;
38  }
39 
40  /* experimental */
41  template <typename T> static T
42  digest (const void* const in, size_t size)
43  {
44  switch (sizeof(T))
45  {
46  case 1: return gu_mmh128_32(in, size);
47  case 2: return gu_mmh128_32(in, size);
48  case 4: return gu_mmh128_32(in, size);
49  case 8: return gu_mmh128_64(in, size);
50  }
51  throw;
52  }
53 
54  void append (const void* const buf, size_t const size)
55  {
56  gu_mmh128_append (&ctx_, buf, size);
57  }
58 
59  template <size_t size>
60  int gather (void* const buf) const
61  {
62  GU_COMPILE_ASSERT(size >= 16, wrong_buf_size);
63  gather16 (buf);
64  return 16;
65  }
66 
67  int gather (void* const buf, size_t const size) const
68  {
69  byte_t tmp[16];
70  gather16(tmp);
71  int const s(std::min(size, sizeof(tmp)));
72  ::memcpy (buf, tmp, s);
73  return s;
74  }
75 
76  void gather16 (void* const buf) const { gu_mmh128_get (&ctx_, buf); }
77 
78  uint64_t gather8() const { return gu_mmh128_get64 (&ctx_); }
79 
80  uint32_t gather4() const { return gu_mmh128_get32 (&ctx_); }
81 
82  // a questionable feature
83  template <typename T> int
84  operator() (T& out) const { return gather<sizeof(out)>(&out); }
85 
86 private:
87 
88  gu_mmh128_ctx_t ctx_;
89 
90 }; /* class MMH3 */
91 
92 template <> inline int
93 MMH3::digest (const void* const in, size_t size, uint8_t& out)
94 {
95  out = gu_mmh128_32(in, size); return sizeof(out);
96 }
97 
98 template <> inline int
99 MMH3::digest (const void* const in, size_t size, uint16_t& out)
100 {
101  out = gu_mmh128_32(in, size); return sizeof(out);
102 }
103 
104 template <> inline int
105 MMH3::digest (const void* const in, size_t size, uint32_t& out)
106 {
107  out = gu_mmh128_32(in, size); return sizeof(out);
108 }
109 
110 template <> inline int
111 MMH3::digest (const void* const in, size_t size, uint64_t& out)
112 {
113  out = gu_mmh128_64(in, size); return sizeof(out);
114 }
115 
116 template <> inline int
117 MMH3::gather<8> (void* const out) const
118 {
119  *(reinterpret_cast<uint64_t*>(out)) = htog64(gather8()); return 8;
120 }
121 
122 template <> inline int
123 MMH3::gather<4> (void* const out) const
124 {
125  *(reinterpret_cast<uint32_t*>(out)) = htog32(gather4()); return 4;
126 }
127 
128 typedef MMH3 Hash;
129 
130 
131 class FastHash
132 {
133 public:
134 
135  template <typename T> static int
136  digest (const void* const in, size_t size, T& out)
137  {
138  byte_t tmp[16];
139  gu_fast_hash128(in, size, tmp);
140  int const s(std::min(sizeof(T), sizeof(tmp)));
141  ::memcpy (&out, tmp, s);
142  return s;
143  }
144 
145  /* experimental */
146  template <typename T> static T
147  digest (const void* const in, size_t size)
148  {
149  switch (sizeof(T))
150  {
151  case 1: return gu_fast_hash32(in, size);
152  case 2: return gu_fast_hash32(in, size);
153  case 4: return gu_fast_hash32(in, size);
154  case 8: return gu_fast_hash64(in, size);
155  }
156  throw;
157  }
158 }; /* FastHash */
159 
160 template <> inline int
161 FastHash::digest (const void* const in, size_t size, uint8_t& out)
162 {
163  out = gu_fast_hash32(in, size); return sizeof(out);
164 }
165 
166 template <> inline int
167 FastHash::digest (const void* const in, size_t size, uint16_t& out)
168 {
169  out = gu_fast_hash32(in, size); return sizeof(out);
170 }
171 
172 template <> inline int
173 FastHash::digest (const void* const in, size_t size, uint32_t& out)
174 {
175  out = gu_fast_hash32(in, size); return sizeof(out);
176 }
177 
178 template <> inline int
179 FastHash::digest (const void* const in, size_t size, uint64_t& out)
180 {
181  out = gu_fast_hash64(in, size); return sizeof(out);
182 }
183 
184 } /* namespace gu */
185 
186 #endif /* GU_DIGEST_HPP */
Definition: gu_digest.hpp:22
Definition: gu_digest.hpp:131
Definition: gu_mmh3.h:276