Enum SkippableChecksum

pub enum SkippableChecksum<D: Digest + Clone> {
    Skip,
    Checksum {
        digest: Checksum<D>,
    },
}

A Checksum that may be skipped.

Strings representing checksums are used to verify the integrity of files. If the "SKIP" keyword is found, the integrity check is skipped.

Variants

Skip

Sourcefile checksum validation may be skipped, which is expressed with this variant.

Checksum

The related source file should be validated via the provided checksum.

Fields

digest: Checksum<D>

The checksum to be used for the validation.

Implementations

impl<D: Digest + Clone> SkippableChecksum<D>

pub fn parser(input: &mut &str) -> ModalResult<Self>

Recognizes a SkippableChecksum from a string slice.

Consumes all its input. See SkippableChecksum::from_str, Checksum::parser and Checksum::from_str.

Errors

Returns an error if input is not the output of a hash function in hexadecimal form.

Trait Implementations

impl<D: Clone + Digest + Clone> Clone for SkippableChecksum<D>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Debug + Digest + Clone> Debug for SkippableChecksum<D>

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

Formats the value using the given formatter.

impl<'de, D> Deserialize<'de> for SkippableChecksum<D>

where D: Digest + Clone,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<D: Digest + Clone> Display for SkippableChecksum<D>

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

Formats the value using the given formatter.

impl<D: Digest + Clone> FromStr for SkippableChecksum<D>

fn from_str(s: &str) -> Result<SkippableChecksum<D>, Self::Err>

Create a new SkippableChecksum from a string slice and return it in a Result.

First checks for the special SKIP keyword, before trying Checksum::from_str.

Delegates to SkippableChecksum::parser.

Examples

use std::str::FromStr;

use alpm_types::{SkippableChecksum, digests::Sha256};

assert!(SkippableChecksum::<Sha256>::from_str("SKIP").is_ok());
assert!(
    SkippableChecksum::<Sha256>::from_str(
        "b5bb9d8014a0f9b1d61e21e796d78dccdf1352f23cd32812f4850b878ae4944c"
    )
    .is_ok()
);

type Err = Error

The associated error which can be returned from parsing.

impl<D: Digest + Clone> PartialEq for SkippableChecksum<D>

fn eq(&self, other: &Self) -> 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<D> Serialize for SkippableChecksum<D>

where D: Digest + Clone,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.