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

Download history 67265/week @ 2024-07-16 65073/week @ 2024-07-23 55711/week @ 2024-07-30 63361/week @ 2024-08-06 76767/week @ 2024-08-13 58481/week @ 2024-08-20 68436/week @ 2024-08-27 78323/week @ 2024-09-03 69152/week @ 2024-09-10 64347/week @ 2024-09-17 65951/week @ 2024-09-24 70271/week @ 2024-10-01 71318/week @ 2024-10-08 73608/week @ 2024-10-15 73305/week @ 2024-10-22 48957/week @ 2024-10-29

282,239 downloads per month
Used in 656 crates (7 directly)

MIT license

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