Struct D 

pub struct D<const N: usize>(/* private fields */);

Generic digest implementation.

This is used to make the “real” types you’d use every day, particularly Digest. This flexibility should be somewhat helpful if Sha256 ever proves inadequate, which isn’t likely in the near future, but is plausible on a long enough timescale.

Implementations

impl<const N: usize> D<N>

pub fn to_bytes(&self) -> &[u8; N]

Machine-friendly borrow of digest bytes.

pub fn from_bytes(bytes: &[u8; N]) -> D<N>

Import from some external source. Be careful to preserve invariants!

pub fn to_hex(&self) -> String

Human-friendly representation of digest bytes.

pub fn from_hex(h: impl AsRef<[u8]>) -> Result<D<N>, FromHexError>

Create a digest from a text hex

Trait Implementations

impl<const N: usize> Clone for D<N>

fn clone(&self) -> D<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for D<N>

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

Formats the value using the given formatter.

impl<'de, const N: usize> Deserialize<'de> for D<N>

fn deserialize<DE>( deserializer: DE, ) -> Result<D<N>, <DE as Deserializer<'de>>::Error>

where DE: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<T> for D<arkive::::types::digest::DigestSha256::{constant#0}>

where T: AsRef<[u8]>,

fn from(data: T) -> D<arkive::::types::digest::DigestSha256::{constant#0}>

Converts to this type from the input type.

impl<T> From<T> for D<arkive::::types::digest::DigestSha512::{constant#0}>

where T: AsRef<[u8]>,

fn from(data: T) -> D<arkive::::types::digest::DigestSha512::{constant#0}>

Converts to this type from the input type.

impl<const N: usize> PartialEq for D<N>

fn eq(&self, other: &D<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const N: usize> Serialize for D<N>

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize> Copy for D<N>

impl<const N: usize> StructuralPartialEq for D<N>