digest-murmurhash 0.3.0 → 1.0.0

data/ext/digest/murmurhash/murmurhash1.c

@@ -5,77 +5,65 @@
 #include "murmurhash1.h"
 
 #define murmur1(r) do { \
-	h *= m; \
-	h ^= h >> r; \
+  h *= m; \
+  h ^= h >> r; \
 } while(0)
 
 static uint32_t
 murmur_hash_process1(const char *data, uint32_t length, uint32_t seed)
 {
-	const uint32_t m = MURMURHASH_MAGIC;
-	const uint8_t r = 16;
-	uint32_t h;
+  const uint32_t m = MURMURHASH_MAGIC;
+  const uint8_t r = 16;
+  uint32_t h;
 
-	h = seed ^ (length * m);
+  h = seed ^ (length * m);
 
-	while (4 <= length) {
-		h += *(uint32_t*)data;
-		murmur1(r);
-		data += 4;
-		length -= 4;
-	}
+  while (4 <= length) {
+    h += *(uint32_t*)data;
+    murmur1(r);
+    data += 4;
+    length -= 4;
+  }
 
-	switch (length) {
-	case 3:
-		h += data[2] << 16;
-	case 2:
-		h += data[1] << 8;
-	case 1:
-		h += data[0];
-		murmur1(r);
-	}
+  switch (length) {
+    case 3:
+      h += data[2] << 16;
+    case 2:
+      h += data[1] << 8;
+    case 1:
+      h += data[0];
+      murmur1(r);
+  }
 
-	murmur1(10);
-	murmur1(17);
+  murmur1(10);
+  murmur1(17);
 
-	return h;
+  return h;
 }
 
 VALUE
 murmur1_finish(VALUE self)
 {
-	uint8_t digest[4];
-	uint64_t h;
+  uint8_t digest[4];
+  uint64_t h;
 
-	h = _murmur_finish32(self, murmur_hash_process1);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur1_to_i(VALUE self)
-{
-	return UINT2NUM(_murmur_finish32(self, murmur_hash_process1));
+  h = _murmur_finish32(self, murmur_hash_process1);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur1_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	uint8_t digest[4];
-	uint32_t h;
-	h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process1);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur1_s_hexdigest(int argc, VALUE *argv, VALUE klass)
-{
-	return hexencode_str_new(murmur1_s_digest(argc, argv, klass));
+  uint8_t digest[4];
+  uint32_t h;
+  h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process1);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur1_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	return UINT2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process1));
+  return UINT2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process1));
 }

data/ext/digest/murmurhash/murmurhash1.h

@@ -4,9 +4,7 @@
 #include "murmurhash.h"
 
 VALUE murmur1_finish(VALUE self);
-VALUE murmur1_to_i(VALUE self);
 VALUE murmur1_s_digest(int argc, VALUE *argv, VALUE klass);
-VALUE murmur1_s_hexdigest(int argc, VALUE *argv, VALUE klass);
 VALUE murmur1_s_rawdigest(int argc, VALUE *argv, VALUE klass);
 
 #endif /* ifndef MURMURHASH1_INCLUDED */

data/ext/digest/murmurhash/murmurhash2.c

@@ -7,75 +7,62 @@
 static uint32_t
 murmur_hash_process2(const char *data, uint32_t length, uint32_t seed)
 {
-	const uint32_t m = MURMURHASH_MAGIC;
-	const uint8_t r = 24;
-	uint32_t h, k;
+  const uint32_t m = MURMURHASH_MAGIC;
+  const uint8_t r = 24;
+  uint32_t h, k;
 
-	h = seed ^ length;
+  h = seed ^ length;
 
-	while (4 <= length) {
-		k = *(uint32_t*)data;
-		k *= m;
-		k ^= k >> r;
-		k *= m;
+  while (4 <= length) {
+    k = *(uint32_t*)data;
+    k *= m;
+    k ^= k >> r;
+    k *= m;
 
-		h *= m;
-		h ^= k;
+    h *= m;
+    h ^= k;
 
-		data += 4;
-		length -= 4;
-	}
+    data += 4;
+    length -= 4;
+  }
 
-	switch (length) {
-	case 3: h ^= data[2] << 16;
-	case 2: h ^= data[1] << 8;
-	case 1: h ^= data[0];
-		h *= m;
-	}
+  switch (length) {
+    case 3: h ^= data[2] << 16;
+    case 2: h ^= data[1] << 8;
+    case 1: h ^= data[0];
+            h *= m;
+  }
 
-	h ^= h >> 13;
-	h *= m;
-	h ^= h >> 15;
+  h ^= h >> 13;
+  h *= m;
+  h ^= h >> 15;
 
-	return h;
+  return h;
 }
 
 VALUE
 murmur2_finish(VALUE self)
 {
-	uint8_t digest[4];
-	uint64_t h;
+  uint8_t digest[4];
+  uint64_t h;
 
-	h = _murmur_finish32(self, murmur_hash_process2);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur2_to_i(VALUE self)
-{
-	return ULONG2NUM(_murmur_finish32(self, murmur_hash_process2));
+  h = _murmur_finish32(self, murmur_hash_process2);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur2_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	uint8_t digest[4];
-	uint32_t h;
-	h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process2);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur2_s_hexdigest(int argc, VALUE *argv, VALUE klass)
-{
-	return hexencode_str_new(murmur2_s_digest(argc, argv, klass));
+  uint8_t digest[4];
+  uint32_t h;
+  h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process2);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur2_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	return ULONG2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process2));
+  return ULONG2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process2));
 }
