xxhash 0.5.0 → 0.7.0

data/ext/xxhash/xxhash.c

@@ -67,13 +67,30 @@ VALUE xxhash_xxh32(VALUE mod, VALUE input, VALUE seed)
   return ULL2NUM(XXH32(StringValuePtr(input), (size_t)RSTRING_LEN(input), (unsigned int)NUM2ULL(seed)));
 }
 
-void xxhash32_streaming_hash_free(xxhash_xxh32_t* storage)
+static void xxhash32_streaming_hash_free(void *ptr)
 {
+  xxhash_xxh32_t* storage = (xxhash_xxh32_t*)ptr;
   // Digest frees the memory.
   XXH32_freeState(storage->state);
   xfree(storage);
 }
 
+static size_t xxhash32_streaming_hash_memsize(const void *ptr)
+{
+  // Ideally we'd include sizeof(XXH32_state_t) too, but the type is opaque.
+  return sizeof(xxhash_xxh32_t);
+}
+
+static const rb_data_type_t xxhash_xxh32_type = {
+    .wrap_struct_name = "xxhash/xxhash32_streaming_hash",
+    .function = {
+        .dmark = NULL,
+        .dfree = xxhash32_streaming_hash_free,
+        .dsize = xxhash32_streaming_hash_memsize,
+    },
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 VALUE xxhash32_streaming_hash_new(VALUE klass, VALUE seed)
 {
   XXH_errorcode code;
@@ -86,14 +103,14 @@ VALUE xxhash32_streaming_hash_new(VALUE klass, VALUE seed)
     rb_raise(rb_eRuntimeError, "Error during reset.");
     return Qnil;
   }
-  return Data_Wrap_Struct(klass, 0, xxhash32_streaming_hash_free, storage);
+  return TypedData_Wrap_Struct(klass, &xxhash_xxh32_type, storage);
 }
 
 VALUE xxhash32_streaming_hash_reset(VALUE self)
 {
   XXH_errorcode code;
   xxhash_xxh32_t* storage;
-  Data_Get_Struct(self, xxhash_xxh32_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh32_t, &xxhash_xxh32_type, storage);
 
   code = XXH32_reset(storage->state, storage->seed);
   if(code != XXH_OK) {
@@ -107,7 +124,7 @@ VALUE xxhash32_streaming_hash_update(VALUE self, VALUE data)
 {
   XXH_errorcode code;
   xxhash_xxh32_t* storage;
-  Data_Get_Struct(self, xxhash_xxh32_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh32_t, &xxhash_xxh32_type, storage);
 
   code = XXH32_update(storage->state, StringValuePtr(data), (size_t)RSTRING_LEN(data));
   if(code != XXH_OK) {
@@ -119,7 +136,7 @@ VALUE xxhash32_streaming_hash_update(VALUE self, VALUE data)
 VALUE xxhash32_streaming_hash_digest(VALUE self)
 {
   xxhash_xxh32_t* storage;
-  Data_Get_Struct(self, xxhash_xxh32_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh32_t, &xxhash_xxh32_type, storage);
 
   // Do not free memory now.
   return ULL2NUM(XXH32_digest(storage->state));
@@ -130,13 +147,30 @@ VALUE xxhash_xxh64(VALUE mod, VALUE input, VALUE seed)
   return ULL2NUM(XXH64(StringValuePtr(input), (size_t)RSTRING_LEN(input), (unsigned int)NUM2ULL(seed)));
 }
 
-void xxhash64_streaming_hash_free(xxhash_xxh64_t* storage)
+static void xxhash64_streaming_hash_free(void *ptr)
 {
+  xxhash_xxh64_t* storage = (xxhash_xxh64_t*)ptr;
   // Digest frees the memory.
   XXH64_freeState(storage->state);
   xfree(storage);
 }
 
+static size_t xxhash64_streaming_hash_memsize(const void *ptr)
+{
+  // Ideally we'd include sizeof(XXH64_state_t) too, but the type is opaque.
+  return sizeof(xxhash_xxh64_t);
+}
+
+static const rb_data_type_t xxhash_xxh64_type = {
+    .wrap_struct_name = "xxhash/xxhash64_streaming_hash",
+    .function = {
+        .dmark = NULL,
+        .dfree = xxhash64_streaming_hash_free,
+        .dsize = xxhash64_streaming_hash_memsize,
+    },
+    .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 VALUE xxhash64_streaming_hash_new(VALUE klass, VALUE seed)
 {
   XXH_errorcode code;
@@ -150,14 +184,14 @@ VALUE xxhash64_streaming_hash_new(VALUE klass, VALUE seed)
     rb_raise(rb_eRuntimeError, "Error during reset.");
     return Qnil;
   }
-  return Data_Wrap_Struct(klass, 0, xxhash64_streaming_hash_free, storage);
+  return TypedData_Wrap_Struct(klass, &xxhash_xxh64_type, storage);
 }
 
 VALUE xxhash64_streaming_hash_reset(VALUE self)
 {
   XXH_errorcode code;
   xxhash_xxh64_t* storage;
-  Data_Get_Struct(self, xxhash_xxh64_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh64_t, &xxhash_xxh64_type, storage);
 
   code = XXH64_reset(storage->state, storage->seed);
   if(code != XXH_OK) {
@@ -170,7 +204,7 @@ VALUE xxhash64_streaming_hash_update(VALUE self, VALUE data)
 {
   XXH_errorcode code;
   xxhash_xxh64_t* storage;
-  Data_Get_Struct(self, xxhash_xxh64_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh64_t, &xxhash_xxh64_type, storage);
 
   code = XXH64_update(storage->state, StringValuePtr(data), (size_t)RSTRING_LEN(data));
   if(code != XXH_OK) {
@@ -182,7 +216,7 @@ VALUE xxhash64_streaming_hash_update(VALUE self, VALUE data)
 VALUE xxhash64_streaming_hash_digest(VALUE self)
 {
   xxhash_xxh64_t* storage;
-  Data_Get_Struct(self, xxhash_xxh64_t, storage);
+  TypedData_Get_Struct(self, xxhash_xxh64_t, &xxhash_xxh64_type, storage);
 
   // Do not free memory now.
   return ULL2NUM(XXH64_digest(storage->state));
@@ -203,22 +237,24 @@ void Init_xxhash(void)
   mXXhash = rb_define_module("XXhash");
   mInternal = rb_define_module_under(mXXhash, "XXhashInternal");
 
-  rb_define_singleton_method(mInternal, "xxh32", (ruby_method*) &xxhash_xxh32, 2);
-  rb_define_singleton_method(mInternal, "xxh32_file", (ruby_method*) &xxhash_xxh32_file, 2);
-  rb_define_singleton_method(mInternal, "xxh64", (ruby_method*) &xxhash_xxh64, 2);
-  rb_define_singleton_method(mInternal, "xxh64_file", (ruby_method*) &xxhash_xxh64_file, 2);
+  rb_define_singleton_method(mInternal, "xxh32", xxhash_xxh32, 2);
+  rb_define_singleton_method(mInternal, "xxh32_file", xxhash_xxh32_file, 2);
+  rb_define_singleton_method(mInternal, "xxh64", xxhash_xxh64, 2);
+  rb_define_singleton_method(mInternal, "xxh64_file", xxhash_xxh64_file, 2);
 
   cStreamingHash = rb_define_class_under(mInternal, "StreamingHash32", rb_cObject);
+  rb_undef_alloc_func(cStreamingHash);
 
-  rb_define_singleton_method(cStreamingHash, "new", (ruby_method*) &xxhash32_streaming_hash_new, 1);
-  rb_define_method(cStreamingHash, "update", (ruby_method*) &xxhash32_streaming_hash_update, 1);
-  rb_define_method(cStreamingHash, "digest", (ruby_method*) &xxhash32_streaming_hash_digest, 0);
-  rb_define_method(cStreamingHash, "reset", (ruby_method*) &xxhash32_streaming_hash_reset, 0);
+  rb_define_singleton_method(cStreamingHash, "new", xxhash32_streaming_hash_new, 1);
+  rb_define_method(cStreamingHash, "update", xxhash32_streaming_hash_update, 1);
+  rb_define_method(cStreamingHash, "digest", xxhash32_streaming_hash_digest, 0);
+  rb_define_method(cStreamingHash, "reset", xxhash32_streaming_hash_reset, 0);
 
   cStreamingHash64 = rb_define_class_under(mInternal, "StreamingHash64", rb_cObject);
+  rb_undef_alloc_func(cStreamingHash64);
 
-  rb_define_singleton_method(cStreamingHash64, "new", (ruby_method*) &xxhash64_streaming_hash_new, 1);
-  rb_define_method(cStreamingHash64, "update", (ruby_method*) &xxhash64_streaming_hash_update, 1);
-  rb_define_method(cStreamingHash64, "digest", (ruby_method*) &xxhash64_streaming_hash_digest, 0);
-  rb_define_method(cStreamingHash64, "reset", (ruby_method*) &xxhash64_streaming_hash_reset, 0);
+  rb_define_singleton_method(cStreamingHash64, "new", xxhash64_streaming_hash_new, 1);
+  rb_define_method(cStreamingHash64, "update", xxhash64_streaming_hash_update, 1);
+  rb_define_method(cStreamingHash64, "digest", xxhash64_streaming_hash_digest, 0);
+  rb_define_method(cStreamingHash64, "reset", xxhash64_streaming_hash_reset, 0);
 }

data/ext/xxhash/xxhash.h

@@ -19,14 +19,12 @@ typedef VALUE (ruby_method)();
 
 VALUE xxhash_xxh32(VALUE mod, VALUE input, VALUE seed);
 VALUE xxhash_xxh32_file(VALUE mod, VALUE filename, VALUE seed);
-void xxhash32_streaming_hash_free(xxhash_xxh32_t* state);
 VALUE xxhash32_streaming_hash_new(VALUE klass, VALUE seed);
 VALUE xxhash32_streaming_hash_update(VALUE self, VALUE data);
 VALUE xxhash32_streaming_hash_reset(VALUE self);
 VALUE xxhash32_streaming_hash_digest(VALUE self);
 VALUE xxhash_xxh64(VALUE mod, VALUE input, VALUE seed);
 VALUE xxhash_xxh64_file(VALUE mod, VALUE filename, VALUE seed);
-void xxhash64_streaming_hash_free(xxhash_xxh64_t* state);
 VALUE xxhash64_streaming_hash_new(VALUE klass, VALUE seed);
 VALUE xxhash64_streaming_hash_update(VALUE self, VALUE data);
 VALUE xxhash64_streaming_hash_reset(VALUE self);

data/lib/xxhash/version.rb

@@ -1,3 +1,3 @@
 module XXhash
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: xxhash
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Vasiliy Ermolovich
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Ruby wrapper for xxHash lib
 email:
@@ -39,7 +38,6 @@ homepage: http://github.com/nashby/xxhash
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -54,8 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
-signing_key: 
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Ruby wrapper for xxHash lib
 test_files: