digest-xxhash 0.0.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 70bda38e968bd286bb529fdaea93306867b2711c
-  data.tar.gz: e70942cbba4e25c06b124e3adc8fd008665c2888
+SHA256:
+  metadata.gz: 67c1180d8629bae85bc269796cdae0b67e1fb1942dd5048906c5b785b94b878b
+  data.tar.gz: 0f35b3b820f91b12e0439e91dac4bf45a390dfc901d20c730d746886c132ca5a
 SHA512:
-  metadata.gz: 987ccbba297ee355686df25fd14225dac3ba89a460fc31b36bcac876c78d18bbac4765cd58f0c8c7cbac9e06c788827de1d7783511a5d76627dff8a545bd180e
-  data.tar.gz: ae6af3b301e27d9d0d120b9a440f309468337557e829205a7908126e5b34c947e18107e6446af4f217fd423f613c7c679d3f78da5ee68e3add67cce05b34d6c7
+  metadata.gz: e7177998d433255ccb0e222257f9161c2e9514418052cf757621b3b13fbdb348dc6a47bd460b94398466496b28ebc7c06b845fc44329156a46309aef749c3bd5
+  data.tar.gz: af71a1e091b287e7d2ff9a41f74fc1adb2af73f625a66c9a5f1d64d3001c99034ec00e5b88085d93362b0820e0a33e2ad1f5f70df8b19551247d9a8d84d757da

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2017 konsolebox
+Copyright (c) 2021 konsolebox
 
 MIT License
 

data/README.md

@@ -1,15 +1,15 @@
-# digest-xxhash-ruby
+# digest-xxhash
 
-This gem 'digest-xxhash' provides XXH32 and XXH64 functions for Ruby.  It works
-on top of Digest::Class and complies with the functional design of
-Digest::Instance.
+This gem provides XXH32, XXH64, XXH3_64bits and XXH3_128bits
+functionalities for Ruby.  It inherits Digest::Class and complies
+with Digest::Instance's functional design.
 
-Its core implementation was taken from the official source, which is
-in https://github.com/Cyan4973/xxHash.
+Its core implementation comes from the official source, which is in
+https://github.com/Cyan4973/xxHash.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this line to the application's Gemfile:
 
     gem 'digest-xxhash'
 
@@ -17,10 +17,21 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
+It can also be installed manually with:
 
     $ gem install digest-xxhash
 
+The library can also be installed in Gentoo system-wide using 'layman':
+
+    # Fetch remote list of overlays, and add 'konsolebox' overlay
+    layman -f && layman -a konsolebox
+
+    # Unmask unstable keyword
+    echo 'dev-ruby/digest-xxhash' > /etc/portage/package.keywords/dev-ruby.digest-xxhash
+
+    # Merge package
+    emerge dev-ruby/digest-xxhash
+
 ## Example Usage
 
     require 'digest/xxhash'
@@ -52,10 +63,35 @@ Or install it yourself as:
     Digest::XXH64.new.reset("0123456789abcdef").update("12").update("34").hexdigest
     => "d7544504de216507"
 
