Struct libp2p::multihash::MultihashGeneric

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

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

impl<const S: usize> Multihash<S>

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

Wraps the digest in a multihash.

pub const fn code(&self) -> u64

Returns the code of the multihash.

pub const fn size(&self) -> u8

Returns the size of the digest.

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

Returns the digest.

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

Reads a multihash from a byte stream.

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.

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

Writes a multihash to a byte stream.

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

Returns the bytes of a multihash.

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);

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();

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 };

Trait Implementations

impl AsRef<Multihash<64>> for PeerId

fn as_ref(&self) -> &Multihash<64>

Converts this type into a shared reference of the (usually inferred) input type.

impl<const S: usize> Clone for Multihash<S>

fn clone(&self) -> Multihash<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const S: usize> Debug for Multihash<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<const S: usize> Default for Multihash<S>

fn default() -> Multihash<S>

Returns the “default value” for a type.

impl From<Multihash<64>> for Key

fn from(m: Multihash<64>) -> Key

Converts to this type from the input type.

impl From<Multihash<64>> for Key<Multihash<64>>

fn from(m: Multihash<64>) -> Key<Multihash<64>>

Converts to this type from the input type.

impl<const S: usize> From<Multihash<S>> for Vec<u8, Global>

fn from(multihash: Multihash<S>) -> Vec<u8, Global>

Converts to this type from the input type.

impl From<PeerId> for Multihash<64>

fn from(peer_id: PeerId) -> Multihash<64>

Converts to this type from the input type.

impl<const S: usize> Hash for Multihash<S>

fn hash<T>(&self, state: &mut T)where T: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const S: usize> Ord for Multihash<S>

fn cmp(&self, other: &Multihash<S>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<const A: usize, const B: usize> PartialEq<Multihash<B>> for Multihash<A>

fn eq(&self, other: &Multihash<B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const S: usize> PartialOrd<Multihash<S>> for Multihash<S>

fn partial_cmp(&self, other: &Multihash<S>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<Multihash<64>> for PeerId

type Error = Multihash<64>

The type returned in the event of a conversion error.

fn try_from( value: Multihash<64> ) -> Result<PeerId, <PeerId as TryFrom<Multihash<64>>>::Error>

Performs the conversion.

impl<const S: usize> Copy for Multihash<S>

impl<const S: usize> Eq for Multihash<S>

impl<const S: usize> StructuralEq for Multihash<S>