8 releases
0.9.1 | Oct 24, 2024 |
---|---|
0.9.0 | Jun 6, 2023 |
0.8.1 | Nov 7, 2022 |
0.8.0 | Feb 1, 2022 |
0.6.0 | Oct 30, 2020 |
#513 in Procedural macros
282,239 downloads per month
Used in 656 crates
(7 directly)
41KB
665 lines
A procedural macro for custom Multihash code tables.
This proc macro derives a custom Multihash code table from a list of hashers. It also
generates a public type called Multihash
which corresponds to the specified alloc_size
.
The digests are stack allocated with a fixed size. That size needs to be big enough to hold any
of the specified hash digests. This cannot be determined reliably on compile-time, hence it
needs to set manually via the alloc_size
attribute. Also you might want to set it to bigger
sizes then necessarily needed for backwards/forward compatibility.
If you set #mh(alloc_size = …)
to a too low value, you will get compiler errors. Please note
the the sizes are checked only on a syntactic level and not on the type level. This means
that digest need to have a size const generic, which is a valid usize
, for example 32
or
64
.
You can disable those compiler errors with setting the no_alloc_size_errors
attribute. This
can be useful if you e.g. have specified type aliases for your hash digests and you are sure
you use the correct value for alloc_size
.
When you want to define your own codetable, you should only depend on multihash-derive
.
It re-exports the multihash
crate for you.
Example
```ignore : proc-macro-crate
does not work in docs, see https://github.com/bkchr/proc-macro-crate/issues/14
use multihash_derive::{Hasher, MultihashDigest};
struct FooHasher;
impl Hasher for FooHasher { // Implement hasher ...
fn update(&mut self, input: &[u8]) {
}
fn finalize(&mut self) -> &[u8] {
&[]
}
fn reset(&mut self) {
}
}
#[derive(Clone, Copy, Debug, Eq, MultihashDigest, PartialEq)] #[mh(alloc_size = 64)] pub enum Code { #[mh(code = 0x01, hasher = FooHasher)] Foo }
let hash = Code::Foo.digest(b"hello world!");
println!("{:02x?}", hash);
Dependencies
~1.7–2.5MB
~47K SLoC