+    Digest::XXH3_64bits.hexdigest("1234", "0123456789abcdef")
+    => "4156724c7605b1be"
+
+    Digest::XXH3_64bits.new.reset_with_secret("abcd" * 34).update("1234").hexdigest
+    => "f7bbdbf9ec8c6394"
+
+    Digest::XXH3_128bits.hexdigest("1234", "0123456789abcdef") # XXH3_128bits() only allows 64-bit seeds
+    => "ad6108fb0b9a6b51b7f80d053c76c0fd"
+
+    Digest::XXH3_128bits.new.reset_with_secret("abcd" * 34).update("1234").hexdigest
+    => "0d44dd7fde8ea2b4ba961e1a26f71f21"
+
+## API Documentation
+
+RubyGems.org provides autogenerated API documentation of the library in
+https://www.rubydoc.info/gems/digest-xxhash/.
+
+## Homepage
+
+https://rubygems.org/gems/digest-xxhash
+
 ## Contributing
 
 1. Fork it ( https://github.com/konsolebox/digest-xxhash-ruby/fork ).
-2. Create your feature branch (`git checkout -b my-new-feature`).
-3. Commit your changes (`git commit -am 'Add some feature'`).
+2. Create feature branch (`git checkout -b my-new-feature`).
+3. Commit changes (`git commit -am 'Add some feature'`).
 4. Push to the branch (`git push origin my-new-feature`).
 5. Create a new Pull Request.
+
+[![Build Status](https://travis-ci.org/konsolebox/digest-xxhash-ruby.svg?branch=master)](https://travis-ci.org/konsolebox/digest-xxhash-ruby)
+[![Build Status](https://ci.appveyor.com/api/projects/status/kb6hvlxjms3ftw7u?svg=true)](https://ci.appveyor.com/project/konsolebox/digest-xxhash-ruby)
+[![Build Status](https://github.com/konsolebox/digest-xxhash-ruby/actions/workflows/ruby.yml/badge.svg)](https://github.com/konsolebox/digest-xxhash-ruby/actions/workflows/ruby.yml)

data/Rakefile

@@ -1,10 +1,21 @@
 require 'bundler/gem_tasks'
+require 'rake/extensiontask'
 require 'rake/testtask'
 
 # clean, clobber, compile, and compile:digest/xxhash
-require 'rake/extensiontask'
 Rake::ExtensionTask.new('digest/xxhash', Bundler::GemHelper.gemspec)
 
+# install
+Rake::Task[:install].clear
+task :install => :build do
+  name = Bundler::GemHelper.gemspec.name
+  pkg_dir = File.join(Bundler::GemHelper.instance.base, "pkg")
+  built_gem = Dir.chdir(pkg_dir){ Dir.glob("#{name}-*.gem").sort_by{ |f| File.mtime(f) }.last }
+  gem_command = (ENV["GEM_COMMAND"].shellsplit rescue nil) || ["gem"]
+  options = ARGV.select{ |e| e =~ /\A--?/ }
+  Process.wait spawn(*gem_command, "install", File.join(pkg_dir, built_gem), *options)
+end
+
 # test
 Rake::TestTask.new(:test => :compile) do |t|
   t.test_files = FileList['test/test.rb']
@@ -17,4 +28,7 @@ task :clean do
   rm_f list unless list.empty?
 end
 
+# default
+task :default => :test
+
 # Run `rake --tasks` for a list of tasks.

data/digest-xxhash.gemspec

@@ -9,15 +9,19 @@ Gem::Specification.new do |spec|
   spec.version       = Digest::XXHash::VERSION
   spec.authors       = ["konsolebox"]
   spec.email         = ["konsolebox@gmail.com"]
-  spec.summary       = "XXHash for Ruby"
-  spec.description   = "An XXHash library that complies with Digest::Instance's functional design."
+  spec.summary       = "A Digest framework based XXHash library for Ruby"
+  spec.description   = <<-EOF
+    This gem provides XXH32, XXH64, XXH3_64bits and XXH3_128bits
+    functionalities for Ruby.  It inherits Digest::Class and complies
+    with Digest::Instance's functional design.
+  EOF
   spec.homepage      = "https://github.com/konsolebox/digest-xxhash-ruby"
   spec.license       = "MIT"
 
   spec.required_ruby_version = '>= 2.2'
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.files         = `git ls-files -z`.split("\x0").reject{ |f| f =~ /\.yml$/ }
+  spec.executables   = spec.files.grep(%r{^bin/}){ |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 

data/ext/digest/xxhash/ext.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 konsolebox
+ * Copyright (c) 2021 konsolebox
  *
  * MIT License
  *
@@ -23,12 +23,10 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-
 #include <ruby.h>
 #include <ruby/digest.h>
-#include <stdint.h>
 
-#define XXH_STATIC_LINKING_ONLY
+#define XXH_INLINE_ALL
 #include "xxhash.h"
 #include "utils.h"
 
@@ -39,14 +37,21 @@
 #endif
 
 #define _XXH32_DIGEST_SIZE 4
-#define _XXH64_DIGEST_SIZE 8
-
 #define _XXH32_BLOCK_SIZE 4
-#define _XXH64_BLOCK_SIZE 8
-
 #define _XXH32_DEFAULT_SEED 0
+
+#define _XXH64_DIGEST_SIZE 8
+#define _XXH64_BLOCK_SIZE 8
 #define _XXH64_DEFAULT_SEED 0
 
+#define _XXH3_64BITS_DIGEST_SIZE 8
+#define _XXH3_64BITS_BLOCK_SIZE 8
+#define _XXH3_64BITS_DEFAULT_SEED 0
+
+#define _XXH3_128BITS_DIGEST_SIZE 16
+#define _XXH3_128BITS_BLOCK_SIZE 16
+#define _XXH3_128BITS_DEFAULT_SEED 0
+
 #if 0
 #	define _DEBUG(...) fprintf(stderr, __VA_ARGS__)
 #else
@@ -63,9 +68,19 @@ static ID _id_reset;
 static ID _id_update;
 
 static VALUE _Digest;
+static VALUE _Digest_Class;
 static VALUE _Digest_XXHash;
 static VALUE _Digest_XXH32;
 static VALUE _Digest_XXH64;
+static VALUE _Digest_XXH3_64bits;
+static VALUE _Digest_XXH3_128bits;
+
+#define _RSTRING_PTR_U(x) ((unsigned char *)RSTRING_PTR(x))
+#define _TWICE(x) (x * 2)
+
+static void _xxh32_free_state(void *);
+static void _xxh64_free_state(void *);
+static void _xxh3_free_state(void *);
 
 /*
  * Data types
@@ -73,13 +88,25 @@ static VALUE _Digest_XXH64;
 
 static const rb_data_type_t _xxh32_state_data_type = {
 	"xxh32_state_data",
-	{ 0, RUBY_TYPED_DEFAULT_FREE, 0, }, 0, 0,
+	{ 0, _xxh32_free_state, 0, }, 0, 0,
 	RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
 };
 
 static const rb_data_type_t _xxh64_state_data_type = {
 	"xxh64_state_data",
-	{ 0, RUBY_TYPED_DEFAULT_FREE, 0, }, 0, 0,
+	{ 0, _xxh64_free_state, 0, }, 0, 0,
+	RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
+};
+
+static const rb_data_type_t _xxh3_64bits_state_data_type = {
+	"xxh3_64bits_state_data",
+	{ 0, _xxh3_free_state, 0, }, 0, 0,
+	RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
+};
+
+static const rb_data_type_t _xxh3_128bits_state_data_type = {
+	"xxh3_128bits_state_data",
+	{ 0, _xxh3_free_state, 0, }, 0, 0,
 	RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
 };
 
@@ -87,108 +114,93 @@ static const rb_data_type_t _xxh64_state_data_type = {
  * Common functions
  */
 
-static XXH32_state_t *_get_state_32(VALUE self)
+static XXH32_state_t *_get_state_xxh32(VALUE self)
 {
 	XXH32_state_t *state_p;
 	TypedData_Get_Struct(self, XXH32_state_t, &_xxh32_state_data_type, state_p);
 	return state_p;
 }
 
-static XXH64_state_t *_get_state_64(VALUE self)
+static XXH64_state_t *_get_state_xxh64(VALUE self)
 {
 	XXH64_state_t *state_p;
 	TypedData_Get_Struct(self, XXH64_state_t, &_xxh64_state_data_type, state_p);
 	return state_p;
 }
 
-static void _xxh32_reset(XXH32_state_t *state_p, uint32_t seed)
+static XXH3_state_t *_get_state_xxh3_64bits(VALUE self)
 {
-	if (XXH32_reset(state_p, seed) != XXH_OK)
-		rb_raise(rb_eRuntimeError, "Failed to reset state.");
+	XXH3_state_t *state_p;
+	TypedData_Get_Struct(self, XXH3_state_t, &_xxh3_64bits_state_data_type, state_p);
+	return state_p;
 }
 
-static void _xxh64_reset(XXH64_state_t *state_p, uint64_t seed)
+static XXH3_state_t *_get_state_xxh3_128bits(VALUE self)
 {
-	if (XXH64_reset(state_p, seed) != XXH_OK)
-		rb_raise(rb_eRuntimeError, "Failed to reset state.");
+	XXH3_state_t *state_p;
+	TypedData_Get_Struct(self, XXH3_state_t, &_xxh3_128bits_state_data_type, state_p);
+	return state_p;
 }
 
-static VALUE _encode_big_endian_32(uint32_t num)
+static void _xxh32_reset(XXH32_state_t *state_p, XXH32_hash_t seed)
 {
-	uint32_t temp;
-
-	if (is_little_endian()) {
-		temp = swap_uint32(num);
-	} else {
-		temp = num;
-	}
-
-	return rb_usascii_str_new((unsigned char *) &temp, sizeof(uint32_t));
+	if (XXH32_reset(state_p, seed) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state.");
 }
 
-static uint32_t _decode_big_endian_32_cstr(unsigned char *str)
+static void _xxh64_reset(XXH64_state_t *state_p, XXH64_hash_t seed)
 {
-	uint32_t temp = read32(str);
-
-	if (is_little_endian()) {
-		return swap_uint32(temp);
-	} else {
-		return temp;
-	}
+	if (XXH64_reset(state_p, seed) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state.");
 }
 
-static uint32_t _decode_big_endian_32(VALUE str)
+static void _xxh3_64bits_reset(XXH3_state_t *state_p, XXH64_hash_t seed)
 {
-	return _decode_big_endian_32_cstr(RSTRING_PTR(str));
+	if (XXH3_64bits_reset_withSeed(state_p, seed) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state.");
 }
 
-static VALUE _encode_big_endian_64(uint64_t num)
+static void _xxh3_128bits_reset(XXH3_state_t *state_p, XXH64_hash_t seed)
 {
-	uint64_t temp;
-
-	if (is_little_endian()) {
-		temp = swap_uint64(num);
-	} else {
-		temp = num;
-	}
-
-	return rb_usascii_str_new((unsigned char *) &temp, sizeof(uint64_t));
+	if (XXH3_128bits_reset_withSeed(state_p, seed) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state.");
 }
 
-static uint64_t _decode_big_endian_64_cstr(unsigned char *str)
+static void _xxh32_free_state(void* state)
 {
-	uint64_t temp = read64(str);
+	XXH32_freeState((XXH32_state_t *)state);
+}
 
-	if (is_little_endian()) {
-		return swap_uint64(temp);
-	} else {
-		return temp;
-	}
+static void _xxh64_free_state(void* state)
+{
+	XXH64_freeState((XXH64_state_t *)state);
 }
 
-static uint64_t _decode_big_endian_64(VALUE str)
+static void _xxh3_free_state(void* state)
 {
-	return _decode_big_endian_64_cstr(RSTRING_PTR(str));
+	XXH3_freeState((XXH3_state_t *)state);
 }
 
 static VALUE _hex_encode_str(VALUE str)
 {
 	int len = RSTRING_LEN(str);
-	VALUE hex = rb_str_new(0, len * 2);
-	hex_encode_str_implied(RSTRING_PTR(str), len, RSTRING_PTR(hex));
+	VALUE hex = rb_usascii_str_new(0, _TWICE(len));
+	hex_encode_str_implied(_RSTRING_PTR_U(str), len, _RSTRING_PTR_U(hex));
 	return hex;
 }
 
 /*
  * Document-class: Digest::XXHash
  *
- * This is the base class of Digest::XXH32 and Digest::XXH64.
+ * This is the base class of Digest::XXH32, Digest::XXH64,
+ * Digest::XXH3_64bits, and Digest::XXH3_128bits.
  */
 
 static VALUE _Digest_XXHash_internal_allocate(VALUE klass)
 {
 	if (klass == _Digest_XXHash)
-		rb_raise(rb_eRuntimeError, "Digest::XXHash is an incomplete class and cannot be instantiated.");
+		rb_raise(rb_eRuntimeError, "Digest::XXHash is an incomplete class and cannot be "
+				"instantiated.");
 
 	rb_raise(rb_eNotImpError, "Allocator function not implemented.");
 }
@@ -221,7 +233,7 @@ static VALUE _Digest_XXHash_ifinish(VALUE self)
 
 static VALUE _do_digest(int argc, VALUE* argv, VALUE self, ID finish_method_id)
 {
-	VALUE str, seed;
+	VALUE str, seed, result;
 	int argc2 = argc > 0 ? rb_scan_args(argc, argv, "02", &str, &seed) : 0;
 
 	if (argc2 > 0) {
@@ -236,7 +248,7 @@ static VALUE _do_digest(int argc, VALUE* argv, VALUE self, ID finish_method_id)
 		rb_funcall(self, _id_update, 1, str);
 	}
 
-	VALUE result = rb_funcall(self, finish_method_id, 0);
+	result = rb_funcall(self, finish_method_id, 0);
 
 	if (argc2 > 0)
 		rb_funcall(self, _id_reset, 0);
@@ -258,8 +270,9 @@ static VALUE _do_digest(int argc, VALUE* argv, VALUE self, ID finish_method_id)
  * with +seed+, and is used as the return value.  The instance's state is reset
  * to default afterwards.
  *
- * Providing an argument means that previous calculations done with #update
- * would be discarded, so be careful with its use.
+ * Providing an argument means that previous initializations done with custom
+ * seeds or secrets, and previous calculations done with #update would be
+ * discarded, so be careful with its use.
  *
  * +seed+ can be in the form of a string, a hex string, or a number.
  */
@@ -278,8 +291,7 @@ static VALUE _Digest_XXHash_digest(int argc, VALUE* argv, VALUE self)
  */
 static VALUE _Digest_XXHash_hexdigest(int argc, VALUE* argv, VALUE self)
 {
-	VALUE result = _do_digest(argc, argv, self, _id_finish);
-	return _hex_encode_str(result);
+	return _hex_encode_str(_do_digest(argc, argv, self, _id_finish));
 }
 
 /*
@@ -302,7 +314,8 @@ static VALUE _Digest_XXHash_idigest(int argc, VALUE* argv, VALUE self)
  */
 static VALUE _Digest_XXHash_idigest_bang(VALUE self)
 {
-	VALUE result = rb_funcall(self, _id_ifinish, 0);
+	VALUE result;
+	result = rb_funcall(self, _id_ifinish, 0);
 	rb_funcall(self, _id_reset, 0);
 	return result;
 }
@@ -313,7 +326,7 @@ static VALUE _Digest_XXHash_idigest_bang(VALUE self)
  * This method is called when instances are cloned.  It is responsible for
  * replicating internal data.
  */
-static VALUE _Digest_XXHash_initialize_copy(VALUE orig)
+static VALUE _Digest_XXHash_initialize_copy(VALUE self, VALUE orig)
 {
 	rb_raise(rb_eNotImpError, "initialize_copy method not implemented.");
 }
@@ -325,27 +338,31 @@ static VALUE _Digest_XXHash_initialize_copy(VALUE orig)
  */
 static VALUE _Digest_XXHash_inspect(VALUE self)
 {
-	VALUE klass = rb_obj_class(self);
-	VALUE klass_name = rb_class_name(klass);
+	VALUE klass, klass_name, hexdigest, args[2];
+	klass = rb_obj_class(self);
+	klass_name = rb_class_name(klass);
 
 	if (klass_name == Qnil)
 		klass_name = rb_inspect(klass);
 
-	VALUE hexdigest = rb_funcall(self, _id_hexdigest, 0);
+	hexdigest = rb_funcall(self, _id_hexdigest, 0);
 
-	VALUE args[] = { klass_name, hexdigest };
+	args[0] = klass_name;
+	args[1] = hexdigest;
 	return rb_str_format(sizeof(args), args, rb_str_new_literal("#<%s|%s>"));
 }
 
 static VALUE _instantiate_and_digest(int argc, VALUE* argv, VALUE klass, ID digest_method_id)
 {
-	VALUE str, seed;
-	int argc2 = rb_scan_args(argc, argv, "11", &str, &seed);
+	VALUE str, seed, instance;
+	int argc2;
+
+	argc2 = rb_scan_args(argc, argv, "11", &str, &seed);
 
 	if (TYPE(str) != T_STRING)
 		rb_raise(rb_eTypeError, "Argument type not string.");
 
-	VALUE instance = rb_funcall(klass, _id_new, 0);
+	instance = rb_funcall(klass, _id_new, 0);
 
 	if (argc2 > 1)
 		return rb_funcall(instance, digest_method_id, 2, str, seed);
@@ -395,10 +412,9 @@ static VALUE _Digest_XXHash_singleton_idigest(int argc, VALUE* argv, VALUE self)
 
 static VALUE _Digest_XXH32_internal_allocate(VALUE klass)
 {
-	XXH32_state_t *state_p;
-	VALUE obj = TypedData_Make_Struct(klass, XXH32_state_t, &_xxh32_state_data_type, state_p);
+	XXH32_state_t *state_p = XXH32_createState();
 	_xxh32_reset(state_p, 0);
-	return obj;
+	return TypedData_Wrap_Struct(klass, &_xxh32_state_data_type, state_p);
 }
 
 /*
@@ -408,8 +424,8 @@ static VALUE _Digest_XXH32_internal_allocate(VALUE klass)
  */
 static VALUE _Digest_XXH32_update(VALUE self, VALUE str)
 {
-	if (XXH32_update(_get_state_32(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
-		rb_raise(rb_eRuntimeError, "Failed to reset state.");
+	if (XXH32_update(_get_state_xxh32(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to update state.");
 
 	return self;
 }
@@ -417,15 +433,17 @@ static VALUE _Digest_XXH32_update(VALUE self, VALUE str)
 /* :nodoc: */
 static VALUE _Digest_XXH32_finish(VALUE self)
 {
-	uint32_t result = XXH32_digest(_get_state_32(self));
-	return _encode_big_endian_32(result);
+	XXH64_hash_t hash = XXH32_digest(_get_state_xxh32(self));
+	VALUE str = rb_usascii_str_new(0, sizeof(XXH32_canonical_t));
+	XXH32_canonicalFromHash((XXH32_canonical_t *)RSTRING_PTR(str), hash);
+	return str;
 }
 
 /* :nodoc: */
 static VALUE _Digest_XXH32_ifinish(VALUE self)
 {
-	uint32_t result = XXH32_digest(_get_state_32(self));
-	return ULONG2NUM(result);
+	XXH32_hash_t hash = XXH32_digest(_get_state_xxh32(self));
+	return ULONG2NUM(hash);
 }
 
 /*
@@ -433,9 +451,10 @@ static VALUE _Digest_XXH32_ifinish(VALUE self)
  *
  * Resets state to initial form with seed.
  *
- * This would discard previous calculations with #update.
+ * This discards previous calculations with #update.
  *
  * +seed+ can be in the form of a string, a hex string, or a number.
+ * Its virtual length should be 32-bits.
  *
  * If +seed+ is not provided, the default value would be 0.
  */
@@ -448,36 +467,39 @@ static VALUE _Digest_XXH32_reset(int argc, VALUE* argv, VALUE self)
 		case T_STRING:
 			{
 				int len = RSTRING_LEN(seed);
-				uint32_t decoded_seed;
+				XXH32_hash_t decoded_seed;
 
-				if (len == (sizeof(uint32_t) * 2)) {
-					unsigned char hex_decoded_seed[sizeof(uint32_t)];
+				if (len == _TWICE(sizeof(XXH32_hash_t))) {
+					unsigned char hex_decoded_seed[sizeof(XXH32_hash_t)];
 
-					if (! hex_decode_str_implied(RSTRING_PTR(seed), sizeof(uint32_t) * 2, hex_decoded_seed))
-						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n", StringValueCStr(seed));
+					if (! hex_decode_str_implied(_RSTRING_PTR_U(seed), len, hex_decoded_seed))
+						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n",
+								StringValueCStr(seed));
 
-					decoded_seed = _decode_big_endian_32_cstr(hex_decoded_seed);
-				} else if (len == sizeof(uint32_t)) {
-					decoded_seed = _decode_big_endian_32_cstr(RSTRING_PTR(seed));
+					decoded_seed = XXH_readBE32(hex_decoded_seed);
+				} else if (len == sizeof(XXH32_hash_t)) {
+					decoded_seed = XXH_readBE32(RSTRING_PTR(seed));
 				} else {
-					rb_raise(rb_eArgError, "Invalid seed length.  Expecting an 8-character hex string or a 4-byte string.");
+					rb_raise(rb_eArgError, "Invalid seed length.  "
+							"Expecting an 8-character hex string or a 4-byte string.");
 				}
 
-				_xxh32_reset(_get_state_32(self), decoded_seed);
+				_xxh32_reset(_get_state_xxh32(self), decoded_seed);
 			}
 
 			break;
 		case T_FIXNUM:
-			_xxh32_reset(_get_state_32(self), FIX2UINT(seed));
+			_xxh32_reset(_get_state_xxh32(self), FIX2UINT(seed));
 			break;
 		case T_BIGNUM:
-			_xxh32_reset(_get_state_32(self), NUM2UINT(seed));
+			_xxh32_reset(_get_state_xxh32(self), NUM2UINT(seed));
 			break;
 		default:
-			rb_raise(rb_eArgError, "Invalid argument type for seed.  Expecting a string or number.");
+			rb_raise(rb_eArgError, "Invalid argument type for 'seed'.  "
+					"Expecting a string or a number.");
 		}
 	} else {
-		_xxh32_reset(_get_state_32(self), _XXH32_DEFAULT_SEED);
+		_xxh32_reset(_get_state_xxh32(self), _XXH32_DEFAULT_SEED);
 	}
 
 	return self;
@@ -491,14 +513,14 @@ static VALUE _Digest_XXH32_reset(int argc, VALUE* argv, VALUE self)
  */
 static VALUE _Digest_XXH32_initialize_copy(VALUE self, VALUE orig)
 {
-	XXH32_copyState(_get_state_32(self), _get_state_32(orig));
+	XXH32_copyState(_get_state_xxh32(self), _get_state_xxh32(orig));
 	return self;
 }
 
 /*
  * call-seq: digest_length -> int
  *
- * Returns 4.
+ * Returns 4
  */
 static VALUE _Digest_XXH32_digest_length(VALUE self)
 {
@@ -508,7 +530,7 @@ static VALUE _Digest_XXH32_digest_length(VALUE self)
 /*
  * call-seq: block_length  -> int
  *
- * Returns 4.
+ * Returns 4
  */
 static VALUE _Digest_XXH32_block_length(VALUE self)
 {
@@ -518,7 +540,7 @@ static VALUE _Digest_XXH32_block_length(VALUE self)
 /*
  * call-seq: digest_length -> int
  *
- * Returns 4.
+ * Returns 4
  */
 static VALUE _Digest_XXH32_singleton_digest_length(VALUE self)
 {
@@ -528,7 +550,7 @@ static VALUE _Digest_XXH32_singleton_digest_length(VALUE self)
 /*
  * call-seq: block_length -> int
  *
- * Returns 4.
+ * Returns 4
  */
 static VALUE _Digest_XXH32_singleton_block_length(VALUE self)
 {
@@ -543,10 +565,9 @@ static VALUE _Digest_XXH32_singleton_block_length(VALUE self)
 
 static VALUE _Digest_XXH64_internal_allocate(VALUE klass)
 {
-	XXH64_state_t *state_p;
-	VALUE obj = TypedData_Make_Struct(klass, XXH64_state_t, &_xxh64_state_data_type, state_p);
+	XXH64_state_t *state_p = XXH64_createState();
 	_xxh64_reset(state_p, 0);
-	return obj;
+	return TypedData_Wrap_Struct(klass, &_xxh64_state_data_type, state_p);
 }
 
 /*
@@ -556,8 +577,8 @@ static VALUE _Digest_XXH64_internal_allocate(VALUE klass)
  */
 static VALUE _Digest_XXH64_update(VALUE self, VALUE str)
 {
-	if (XXH64_update(_get_state_64(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
-		rb_raise(rb_eRuntimeError, "Failed to reset state.");
+	if (XXH64_update(_get_state_xxh64(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to update state.");
 
 	return self;
 }
@@ -565,15 +586,17 @@ static VALUE _Digest_XXH64_update(VALUE self, VALUE str)
 /* :nodoc: */
 static VALUE _Digest_XXH64_finish(VALUE self)
 {
-	uint64_t result = XXH64_digest(_get_state_64(self));
-	return _encode_big_endian_64(result);
+	XXH64_hash_t hash = XXH64_digest(_get_state_xxh64(self));
+	VALUE str = rb_usascii_str_new(0, sizeof(XXH64_canonical_t));
+	XXH64_canonicalFromHash((XXH64_canonical_t *)RSTRING_PTR(str), hash);
+	return str;
 }
 
 /* :nodoc: */
 static VALUE _Digest_XXH64_ifinish(VALUE self)
 {
-	uint64_t result = XXH64_digest(_get_state_64(self));
-	return ULL2NUM(result);
+	XXH64_hash_t hash = XXH64_digest(_get_state_xxh64(self));
+	return ULL2NUM(hash);
 }
 
 /*
@@ -581,9 +604,10 @@ static VALUE _Digest_XXH64_ifinish(VALUE self)
  *
  * Resets state to initial form with seed.
  *
- * This would discard previous calculations with #update.
+ * This discards previous calculations with #update.
  *
  * +seed+ can be in the form of a string, a hex string, or a number.
+ * Its virtual length should be 64-bits.
  *
  * If +seed+ is not provided, the default value would be 0.
  */
@@ -596,36 +620,39 @@ static VALUE _Digest_XXH64_reset(int argc, VALUE* argv, VALUE self)
 		case T_STRING:
 			{
 				int len = RSTRING_LEN(seed);
-				uint64_t decoded_seed;
+				XXH64_hash_t decoded_seed;
 
-				if (len == (sizeof(uint64_t) * 2)) {
-					unsigned char hex_decoded_seed[sizeof(uint64_t)];
+				if (len == _TWICE(sizeof(XXH64_hash_t))) {
+					unsigned char hex_decoded_seed[sizeof(XXH64_hash_t)];
 
-					if (! hex_decode_str_implied(RSTRING_PTR(seed), sizeof(uint64_t) * 2, hex_decoded_seed))
-						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n", StringValueCStr(seed));
+					if (! hex_decode_str_implied(_RSTRING_PTR_U(seed), len, hex_decoded_seed))
+						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n",
+								StringValueCStr(seed));
 
-					decoded_seed = _decode_big_endian_64_cstr(hex_decoded_seed);
-				} else if (len == sizeof(uint64_t)) {
-					decoded_seed = _decode_big_endian_64_cstr(RSTRING_PTR(seed));
+					decoded_seed = XXH_readBE64(hex_decoded_seed);
+				} else if (len == sizeof(XXH64_hash_t)) {
+					decoded_seed = XXH_readBE64(RSTRING_PTR(seed));
 				} else {
-					rb_raise(rb_eArgError, "Invalid seed length.  Expecting a 16-character hex string or an 8-byte string.");
+					rb_raise(rb_eArgError, "Invalid seed length.  "
+							"Expecting a 16-character hex string or an 8-byte string.");
 				}
 
-				_xxh64_reset(_get_state_64(self), decoded_seed);
+				_xxh64_reset(_get_state_xxh64(self), decoded_seed);
 			}
 
 			break;
 		case T_FIXNUM:
-			_xxh64_reset(_get_state_64(self), FIX2UINT(seed));
+			_xxh64_reset(_get_state_xxh64(self), FIX2UINT(seed));
 			break;
 		case T_BIGNUM:
-			_xxh64_reset(_get_state_64(self), NUM2ULL(seed));
+			_xxh64_reset(_get_state_xxh64(self), NUM2ULL(seed));
 			break;
 		default:
-			rb_raise(rb_eArgError, "Invalid argument type for seed.  Expecting a string or number.");
+			rb_raise(rb_eArgError, "Invalid argument type for 'seed'.  "
+					"Expecting a string or a number.");
 		}
 	} else {
-		_xxh64_reset(_get_state_64(self), _XXH64_DEFAULT_SEED);
+		_xxh64_reset(_get_state_xxh64(self), _XXH64_DEFAULT_SEED);
 	}
 
 	return self;
@@ -639,14 +666,14 @@ static VALUE _Digest_XXH64_reset(int argc, VALUE* argv, VALUE self)
  */
 static VALUE _Digest_XXH64_initialize_copy(VALUE self, VALUE orig)
 {
-	XXH64_copyState(_get_state_64(self), _get_state_64(orig));
+	XXH64_copyState(_get_state_xxh64(self), _get_state_xxh64(orig));
 	return self;
 }
 
 /*
  * call-seq: digest_length -> int
  *
- * Returns 8.
+ * Returns 8
  */
 static VALUE _Digest_XXH64_digest_length(VALUE self)
 {
@@ -656,7 +683,7 @@ static VALUE _Digest_XXH64_digest_length(VALUE self)
 /*
  * call-seq: block_length -> int
  *
- * Returns 8.
+ * Returns 8
  */
 static VALUE _Digest_XXH64_block_length(VALUE self)
 {
@@ -666,7 +693,7 @@ static VALUE _Digest_XXH64_block_length(VALUE self)
 /*
  * call-seq: digest_length -> int
  *
- * Returns 8.
+ * Returns 8
  */
 static VALUE _Digest_XXH64_singleton_digest_length(VALUE self)
 {
@@ -676,13 +703,378 @@ static VALUE _Digest_XXH64_singleton_digest_length(VALUE self)
 /*
  * call-seq: block_length -> int
  *
- * Returns 8.
+ * Returns 8
  */
 static VALUE _Digest_XXH64_singleton_block_length(VALUE self)
 {
 	return INT2FIX(_XXH64_BLOCK_SIZE);
 }
 
+/*
+ * Document-class: Digest::XXH3_64bits
+ *
+ * This class implements XXH3_64bits.
+ */
+
+static VALUE _Digest_XXH3_64bits_internal_allocate(VALUE klass)
+{
+	XXH3_state_t *state_p = XXH3_createState();
+	XXH3_64bits_reset(state_p);
+	return TypedData_Wrap_Struct(klass, &_xxh3_64bits_state_data_type, state_p);
+}
+
+/*
+ * call-seq: update(str) -> self
+ *
+ * Updates current digest value with string.
+ */
+static VALUE _Digest_XXH3_64bits_update(VALUE self, VALUE str)
+{
+	if (XXH3_64bits_update(_get_state_xxh3_64bits(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to update state.");
+
+	return self;
+}
+
+/* :nodoc: */
+static VALUE _Digest_XXH3_64bits_finish(VALUE self)
+{
+	XXH64_hash_t hash = XXH3_64bits_digest(_get_state_xxh3_64bits(self));
+	VALUE str = rb_usascii_str_new(0, sizeof(XXH64_canonical_t));
+	XXH64_canonicalFromHash((XXH64_canonical_t *)RSTRING_PTR(str), hash);
+	return str;
+}
+
+/* :nodoc: */
+static VALUE _Digest_XXH3_64bits_ifinish(VALUE self)
+{
+	XXH64_hash_t hash = XXH3_64bits_digest(_get_state_xxh3_64bits(self));
+	return ULL2NUM(hash);
+}
+
+/*
+ * call-seq: reset(seed = 0) -> self
+ *
+ * Resets state to initial form with seed.
+ *
+ * This discards previous calculations with #update.
+ *
+ * +seed+ can be in the form of a string, a hex string, or a number.
+ * Its virtual length should be 64-bits.
+ *
+ * If +seed+ is not provided, the default value would be 0.
+ */
+static VALUE _Digest_XXH3_64bits_reset(int argc, VALUE* argv, VALUE self)
+{
+	VALUE seed;
+
+	if (rb_scan_args(argc, argv, "01", &seed) > 0) {
+		switch (TYPE(seed)) {
+		case T_STRING:
+			{
+				int len = RSTRING_LEN(seed);
+				XXH64_hash_t decoded_seed;
+
+				if (len == _TWICE(sizeof(XXH64_hash_t))) {
+					unsigned char hex_decoded_seed[sizeof(XXH64_hash_t)];
+
+					if (! hex_decode_str_implied(_RSTRING_PTR_U(seed), len, hex_decoded_seed))
+						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n",
+								StringValueCStr(seed));
+
+					decoded_seed = XXH_readBE64(hex_decoded_seed);
+				} else if (len == sizeof(XXH64_hash_t)) {
+					decoded_seed = XXH_readBE64(RSTRING_PTR(seed));
+				} else {
+					rb_raise(rb_eArgError, "Invalid seed length.  "
+							"Expecting a 16-character hex string or an 8-byte string.");
+				}
+
+				_xxh3_64bits_reset(_get_state_xxh3_64bits(self), decoded_seed);
+			}
+
+			break;
+		case T_FIXNUM:
+			_xxh3_64bits_reset(_get_state_xxh3_64bits(self), FIX2UINT(seed));
+			break;
+		case T_BIGNUM:
+			_xxh3_64bits_reset(_get_state_xxh3_64bits(self), NUM2ULL(seed));
+			break;
+		default:
+			rb_raise(rb_eArgError, "Invalid argument type for 'seed'.  "
+					"Expecting a string or a number.");
+		}
+	} else {
+		_xxh3_64bits_reset(_get_state_xxh3_64bits(self), _XXH3_64BITS_DEFAULT_SEED);
+	}
+
+	return self;
+}
+
+/*
+ * call-seq: reset_with_secret(secret) -> self
+ *
+ * Resets state to initial form using a secret.
+ *
+ * This discards previous calculations with #update.
+ *
+ * Secret should be a string and have a minimum length of XXH3_SECRET_SIZE_MIN.
+ */
+static VALUE _Digest_XXH3_64bits_reset_with_secret(VALUE self, VALUE secret)
+{
+	if (TYPE(secret) != T_STRING)
+		rb_raise(rb_eArgError, "Argument 'secret' needs to be a string.");
+
+	if (RSTRING_LEN(secret) < XXH3_SECRET_SIZE_MIN)
+		rb_raise(rb_eRuntimeError, "Secret needs to be at least %d bytes in length.",
+				XXH3_SECRET_SIZE_MIN);
+
+	if (XXH3_64bits_reset_withSecret(_get_state_xxh3_64bits(self), RSTRING_PTR(secret),
+			RSTRING_LEN(secret)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state with secret.");
+
+	return self;
+}
+
+/*
+ * call-seq: initialize_copy(orig) -> self
+ *
+ * This method is called when instances are cloned.  It is responsible for
+ * replicating internal data.
+ */
+static VALUE _Digest_XXH3_64bits_initialize_copy(VALUE self, VALUE orig)
+{
+	XXH3_copyState(_get_state_xxh3_64bits(self), _get_state_xxh3_64bits(orig));
+	return self;
+}
+
+/*
+ * call-seq: digest_length -> int
+ *
+ * Returns 8
+ */
+static VALUE _Digest_XXH3_64bits_digest_length(VALUE self)
+{
+	return INT2FIX(_XXH3_64BITS_DIGEST_SIZE);
+}
+
+/*
+ * call-seq: block_length -> int
+ *
+ * Returns 8
+ */
+static VALUE _Digest_XXH3_64bits_block_length(VALUE self)
+{
+	return INT2FIX(_XXH3_64BITS_BLOCK_SIZE);
+}
+
+/*
+ * call-seq: digest_length -> int
+ *
+ * Returns 8
+ */
+static VALUE _Digest_XXH3_64bits_singleton_digest_length(VALUE self)
+{
+	return INT2FIX(_XXH3_64BITS_DIGEST_SIZE);
+}
+
+/*
+ * call-seq: block_length -> int
+ *
+ * Returns 8
+ */
+static VALUE _Digest_XXH3_64bits_singleton_block_length(VALUE self)
+{
+	return INT2FIX(_XXH3_64BITS_BLOCK_SIZE);
+}
+
+/*
+ * Document-class: Digest::XXH3_128bits
+ *
+ * This class implements XXH3_128bits.
+ */
+
+static VALUE _Digest_XXH3_128bits_internal_allocate(VALUE klass)
+{
+	XXH3_state_t *state_p = XXH3_createState();
+	XXH3_128bits_reset(state_p);
+	return TypedData_Wrap_Struct(klass, &_xxh3_128bits_state_data_type, state_p);
+}
+
+/*
+ * call-seq: update(str) -> self
+ *
+ * Updates current digest value with string.
+ */
+static VALUE _Digest_XXH3_128bits_update(VALUE self, VALUE str)
+{
+	if (XXH3_128bits_update(_get_state_xxh3_128bits(self), RSTRING_PTR(str), RSTRING_LEN(str)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to update state.");
+
+	return self;
+}
+
+/* :nodoc: */
+static VALUE _Digest_XXH3_128bits_finish(VALUE self)
+{
+	XXH128_hash_t hash = XXH3_128bits_digest(_get_state_xxh3_128bits(self));
+	VALUE str = rb_usascii_str_new(0, sizeof(XXH128_canonical_t));
+	XXH128_canonicalFromHash((XXH128_canonical_t *)RSTRING_PTR(str), hash);
+	return str;
+}
+
+/* :nodoc: */
+static VALUE _Digest_XXH3_128bits_ifinish(VALUE self)
+{
+	XXH128_hash_t hash = XXH3_128bits_digest(_get_state_xxh3_128bits(self));
+
+	if (! XXH_CPU_LITTLE_ENDIAN) {
+		#define _SWAP_WORDS(x) ((x << 32) & 0xffffffff00000000ULL) | \
+			((x >> 32) & 0x000000000ffffffffULL)
+		hash.low64 = _SWAP_WORDS(hash.low64);
+		hash.high64 = _SWAP_WORDS(hash.high64);
+	}
+
+	return rb_integer_unpack(&hash, 4, sizeof(XXH32_hash_t), 0, INTEGER_PACK_LSWORD_FIRST|
+			INTEGER_PACK_NATIVE_BYTE_ORDER);
+}
+
+/*
+ * call-seq: reset(seed = 0) -> self
+ *
+ * Resets state to initial form with seed.
+ *
+ * This discards previous calculations with #update.
+ *
+ * +seed+ can be in the form of a string, a hex string, or a number.
+ * Its virtual length should be 64-bits and not 128-bits.
+ *
+ * If +seed+ is not provided, the default value would be 0.
+ */
+static VALUE _Digest_XXH3_128bits_reset(int argc, VALUE* argv, VALUE self)
+{
+	VALUE seed;
+
+	if (rb_scan_args(argc, argv, "01", &seed) > 0) {
+		switch (TYPE(seed)) {
+		case T_STRING:
+			{
+				int len = RSTRING_LEN(seed);
+				XXH64_hash_t decoded_seed;
+
+				if (len == _TWICE(sizeof(XXH64_hash_t))) {
+					unsigned char hex_decoded_seed[sizeof(XXH64_hash_t)];
+
+					if (! hex_decode_str_implied(_RSTRING_PTR_U(seed), len, hex_decoded_seed))
+						rb_raise(rb_eArgError, "Invalid hex string seed: %s\n",
+								StringValueCStr(seed));
+
+					decoded_seed = XXH_readBE64(hex_decoded_seed);
+				} else if (len == sizeof(XXH64_hash_t)) {
+					decoded_seed = XXH_readBE64(RSTRING_PTR(seed));
+				} else {
+					rb_raise(rb_eArgError, "Invalid seed length.  Expecting a 16-character hex "
+							"string or an 8-byte string.");
+				}
+
+				_xxh3_128bits_reset(_get_state_xxh3_128bits(self), decoded_seed);
+			}
+
+			break;
+		case T_FIXNUM:
+			_xxh3_128bits_reset(_get_state_xxh3_128bits(self), FIX2UINT(seed));
+			break;
+		case T_BIGNUM:
+			_xxh3_128bits_reset(_get_state_xxh3_128bits(self), NUM2ULL(seed));
+			break;
+		default:
+			rb_raise(rb_eArgError, "Invalid argument type for 'seed'.  "
+					"Expecting a string or a number.");
+		}
+	} else {
+		_xxh3_128bits_reset(_get_state_xxh3_128bits(self), _XXH3_128BITS_DEFAULT_SEED);
+	}
+
+	return self;
+}
+
+/*
+ * call-seq: reset_with_secret(secret) -> self
+ *
+ * Resets state to initial form using a secret.
+ *
+ * This discards previous calculations with #update.
+ *
+ * Secret should be a string having a minimum length of XXH3_SECRET_SIZE_MIN.
+ */
+static VALUE _Digest_XXH3_128bits_reset_with_secret(VALUE self, VALUE secret)
+{
+	if (TYPE(secret) != T_STRING)
+		rb_raise(rb_eArgError, "Argument 'secret' needs to be a string.");
+
+	if (RSTRING_LEN(secret) < XXH3_SECRET_SIZE_MIN)
+		rb_raise(rb_eRuntimeError, "Secret needs to be at least %d bytes in length.",
+				XXH3_SECRET_SIZE_MIN);
+
+	if (XXH3_128bits_reset_withSecret(_get_state_xxh3_128bits(self), RSTRING_PTR(secret),
+			RSTRING_LEN(secret)) != XXH_OK)
+		rb_raise(rb_eRuntimeError, "Failed to reset state with secret.");
+
+	return self;
+}
+
+/*
+ * call-seq: initialize_copy(orig) -> self
+ *
+ * This method is called when instances are cloned.  It is responsible for
+ * replicating internal data.
+ */
+static VALUE _Digest_XXH3_128bits_initialize_copy(VALUE self, VALUE orig)
+{
+	XXH3_copyState(_get_state_xxh3_128bits(self), _get_state_xxh3_128bits(orig));
+	return self;
+}
+
+/*
+ * call-seq: digest_length -> int
+ *
+ * Returns 16
+ */
+static VALUE _Digest_XXH3_128bits_digest_length(VALUE self)
+{
+	return INT2FIX(_XXH3_128BITS_DIGEST_SIZE);
+}
+
+/*
+ * call-seq: block_length -> int
+ *
+ * Returns 16
+ */
+static VALUE _Digest_XXH3_128bits_block_length(VALUE self)
+{
+	return INT2FIX(_XXH3_128BITS_BLOCK_SIZE);
+}
+
+/*
+ * call-seq: digest_length -> int
+ *
+ * Returns 16
+ */
+static VALUE _Digest_XXH3_128bits_singleton_digest_length(VALUE self)
+{
+	return INT2FIX(_XXH3_128BITS_DIGEST_SIZE);
+}
+
+/*
+ * call-seq: block_length -> int
+ *
+ * Returns 16
+ */
+static VALUE _Digest_XXH3_128bits_singleton_block_length(VALUE self)
+{
+	return INT2FIX(_XXH3_128BITS_BLOCK_SIZE);
+}
+
 /*
  * Initialization
  */
@@ -700,19 +1092,22 @@ void Init_xxhash()
 	DEFINE_ID(reset)
 	DEFINE_ID(update)
 
-	#if 0
-	_Digest = rb_define_module("Digest"); /* Tell RDoc about Digest since it doesn't recognize rb_path2class. */
-	#endif
-
 	rb_require("digest");
 	_Digest = rb_path2class("Digest");
+	_Digest_Class = rb_path2class("Digest::Class");
+
+	#if 0
+	/* Tell RDoc about Digest and Digest::Class since it doesn't parse rb_path2class. */
+	_Digest = rb_define_module("Digest");
+	_Digest_Class = rb_define_class_under(_Digest, "Class", rb_cObject);
+	#endif
 
 	/*
 	 * Document-class: Digest::XXHash
 	 */
 
-	_Digest_XXHash = rb_define_class_under(_Digest, "XXHash", rb_path2class("Digest::Class"));
-
+	_Digest_XXHash = rb_define_class_under(_Digest, "XXHash", _Digest_Class);
+	rb_define_alloc_func(_Digest_XXHash, _Digest_XXHash_internal_allocate);
 	rb_define_method(_Digest_XXHash, "digest", _Digest_XXHash_digest, -1);
 	rb_define_method(_Digest_XXHash, "hexdigest", _Digest_XXHash_hexdigest, -1);
 	rb_define_method(_Digest_XXHash, "idigest", _Digest_XXHash_idigest, -1);
@@ -720,32 +1115,24 @@ void Init_xxhash()
 	rb_define_method(_Digest_XXHash, "initialize", _Digest_XXHash_initialize, -1);
 	rb_define_method(_Digest_XXHash, "inspect", _Digest_XXHash_inspect, 0);
 	rb_define_method(_Digest_XXHash, "initialize_copy", _Digest_XXHash_initialize_copy, 1);
-
 	rb_define_protected_method(_Digest_XXHash, "ifinish", _Digest_XXHash_ifinish, 0);
-
 	rb_define_singleton_method(_Digest_XXHash, "digest", _Digest_XXHash_singleton_digest, -1);
 	rb_define_singleton_method(_Digest_XXHash, "hexdigest", _Digest_XXHash_singleton_hexdigest, -1);
 	rb_define_singleton_method(_Digest_XXHash, "idigest", _Digest_XXHash_singleton_idigest, -1);
 
-	rb_define_alloc_func(_Digest_XXHash, _Digest_XXHash_internal_allocate);
-
 	/*
 	 * Document-class: Digest::XXH32
 	 */
 
 	_Digest_XXH32 = rb_define_class_under(_Digest, "XXH32", _Digest_XXHash);
-
 	rb_define_alloc_func(_Digest_XXH32, _Digest_XXH32_internal_allocate);
-
 	rb_define_private_method(_Digest_XXH32, "finish", _Digest_XXH32_finish, 0);
 	rb_define_private_method(_Digest_XXH32, "ifinish", _Digest_XXH32_ifinish, 0);
-
 	rb_define_method(_Digest_XXH32, "update", _Digest_XXH32_update, 1);
 	rb_define_method(_Digest_XXH32, "reset", _Digest_XXH32_reset, -1);
 	rb_define_method(_Digest_XXH32, "digest_length", _Digest_XXH32_digest_length, 0);
 	rb_define_method(_Digest_XXH32, "block_length", _Digest_XXH32_block_length, 0);
 	rb_define_method(_Digest_XXH32, "initialize_copy", _Digest_XXH32_initialize_copy, 1);
-
 	rb_define_singleton_method(_Digest_XXH32, "digest_length", _Digest_XXH32_singleton_digest_length, 0);
 	rb_define_singleton_method(_Digest_XXH32, "block_length", _Digest_XXH32_singleton_block_length, 0);
 
@@ -754,18 +1141,60 @@ void Init_xxhash()
 	 */
 
 	_Digest_XXH64 = rb_define_class_under(_Digest, "XXH64", _Digest_XXHash);
-
 	rb_define_alloc_func(_Digest_XXH64, _Digest_XXH64_internal_allocate);
-
 	rb_define_private_method(_Digest_XXH64, "finish", _Digest_XXH64_finish, 0);
 	rb_define_private_method(_Digest_XXH64, "ifinish", _Digest_XXH64_ifinish, 0);
-
 	rb_define_method(_Digest_XXH64, "update", _Digest_XXH64_update, 1);
 	rb_define_method(_Digest_XXH64, "reset", _Digest_XXH64_reset, -1);
 	rb_define_method(_Digest_XXH64, "digest_length", _Digest_XXH64_digest_length, 0);
 	rb_define_method(_Digest_XXH64, "block_length", _Digest_XXH64_block_length, 0);
 	rb_define_method(_Digest_XXH64, "initialize_copy", _Digest_XXH64_initialize_copy, 1);
-
 	rb_define_singleton_method(_Digest_XXH64, "digest_length", _Digest_XXH64_singleton_digest_length, 0);
 	rb_define_singleton_method(_Digest_XXH64, "block_length", _Digest_XXH64_singleton_block_length, 0);
+
+	/*
+	 * Document-class: Digest::XXH3_64bits
+	 */
+
+	_Digest_XXH3_64bits = rb_define_class_under(_Digest, "XXH3_64bits", _Digest_XXHash);
+	rb_define_alloc_func(_Digest_XXH3_64bits, _Digest_XXH3_64bits_internal_allocate);
+	rb_define_private_method(_Digest_XXH3_64bits, "finish", _Digest_XXH3_64bits_finish, 0);
+	rb_define_private_method(_Digest_XXH3_64bits, "ifinish", _Digest_XXH3_64bits_ifinish, 0);
+	rb_define_method(_Digest_XXH3_64bits, "update", _Digest_XXH3_64bits_update, 1);
+	rb_define_method(_Digest_XXH3_64bits, "reset", _Digest_XXH3_64bits_reset, -1);
+	rb_define_method(_Digest_XXH3_64bits, "reset_with_secret", _Digest_XXH3_64bits_reset_with_secret, 1);
+	rb_define_method(_Digest_XXH3_64bits, "digest_length", _Digest_XXH3_64bits_digest_length, 0);
+	rb_define_method(_Digest_XXH3_64bits, "block_length", _Digest_XXH3_64bits_block_length, 0);
+	rb_define_method(_Digest_XXH3_64bits, "initialize_copy", _Digest_XXH3_64bits_initialize_copy, 1);
+	rb_define_singleton_method(_Digest_XXH3_64bits, "digest_length", _Digest_XXH3_64bits_singleton_digest_length, 0);
+	rb_define_singleton_method(_Digest_XXH3_64bits, "block_length", _Digest_XXH3_64bits_singleton_block_length, 0);
+
+	/*
+	 * Document-class: Digest::XXH3_128bits
+	 */
+
+	_Digest_XXH3_128bits = rb_define_class_under(_Digest, "XXH3_128bits", _Digest_XXHash);
+	rb_define_alloc_func(_Digest_XXH3_128bits, _Digest_XXH3_128bits_internal_allocate);
+	rb_define_private_method(_Digest_XXH3_128bits, "finish", _Digest_XXH3_128bits_finish, 0);
+	rb_define_private_method(_Digest_XXH3_128bits, "ifinish", _Digest_XXH3_128bits_ifinish, 0);
+	rb_define_method(_Digest_XXH3_128bits, "update", _Digest_XXH3_128bits_update, 1);
+	rb_define_method(_Digest_XXH3_128bits, "reset", _Digest_XXH3_128bits_reset, -1);
+	rb_define_method(_Digest_XXH3_128bits, "reset_with_secret", _Digest_XXH3_128bits_reset_with_secret, 1);
+	rb_define_method(_Digest_XXH3_128bits, "digest_length", _Digest_XXH3_128bits_digest_length, 0);
+	rb_define_method(_Digest_XXH3_128bits, "block_length", _Digest_XXH3_128bits_block_length, 0);
+	rb_define_method(_Digest_XXH3_128bits, "initialize_copy", _Digest_XXH3_128bits_initialize_copy, 1);
+	rb_define_singleton_method(_Digest_XXH3_128bits, "digest_length", _Digest_XXH3_128bits_singleton_digest_length, 0);
+	rb_define_singleton_method(_Digest_XXH3_128bits, "block_length", _Digest_XXH3_128bits_singleton_block_length, 0);
+
+	/*
+	 * Document-const: Digest::XXHash::XXH3_SECRET_SIZE_MIN
+	 *
+	 * Minimum allowed custom secret size defined in the core XXHash
+	 * code.  The current value is 136.
+	 *
+	 * The author of Digest::XXHash doesn't know if this value would
+	 * change in the future.
+	 */
+
+	rb_define_const(_Digest_XXHash, "XXH3_SECRET_SIZE_MIN", INT2FIX(XXH3_SECRET_SIZE_MIN));
 }