-

data/ext/digest/murmurhash/murmurhash2.h

@@ -4,9 +4,7 @@
 #include "murmurhash.h"
 
 VALUE murmur2_finish(VALUE self);
-VALUE murmur2_to_i(VALUE self);
 VALUE murmur2_s_digest(int argc, VALUE *argv, VALUE klass);
-VALUE murmur2_s_hexdigest(int argc, VALUE *argv, VALUE klass);
 VALUE murmur2_s_rawdigest(int argc, VALUE *argv, VALUE klass);
 
 #endif /* ifndef MURMURHASH2_INCLUDED */

data/ext/digest/murmurhash/murmurhash2a.c

@@ -9,82 +9,61 @@
 static uint32_t
 murmur_hash_process2a(const char *key, uint32_t length, uint32_t seed)
 {
-	const uint32_t m = MURMURHASH_MAGIC;
-	const uint8_t r = 24;
-	uint32_t h, k, t, l;
-	const unsigned char *data = (const unsigned char *) key;
-
-	l = length;
-	h = seed;
-
-	while (4 <= length) {
-		k = *(uint32_t*)data;
-		mmix(h,k);
-		data += 4;
-		length -= 4;
-	}
-
-	t = 0;
-	switch (length) {
-	case 3: t ^= data[2] << 16;
-	case 2: t ^= data[1] << 8;
-	case 1: t ^= data[0];
-	}
-
-	mmix(h,t);
-	mmix(h,l);
-
-	h ^= h >> 13;
-	h *= m;
-	h ^= h >> 15;
-
-	return h;
-}
-
-static uint32_t
-_murmur2a_finish(VALUE self)
-{
-	const char *seed = RSTRING_PTR(murmur_seed_get32(self));
-	MURMURHASH(self, ptr);
-	return murmur_hash_process2a(ptr->buffer, ptr->p - ptr->buffer, *(uint32_t*)seed);
+  const uint32_t m = MURMURHASH_MAGIC;
+  const uint8_t r = 24;
+  uint32_t h, k, t, l;
+  const unsigned char *data = (const unsigned char *) key;
+
+  l = length;
+  h = seed;
+
+  while (4 <= length) {
+    k = *(uint32_t*)data;
+    mmix(h,k);
+    data += 4;
+    length -= 4;
+  }
+
+  t = 0;
+  switch (length) {
+    case 3: t ^= data[2] << 16;
+    case 2: t ^= data[1] << 8;
+    case 1: t ^= data[0];
+  }
+
+  mmix(h,t);
+  mmix(h,l);
+
+  h ^= h >> 13;
+  h *= m;
+  h ^= h >> 15;
+
+  return h;
 }
 
 VALUE
 murmur2a_finish(VALUE self)
 {
-	uint8_t digest[4];
-	uint64_t h;
+  uint8_t digest[4];
+  uint64_t h;
 
-	h = _murmur2a_finish(self);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur2a_to_i(VALUE self)
-{
-	return ULONG2NUM(_murmur2a_finish(self));
+  h = _murmur_finish32(self, murmur_hash_process2a);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur2a_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	uint8_t digest[4];
-	uint32_t h;
-	h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process2a);
-	ASSINE_BY_ENDIAN_32(digest, h);
-	return rb_str_new((const char*) digest, 4);
-}
-
-VALUE
-murmur2a_s_hexdigest(int argc, VALUE *argv, VALUE klass)
-{
-	return hexencode_str_new(murmur2a_s_digest(argc, argv, klass));
+  uint8_t digest[4];
+  uint32_t h;
+  h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process2a);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur2a_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process2a));
+  return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process2a));
 }
-

data/ext/digest/murmurhash/murmurhash2a.h

@@ -4,9 +4,7 @@
 #include "murmurhash.h"
 
 VALUE murmur2a_finish(VALUE self);
-VALUE murmur2a_to_i(VALUE self);
 VALUE murmur2a_s_digest(int argc, VALUE *argv, VALUE klass);
