Method parser

alpm-types/src/checksum.rs:319–401

Recognizes an ASCII hexadecimal [`Checksum`] from a string slice. Consumes all input. See [`Checksum::from_str`]. # Errors Returns an error if `input` is not the output of a _hash function_ in hexadecimal (or decimal in case of CRC-32/CKSUM) form.

(input: &mut &str)

    /// # Errors
    ///
    /// Returns an error if `input` does not start with the output of a _hash function_
    /// in hexadecimal (or decimal in case of CRC-32/CKSUM) form.
    fn parser(input: &mut &str) -> ModalResult<Self> {
        /// Consume 1 hex digit and return its hex value.
        ///
        /// Accepts uppercase or lowercase.
        #[inline]
        fn hex_digit(input: &mut &str) -> ModalResult<u8> {
            one_of(('0'..='9', 'a'..='f', 'A'..='F'))
                .map(|d: char|
                    // unwraps are unreachable: their invariants are always
                    // upheld because the above character set can never
                    // consume anything but a single valid hex digit
                    d.to_digit(16).unwrap().try_into().unwrap())
                .context(StrContext::Expected(StrContextValue::Description(
                    "ASCII hex digit",
                )))
                .parse_next(input)
        }

        let hex_pair = (hex_digit, hex_digit).map(|(first, second)|
            // shift is infallible because hex_digit cannot return >0b00001111
            (first << 4) + second);

        // output size in bytes
        let digest_bytes = <D as Digest>::output_size();

        let digest = match D::ENCODING {
            DigestEncoding::Hex => {
                // Consume exactly the number of hex pairs that our Digest type expects
                let digest = repeat(digest_bytes, hex_pair)
                    .context(StrContext::Label("hash digest"))
                    .context(StrContext::Expected(StrContextValue::Description(
                        "a hex hash digest with the appropriate length for the given algorithm.",
                    )))
                    .parse_next(input)?;

                // Handle the case that there's another hex char after the expected number of digits
                // This is one of the few cases that we consider a hard error.
                cut_err(not(hex_digit))
                    .context(StrContext::Expected(StrContextValue::Description(
                        "end of checksum (checksum is too long).",
                    )))
                    .parse_next(input)?;

                digest
            }
            DigestEncoding::Dec => {
                // output size in bits
                let digest_bits = digest_bytes * 8;

                // The following logic parses a decimal integer for consumption by a digest.
                // We chose to use a [`u128::MAX`] as this is the currently largest number type in
                // the rust std library. In reality we only use this for CRC-32/CKSUM which is
                // 4 bytes, but it's nice to keep this a bit more generic.

                // Determine the maximum allowed value based on the number of allowed
                // `digest_bytes`.