feat: enable higher expressiveness after rust 1.67

Author: BobAnkh

.github/workflows/changelog.yml

@@ -32,3 +32,4 @@ jobs:
           PATH: 'README.md'
           COMMIT_MESSAGE: 'docs(readme): update contributors'
           AVATAR_SHAPE: 'round'
+          DEFAULT_SCOPE: '*'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bandwidth"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "Apache-2.0"
 description="A library for representing bandwidth speed in a variety of units, mimicking the `core::time::Duration` struct."
@@ -9,8 +9,9 @@ homepage ="https://github.com/stack-rs/bandwidth"
 repository = "https://github.com/stack-rs/bandwidth"
 keywords = ["bandwidth", "data-structures", "network", "no-std", "utility"]
 documentation = "https://docs.rs/bandwidth"
-categories = ["data-structures", "network-programming", "no-std::no-alloc"]
+categories = ["data-structures", "network-programming", "no-std"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+rustversion = "1.0"

src/lib.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use core::fmt;
+use core::fmt::{self, Write};
 use core::iter::Sum;
 use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
@@ -1072,6 +1072,7 @@ impl Bandwidth {
     }
 }
 
+#[rustversion::before(1.67)]
 impl fmt::Debug for Bandwidth {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         /// Formats a floating point number in decimal notation.
@@ -1197,3 +1198,196 @@ impl fmt::Debug for Bandwidth {
         }
     }
 }