-VALUE murmur2a_s_hexdigest(int argc, VALUE *argv, VALUE klass);
 VALUE murmur2a_s_rawdigest(int argc, VALUE *argv, VALUE klass);
 
 #endif /* ifndef MURMURHASH2A_INCLUDED */

data/ext/digest/murmurhash/murmurhash64a.c

@@ -7,81 +7,69 @@
 static uint64_t
 murmur_hash_process64a(const char *key, uint32_t len, uint64_t seed)
 {
-	const uint64_t m = MURMURHASH_MAGIC64A;
-	const int r = 47;
+  const uint64_t m = MURMURHASH_MAGIC64A;
+  const int r = 47;
 
-	uint64_t h = seed ^ (len * m);
+  uint64_t h = seed ^ (len * m);
 
-	const uint64_t * data = (const uint64_t *)key;
-	const uint64_t * end = data + (len/8);
+  const uint64_t * data = (const uint64_t *)key;
+  const uint64_t * end = data + (len/8);
 
-	while(data != end)
-	{
-		uint64_t k = *data++;
+  while(data != end)
+  {
+    uint64_t k = *data++;
 
-		k *= m; 
-		k ^= k >> r; 
-		k *= m; 
+    k *= m;
+    k ^= k >> r;
+    k *= m;
 
-		h ^= k;
-		h *= m; 
-	}
+    h ^= k;
+    h *= m;
+  }
 
-	const unsigned char * data2 = (const unsigned char*)data;
+  const unsigned char * data2 = (const unsigned char*)data;
 
-	switch(len & 7) {
-	case 7: h ^= (uint64_t)((uint64_t)data2[6] << (uint64_t)48);
-	case 6: h ^= (uint64_t)((uint64_t)data2[5] << (uint64_t)40);
-	case 5: h ^= (uint64_t)((uint64_t)data2[4] << (uint64_t)32);
-	case 4: h ^= (uint64_t)((uint64_t)data2[3] << (uint64_t)24);
-	case 3: h ^= (uint64_t)((uint64_t)data2[2] << (uint64_t)16);
-	case 2: h ^= (uint64_t)((uint64_t)data2[1] << (uint64_t)8 );
-	case 1: h ^= (uint64_t)((uint64_t)data2[0]                );
-			h *= m;
-	};
+  switch(len & 7) {
+    case 7: h ^= (uint64_t)((uint64_t)data2[6] << (uint64_t)48);
+    case 6: h ^= (uint64_t)((uint64_t)data2[5] << (uint64_t)40);
+    case 5: h ^= (uint64_t)((uint64_t)data2[4] << (uint64_t)32);
+    case 4: h ^= (uint64_t)((uint64_t)data2[3] << (uint64_t)24);
+    case 3: h ^= (uint64_t)((uint64_t)data2[2] << (uint64_t)16);
+    case 2: h ^= (uint64_t)((uint64_t)data2[1] << (uint64_t)8 );
+    case 1: h ^= (uint64_t)((uint64_t)data2[0]                );
+            h *= m;
+  };
 
-	h ^= h >> r;
-	h *= m;
-	h ^= h >> r;
+  h ^= h >> r;
+  h *= m;
+  h ^= h >> r;
 
-	return h;
+  return h;
 }
 
 VALUE
 murmur64a_finish(VALUE self)
 {
-	uint8_t digest[8];
-	uint64_t h;
+  uint8_t digest[8];
+  uint64_t h;
 
-	h = _murmur_finish64(self, murmur_hash_process64a);
-	ASSINE_BY_ENDIAN_64(digest, h);
-	return rb_str_new((const char*) digest, 8);
-}
-
-VALUE
-murmur64a_to_i(VALUE self)
-{
-	return ULL2NUM(_murmur_finish64(self, murmur_hash_process64a));
+  h = _murmur_finish64(self, murmur_hash_process64a);
+  assign_by_endian_64(digest, h);
+  return rb_str_new((const char*) digest, 8);
 }
 
 VALUE
 murmur64a_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	uint8_t digest[8];
-	uint64_t h;
-	h = _murmur_s_digest64(argc, argv, klass, murmur_hash_process64a);
-	ASSINE_BY_ENDIAN_64(digest, h);
-	return rb_str_new((const char*) digest, 8);
-}
-
-VALUE
-murmur64a_s_hexdigest(int argc, VALUE *argv, VALUE klass)
-{
-	return hexencode_str_new(murmur64a_s_digest(argc, argv, klass));
+  uint8_t digest[8];
+  uint64_t h;
+  h = _murmur_s_digest64(argc, argv, klass, murmur_hash_process64a);
+  assign_by_endian_64(digest, h);
+  return rb_str_new((const char*) digest, 8);
 }
 
 VALUE
 murmur64a_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	return ULL2NUM(_murmur_s_digest64(argc, argv, klass, murmur_hash_process64a));
+  return ULL2NUM(_murmur_s_digest64(argc, argv, klass, murmur_hash_process64a));
 }