Remove BBLength from SizedAlgoKind::from_unsized

Author: RenjiSann

src/uu/checksum_common/src/lib.rs

@@ -205,7 +205,7 @@ pub fn checksum_main(
     // Set the default algorithm to CRC when not '--check'ing.
     let algo_kind = algo.unwrap_or(AlgoKind::Crc);
 
-    let algo = SizedAlgoKind::from_unsized(algo_kind, length)?;
+    let algo = SizedAlgoKind::from_unsized(algo_kind, length.map(BBLength::as_bits))?;
     let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO));
 
     let opts = ChecksumComputeOptions {

src/uucore/src/lib/features/checksum/mod.rs

@@ -284,19 +284,12 @@ pub enum BBLength {
 }
 
 impl BBLength {
-    pub(crate) fn as_bits(self) -> usize {
+    pub fn as_bits(self) -> usize {
         match self {
             BBLength::Byte(n) => n * 8,
             BBLength::Bit(n) => n,
         }
     }
-
-    pub(crate) fn as_bytes(self) -> usize {
-        match self {
-            BBLength::Byte(n) => n,
-            BBLength::Bit(n) => n.div_ceil(8),
-        }
-    }
 }
 
 /// Represents an actual determined algorithm.
@@ -320,9 +313,9 @@ pub enum SizedAlgoKind {
 }
 
 impl SizedAlgoKind {
-    pub fn from_unsized(kind: AlgoKind, output_length: Option<BBLength>) -> UResult<Self> {
+    pub fn from_unsized(kind: AlgoKind, output_bitlen: Option<usize>) -> UResult<Self> {
         use AlgoKind as ak;
-        match (kind, output_length) {
+        match (kind, output_bitlen) {
             (
                 ak::Sysv
                 | ak::Bsd
@@ -347,19 +340,15 @@ impl SizedAlgoKind {
             (ak::Sha1, _) => Ok(Self::Sha1),
 
             (ak::Blake2b, l) => Ok(Self::Blake2b(XOFLength::from_bits(
-                l.map_or(Blake2b::DEFAULT_BIT_SIZE, BBLength::as_bits),
+                l.unwrap_or(Blake2b::DEFAULT_BIT_SIZE),
             ))),
             (ak::Blake3, l) => Ok(Self::Blake3(XOFLength::from_bits(
-                l.map_or(Blake3::DEFAULT_BIT_SIZE, BBLength::as_bits),
+                l.unwrap_or(Blake3::DEFAULT_BIT_SIZE),
             ))),
-            (ak::Shake128, l) => Ok(Self::Shake128(
-                l.map(BBLength::as_bits).map(XOFLength::from_bits),
-            )),
-            (ak::Shake256, l) => Ok(Self::Shake256(
-                l.map(BBLength::as_bits).map(XOFLength::from_bits),
-            )),
-            (ak::Sha2, Some(l)) => Ok(Self::Sha2(ShaLength::try_from(l.as_bits())?)),
-            (ak::Sha3, Some(l)) => Ok(Self::Sha3(ShaLength::try_from(l.as_bits())?)),
+            (ak::Shake128, l) => Ok(Self::Shake128(l.map(XOFLength::from_bits))),
+            (ak::Shake256, l) => Ok(Self::Shake256(l.map(XOFLength::from_bits))),
+            (ak::Sha2, Some(l)) => Ok(Self::Sha2(ShaLength::try_from(l)?)),
+            (ak::Sha3, Some(l)) => Ok(Self::Sha3(ShaLength::try_from(l)?)),
             (algo @ (ak::Sha2 | ak::Sha3), None) => {
                 Err(ChecksumError::LengthRequiredForSha(algo.to_lowercase().into()).into())
             }

src/uucore/src/lib/features/checksum/validate.rs

@@ -761,7 +761,7 @@ fn process_algo_based_line(
     let expected_checksum = get_raw_expected_digest(&line_info.checksum, digest_bit_length_hint)
         .ok_or(LineCheckError::ImproperlyFormatted)?;
 
-    let algo = SizedAlgoKind::from_unsized(algo_kind, algo_len)
+    let algo = SizedAlgoKind::from_unsized(algo_kind, algo_len.map(BBLength::as_bits))
         .map_err(|_| LineCheckError::ImproperlyFormatted)?;
 
     compute_and_check_digest_from_file(filename_to_check, &expected_checksum, algo, opts)
@@ -805,7 +805,7 @@ fn process_non_algo_based_line(
         _ => cli_algo_length,
     };
 
-    let algo = SizedAlgoKind::from_unsized(cli_algo_kind, algo_len)?;
+    let algo = SizedAlgoKind::from_unsized(cli_algo_kind, algo_len.map(BBLength::as_bits))?;
 
     compute_and_check_digest_from_file(filename_to_check, &expected_checksum, algo, opts)
 }