Struct libipld::cid::multihash::MultihashGeneric

source ·

pub struct MultihashGeneric<const S: usize> { /* private fields */ }

Expand description

A Multihash instance that only supports the basic functionality and no hashing.

With this Multihash implementation you can operate on Multihashes in a generic way, but no hasher implementation is associated with the code.

§Example

use multihash::Multihash;

const Sha3_256: u64 = 0x16;
let digest_bytes = [
    0x16, 0x20, 0x64, 0x4b, 0xcc, 0x7e, 0x56, 0x43, 0x73, 0x04, 0x09, 0x99, 0xaa, 0xc8, 0x9e,
    0x76, 0x22, 0xf3, 0xca, 0x71, 0xfb, 0xa1, 0xd9, 0x72, 0xfd, 0x94, 0xa3, 0x1c, 0x3b, 0xfb,
    0xf2, 0x4e, 0x39, 0x38,
];
let mh = Multihash::from_bytes(&digest_bytes).unwrap();
assert_eq!(mh.code(), Sha3_256);
assert_eq!(mh.size(), 32);
assert_eq!(mh.digest(), &digest_bytes[2..]);

Implementations§

source §

impl<const S: usize> Multihash<S>

source

pub const fn wrap(code: u64, input_digest: &[u8]) -> Result<Multihash<S>, Error>

Wraps the digest in a multihash.

source

pub const fn code(&self) -> u64

Returns the code of the multihash.

source

pub const fn size(&self) -> u8

Returns the size of the digest.

source

pub fn digest(&self) -> &[u8] ⓘ

Returns the digest.

source

pub fn read<R>(r: R) -> Result<Multihash<S>, Error>
where R: Read, Multihash<S>: Sized,

Reads a multihash from a byte stream.

source

pub fn from_bytes(bytes: &[u8]) -> Result<Multihash<S>, Error>
where Multihash<S>: Sized,

Parses a multihash from a bytes.

You need to make sure the passed in bytes have the correct length. The digest length needs to match the size value of the multihash.

source

pub fn write<W>(&self, w: W) -> Result<usize, Error>
where W: Write,

Writes a multihash to a byte stream, returning the written size.

source

pub fn encoded_len(&self) -> usize

Returns the length in bytes needed to encode this multihash into bytes.

source

pub fn to_bytes(&self) -> Vec<u8> ⓘ

Returns the bytes of a multihash.

source

pub fn truncate(&self, size: u8) -> Multihash<S>

Truncates the multihash to the given size. It’s up to the caller to ensure that the new size is secure (cryptographically) to use.

If the new size is larger than the current size, this method does nothing.

use multihash::{Code, MultihashDigest};

let hash = Code::Sha3_256.digest(b"Hello world!").truncate(20);

source

pub fn resize<const R: usize>(&self) -> Result<Multihash<R>, Error>

Resizes the backing multihash buffer. This function fails if the hash digest is larger than the target size.

use multihash::{Code, MultihashDigest, MultihashGeneric};

let hash = Code::Sha3_256.digest(b"Hello world!");
let large_hash: MultihashGeneric<32> = hash.resize().unwrap();

source

pub fn into_inner(self) -> (u64, [u8; S], u8)

Decomposes struct, useful when needing a Sized array or moving all the data into another type

It is recommended to use digest() code() and size() for most cases

use multihash::{Code, MultihashDigest};
struct Foo<const S: usize> {
    arr: [u8; S],
    len: usize,
}

let hash = Code::Sha3_256.digest(b"Hello world!");
let (.., arr, size) = hash.into_inner();
let foo = Foo { arr, len: size as usize };