twox-hash 2.0.0

A Rust implementation of the XXHash and XXH3 algorithms
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [2.0.0] - Unreleased

[2.0.0]: https://github.com/shepmaster/twox-hash/tree/v2.0.0

This release is a complete rewrite of the crate, including
reorganization of the code. The XXH3 algorithm now matches the 0.8
release of the reference C xxHash implementation.

### Added

- `XxHash32::oneshot` and `XxHash64::oneshot` can perform hashing with
  zero allocation and generally improved performance. If you have code
  that creates a hasher and hashes a slice of bytes exactly once, you
  are strongly encouraged to use the new functions. This might look
  like:

  ```rust
  // Before
  let mut hasher = XxHash64::new(); // or XxHash32, or with seeds
  some_bytes.hash(&mut hasher);
  let hash = hasher.finish();

  // After
  let hash = XxHash64::oneshot(some_bytes);
  ```

- There is a feature flag for each hashing implementation. It is
  recommended that you opt-out of the crate's default features and
  only select the implementations you need to improve compile speed.

### Changed

- The crates minimum supported Rust version (MSRV) is now 1.81.

- Functional and performance comparisons are made against the
  reference C xxHash library version 0.8.2, which includes a stable
  XXH3 algorithm.

- Support for randomly-generated hasher instances is now behind the
  `random` feature flag. It was previously combined with the `std`
  feature flag.

### Removed

- The deprecated type aliases `XxHash` and `RandomXxHashBuilder` have
  been removed. Replace them with `XxHash64` and
  `xxhash64::RandomState` respectively.

- `RandomXxHashBuilder32` and `RandomXxHashBuilder64` are no longer
  available at the top-level of the crate. Replace them with
  `xxhash32::RandomState` and ``xxhash64::RandomState` respectively.

- `Xxh3Hash64` and `xx3::Hash64` have been renamed to `XxHash3_64` and
  `xxhash3_64::Hasher` respectively.

- The free functions `xxh3::hash64`, `xxh3::hash64_with_seed`, and
  `xxh3::hash64_with_secret` are now associated functions of
  `xxhash3_64::Hasher`: `oneshot`, `oneshot_with_seed` and
  `oneshot_with_secret`. Note that the argument order has changed.

- Support for the [digest][] crate has been removed. The digest crate
  is for **cryptographic** hash functions and xxHash is
  **non-cryptographic**.

- `XxHash32` and `XxHash64` no longer implement `Copy`. This prevents
  accidentally mutating a duplicate instance of the state instead of
  the original state. `Clone` is still implemented so you can make
  deliberate duplicates.

- The XXH3 128-bit variant is not yet re-written. Work is in progress
  for this.

- We no longer provide support for randomly-generated instances of the
  XXH3 64-bit variant. The XXH3 algorithm takes both a seed and a
  secret as input and deciding what to randomize is non-trivial and
  can have negative impacts on performance.

[digest]: https://docs.rs/digest/latest/digest/