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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
A Rust implementation of the [xxHash] algorithm.
[![Crates.io][crates-badge]][crates-url]
[![Documentation][docs-badge]][docs-url]
[![Build Status][actions-badge]][actions-url]
[xxHash]: https://github.com/Cyan4973/xxHash
[crates-badge]: https://img.shields.io/crates/v/twox-hash.svg
[crates-url]: https://crates.io/crates/twox-hash
[docs-badge]: https://img.shields.io/docsrs/twox-hash
[docs-url]: https://docs.rs/twox-hash/
[actions-badge]: https://github.com/shepmaster/twox-hash/actions/workflows/ci.yml/badge.svg?branch=main
[actions-url]: https://github.com/shepmaster/twox-hash/actions/workflows/ci.yml?query=branch%3Amain
# Examples
These examples use [`XxHash64`][] but the same ideas can be
used for [`XxHash32`][], [`XxHash3_64`][], or [`XxHash3_128`][].
## Hashing arbitrary data
### When all the data is available at once
```rust
# #[cfg(feature = "xxhash64")]
# {
use twox_hash::XxHash64;
let seed = 1234;
let hash = XxHash64::oneshot(seed, b"some bytes");
assert_eq!(0xeab5_5659_a496_d78b, hash);
# }
```
### When the data is streaming
```rust
# #[cfg(feature = "xxhash64")]
# {
use std::hash::Hasher as _;
use twox_hash::XxHash64;
let seed = 1234;
let mut hasher = XxHash64::with_seed(seed);
hasher.write(b"some");
hasher.write(b" ");
hasher.write(b"bytes");
let hash = hasher.finish();
assert_eq!(0xeab5_5659_a496_d78b, hash);
# }
```
## In a [`HashMap`][]
### With a default seed
```rust
# #[cfg(feature = "xxhash64")]
# {
use std::{collections::HashMap, hash::BuildHasherDefault};
use twox_hash::XxHash64;
let mut hash = HashMap::<_, _, BuildHasherDefault<XxHash64>>::default();
hash.insert(42, "the answer");
assert_eq!(hash.get(&42), Some(&"the answer"));
# }
```
### With a random seed
```rust
# #[cfg(all(feature = "xxhash64", feature = "random"))]
# {
use std::collections::HashMap;
use twox_hash::xxhash64;
let mut hash = HashMap::<_, _, xxhash64::RandomState>::default();
hash.insert(42, "the answer");
assert_eq!(hash.get(&42), Some(&"the answer"));
# }
```
### With a fixed seed
```rust
# #[cfg(feature = "xxhash64")]
# {
use std::collections::HashMap;
use twox_hash::xxhash64;
let mut hash = HashMap::with_hasher(xxhash64::State::with_seed(0xdead_cafe));
hash.insert(42, "the answer");
assert_eq!(hash.get(&42), Some(&"the answer"));
# }
```
# Feature Flags
| name | description |
|-------------|-------------------------------------------------------------------------------------------------------------------------------|
| xxhash32 | Include the [`XxHash32`][] algorithm |
| xxhash64 | Include the [`XxHash64`][] algorithm |
| xxhash3_64 | Include the [`XxHash3_64`][] algorithm |
| xxhash3_128 | Include the [`XxHash3_128`][] algorithm |
| random | Create random instances of the hashers |
| serialize | Serialize and deserialize hasher state with Serde |
| std | Use the Rust standard library. Enable this if you want SIMD support in [`XxHash3_64`][] or [`XxHash3_128`][] |
| alloc | Use the Rust allocator library. Enable this if you want to create [`XxHash3_64`][] or [`XxHash3_128`][] with dynamic secrets |
# Benchmarks
See benchmarks in the [comparison][] README.
[comparison]: https://github.com/shepmaster/twox-hash/tree/main/comparison
# Contributing
1. Fork it (<https://github.com/shepmaster/twox-hash/fork>)
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Add a failing test.
4. Add code to pass the test.
5. Commit your changes (`git commit -am 'Add some feature'`)
6. Ensure tests pass.
7. Push to the branch (`git push origin my-new-feature`)
8. Create a new Pull Request
[`Hashmap`]: std::collections::HashMap
[`XxHash32`]: crate::XxHash32
[`XxHash64`]: crate::XxHash64
[`XxHash3_64`]: crate::XxHash3_64
[`XxHash3_128`]: crate::XxHash3_128
|