+
+#[rustversion::since(1.67)]
+impl fmt::Debug for Bandwidth {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        /// Formats a floating point number in decimal notation.
+        ///
+        /// The number is given as the `integer_part` and a fractional part.
+        /// The value of the fractional part is `fractional_part / divisor`. So
+        /// `integer_part` = 3, `fractional_part` = 12 and `divisor` = 100
+        /// represents the number `3.012`. Trailing zeros are omitted.
+        ///
+        /// `divisor` must not be above 100_000_000. It also should be a power
+        /// of 10, everything else doesn't make sense. `fractional_part` has
+        /// to be less than `10 * divisor`!
+        ///
+        /// A prefix and postfix may be added. The whole thing is padded
+        /// to the formatter's `width`, if specified.
+        fn fmt_decimal(
+            f: &mut fmt::Formatter<'_>,
+            integer_part: u64,
+            mut fractional_part: u32,
+            mut divisor: u32,
+            prefix: &str,
+            postfix: &str,
+        ) -> fmt::Result {
+            // Encode the fractional part into a temporary buffer. The buffer
+            // only need to hold 9 elements, because `fractional_part` has to
+            // be smaller than 10^9. The buffer is prefilled with '0' digits
+            // to simplify the code below.
+            let mut buf = [b'0'; 9];
+
+            // The next digit is written at this position
+            let mut pos = 0;
+
+            // We keep writing digits into the buffer while there are non-zero
+            // digits left and we haven't written enough digits yet.
+            while fractional_part > 0 && pos < f.precision().unwrap_or(9) {
+                // Write new digit into the buffer
+                buf[pos] = b'0' + (fractional_part / divisor) as u8;
+
+                fractional_part %= divisor;
+                divisor /= 10;
+                pos += 1;
+            }
+
+            // If a precision < 9 was specified, there may be some non-zero
+            // digits left that weren't written into the buffer. In that case we
+            // need to perform rounding to match the semantics of printing
+            // normal floating point numbers. However, we only need to do work
+            // when rounding up. This happens if the first digit of the
+            // remaining ones is >= 5.
+            let integer_part = if fractional_part > 0 && fractional_part >= divisor * 5 {
+                // Round up the number contained in the buffer. We go through
+                // the buffer backwards and keep track of the carry.
+                let mut rev_pos = pos;
+                let mut carry = true;
+                while carry && rev_pos > 0 {
+                    rev_pos -= 1;
+
+                    // If the digit in the buffer is not '9', we just need to
+                    // increment it and can stop then (since we don't have a
+                    // carry anymore). Otherwise, we set it to '0' (overflow)
+                    // and continue.
+                    if buf[rev_pos] < b'9' {
+                        buf[rev_pos] += 1;
+                        carry = false;
+                    } else {
+                        buf[rev_pos] = b'0';
+                    }
+                }
+
+                // If we still have the carry bit set, that means that we set
+                // the whole buffer to '0's and need to increment the integer
+                // part.
+                if carry {
+                    // If `integer_part == u64::MAX` and precision < 9, any
+                    // carry of the overflow during rounding of the
+                    // `fractional_part` into the `integer_part` will cause the
+                    // `integer_part` itself to overflow. Avoid this by using an
+                    // `Option<u64>`, with `None` representing `u64::MAX + 1`.
+                    integer_part.checked_add(1)
+                } else {
+                    Some(integer_part)
+                }
+            } else {
+                Some(integer_part)
+            };
+
+            // Determine the end of the buffer: if precision is set, we just
+            // use as many digits from the buffer (capped to 9). If it isn't
+            // set, we only use all digits up to the last non-zero one.
+            let end = f.precision().map(|p| core::cmp::min(p, 9)).unwrap_or(pos);
+
+            // This closure emits the formatted duration without emitting any
+            // padding (padding is calculated below).
+            let emit_without_padding = |f: &mut fmt::Formatter<'_>| {
+                if let Some(integer_part) = integer_part {
+                    write!(f, "{prefix}{integer_part}")?;
+                } else {
+                    // u64::MAX + 1 == 18446744073709551616
+                    write!(f, "{prefix}18446744073709551616")?;
+                }
+
+                // Write the decimal point and the fractional part (if any).
+                if end > 0 {
+                    // SAFETY: We are only writing ASCII digits into the buffer and
+                    // it was initialized with '0's, so it contains valid UTF8.
+                    let s = unsafe { core::str::from_utf8_unchecked(&buf[..end]) };
+
+                    // If the user request a precision > 9, we pad '0's at the end.
+                    let w = f.precision().unwrap_or(pos);
+                    write!(f, ".{s:0<w$}")?;
+                }
+
+                write!(f, "{postfix}")
+            };
+
+            match f.width() {
+                None => {
+                    // No `width` specified. There's no need to calculate the
+                    // length of the output in this case, just emit it.
+                    emit_without_padding(f)
+                }
+                Some(requested_w) => {
+                    // A `width` was specified. Calculate the actual width of
+                    // the output in order to calculate the required padding.
+                    // It consists of 4 parts:
+                    // 1. The prefix: is either "+" or "", so we can just use len().
+                    // 2. The postfix: can be "µs" so we have to count UTF8 characters.
+                    let mut actual_w = prefix.len() + postfix.chars().count();
+                    // 3. The integer part:
+                    if let Some(integer_part) = integer_part {
+                        if let Some(log) = integer_part.checked_ilog10() {
+                            // integer_part is > 0, so has length log10(x)+1
+                            actual_w += 1 + log as usize;
+                        } else {
+                            // integer_part is 0, so has length 1.
+                            actual_w += 1;
+                        }
+                    } else {
+                        // integer_part is u64::MAX + 1, so has length 20
+                        actual_w += 20;
+                    }
+                    // 4. The fractional part (if any):
+                    if end > 0 {
+                        let frac_part_w = f.precision().unwrap_or(pos);
+                        actual_w += 1 + frac_part_w;
+                    }
+
+                    if requested_w <= actual_w {
+                        // Output is already longer than `width`, so don't pad.
+                        emit_without_padding(f)
+                    } else {
+                        // We need to add padding.
+                        let post_padding_len = requested_w - actual_w;
+                        emit_without_padding(f)?;
+                        for _ in 0..post_padding_len {
+                            f.write_char(f.fill())?;
+                        }
+                        Ok(())
+                    }
+                }
+            }
+        }
+
+        // Print leading '+' sign if requested
+        let prefix = if f.sign_plus() { "+" } else { "" };
+
+        if self.gbps > 0 {
+            fmt_decimal(f, self.gbps, self.bps.0, BPS_PER_GBPS / 10, prefix, "gbps")
+        } else if self.bps.0 >= BPS_PER_MBPS {
+            fmt_decimal(
+                f,
+                (self.bps.0 / BPS_PER_MBPS) as u64,
+                self.bps.0 % BPS_PER_MBPS,
+                BPS_PER_MBPS / 10,
+                prefix,
+                "mbps",
+            )
+        } else if self.bps.0 >= BPS_PER_KBPS {
+            fmt_decimal(
+                f,
+                (self.bps.0 / BPS_PER_KBPS) as u64,
+                self.bps.0 % BPS_PER_KBPS,
+                BPS_PER_KBPS / 10,
+                prefix,
+                "kbps",
+            )
+        } else {
+            fmt_decimal(f, self.bps.0 as u64, 0, 1, prefix, "bps")
+        }
+    }
+}