feat(cell): add upper/lower hex print support for bitstring

Author: Rexagon

.github/workflows/master.yml

@@ -59,12 +59,20 @@ jobs:
           profile: minimal
           toolchain: stable
           override: true
-          components: rustfmt, clippy
+          components: clippy
+
+      - name: Install nightly toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          components: rustfmt
 
       - name: Run cargo fmt
         uses: actions-rs/cargo@v1
         with:
           command: fmt
+          toolchain: nightly
           args: --all -- --check
 
       - name: Run cargo clippy

src/cell/builder.rs

@@ -1051,34 +1051,50 @@ impl CellBuilder {
 
     /// Returns an object which will display data as a bitstring
     /// with a termination bit.
-    pub fn display_data(&self) -> impl std::fmt::Display + std::fmt::Binary + '_ {
-        struct DisplayData<'a>(&'a CellBuilder);
+    #[inline]
+    pub fn display_data(&self) -> DisplayCellBuilderData<'_> {
+        DisplayCellBuilderData(self)
+    }
 
-        impl std::fmt::Display for DisplayData<'_> {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                std::fmt::Display::fmt(
-                    &Bitstring {
-                        bytes: &self.0.data,
-                        bit_len: self.0.bit_len,
-                    },
-                    f,
-                )
-            }
+    #[inline]
+    fn as_bitstring(&self) -> Bitstring<'_> {
+        Bitstring {
+            bytes: &self.data,
+            bit_len: self.bit_len,
         }
+    }
+}
 
-        impl std::fmt::Binary for DisplayData<'_> {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                std::fmt::Binary::fmt(
-                    &Bitstring {
-                        bytes: &self.0.data,
-                        bit_len: self.0.bit_len,
-                    },
-                    f,
-                )
-            }
-        }
+/// Helper struct to print the cell builder data.
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct DisplayCellBuilderData<'a>(&'a CellBuilder);
 
-        DisplayData(self)
+impl std::fmt::Display for DisplayCellBuilderData<'_> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl std::fmt::LowerHex for DisplayCellBuilderData<'_> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::LowerHex::fmt(&self.0.as_bitstring(), f)
+    }
+}
+
+impl std::fmt::UpperHex for DisplayCellBuilderData<'_> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::UpperHex::fmt(&self.0.as_bitstring(), f)
+    }
+}
+
+impl std::fmt::Binary for DisplayCellBuilderData<'_> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Binary::fmt(&self.0.as_bitstring(), f)
     }
 }
 

src/cell/mod.rs

@@ -5,15 +5,17 @@ use std::str::FromStr;
 
 pub use everscale_types_proc::{Load, Store};
 
-pub use self::builder::{CellBuilder, CellRefsBuilder, Store};
+pub use self::builder::{CellBuilder, CellRefsBuilder, DisplayCellBuilderData, Store};
 pub use self::cell_context::{CellContext, CellParts, LoadMode};
 #[cfg(not(feature = "sync"))]
 pub use self::cell_impl::rc::{Cell, CellInner, WeakCell};
 #[cfg(feature = "sync")]
 pub use self::cell_impl::sync::{Cell, CellInner, WeakCell};
 pub use self::cell_impl::{StaticCell, VirtualCellWrapper};
 pub use self::lazy::{Lazy, LazyExotic};
-pub use self::slice::{CellSlice, CellSliceParts, CellSliceRange, ExactSize, Load, LoadCell};
+pub use self::slice::{
+    CellSlice, CellSliceParts, CellSliceRange, DisplayCellSliceData, ExactSize, Load, LoadCell,
+};
 pub use self::usage_tree::{UsageTree, UsageTreeMode, UsageTreeWithSubtrees};
 use crate::error::{Error, ParseHashBytesError};
 use crate::util::Bitstring;
@@ -667,6 +669,16 @@ impl HashBytes {
             None => unsafe { std::hint::unreachable_unchecked() },
         }
     }
+
+    #[inline(always)]
+    fn fmt_hex(&self, f: &mut std::fmt::Formatter<'_>, table: &[u8; 16]) -> std::fmt::Result {
+        let mut output = [0u8; 64];
+        crate::util::encode_to_hex_slice(&self.0, &mut output, table).ok();
+
+        // SAFETY: output is guaranteed to contain only [0-9a-f]
+        let output = unsafe { std::str::from_utf8_unchecked(&output) };
+        f.write_str(output)
+    }
 }
 
 impl Default for HashBytes {
@@ -811,13 +823,21 @@ impl FromStr for HashBytes {
 }
 
 impl std::fmt::Display for HashBytes {
+    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut output = [0u8; 64];
-        hex::encode_to_slice(self, &mut output).ok();
+        std::fmt::LowerHex::fmt(self, f)
+    }
+}
 
-        // SAFETY: output is guaranteed to contain only [0-9a-f]
-        let output = unsafe { std::str::from_utf8_unchecked(&output) };
-        f.write_str(output)
+impl std::fmt::LowerHex for HashBytes {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::fmt_hex(self, f, crate::util::HEX_CHARS_LOWER)
+    }
+}
+
+impl std::fmt::UpperHex for HashBytes {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::fmt_hex(self, f, crate::util::HEX_CHARS_UPPER)
     }
 }
 
@@ -866,7 +886,8 @@ impl serde::Serialize for HashBytes {
     {
         if serializer.is_human_readable() {
             let mut output = [0u8; 64];
-            hex::encode_to_slice(self.0.as_slice(), &mut output).ok();
+            crate::util::encode_to_hex_slice(&self.0, &mut output, crate::util::HEX_CHARS_LOWER)
+                .ok();
 
             // SAFETY: output is guaranteed to contain only [0-9a-f]
             let output = unsafe { std::str::from_utf8_unchecked(&output) };

src/cell/slice.rs

@@ -1780,36 +1780,54 @@ impl<'a> CellSlice<'a> {
 
     /// Returns an object which will display data as a bitstring
     /// with a termination bit.
-    pub fn display_data<'b: 'a>(&'b self) -> impl std::fmt::Display + std::fmt::Binary + 'b {
-        fn make_bitstring<'b: 'a, 'a>(
-            s: &'b CellSlice<'a>,
-            bytes: &'b mut [u8; 128],
-        ) -> Result<Bitstring<'b>, std::fmt::Error> {
-            let bit_len = s.size_bits();
-            if s.get_raw(0, bytes, bit_len).is_err() {
-                return Err(std::fmt::Error);
-            }
-            Ok(Bitstring { bytes, bit_len })
-        }
+    #[inline]
+    pub fn display_data<'b: 'a>(&'b self) -> DisplayCellSliceData<'b, 'a> {
+        DisplayCellSliceData(self)
+    }
+}
 
-        struct DisplayData<'b, 'a>(&'b CellSlice<'a>);
+/// Helper struct to print the cell slice data.
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct DisplayCellSliceData<'b, 'a>(&'b CellSlice<'a>);
 
-        impl<'b: 'a, 'a> std::fmt::Display for DisplayData<'b, 'a> {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                let mut bytes = [0u8; 128];
-                std::fmt::Display::fmt(&ok!(make_bitstring(self.0, &mut bytes)), f)
-            }
-        }
+impl<'b: 'a, 'a> std::fmt::Display for DisplayCellSliceData<'b, 'a> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::LowerHex::fmt(self, f)
+    }
+}
 
-        impl<'b: 'a, 'a> std::fmt::Binary for DisplayData<'b, 'a> {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                let mut bytes = [0u8; 128];
-                std::fmt::Binary::fmt(&ok!(make_bitstring(self.0, &mut bytes)), f)
-            }
-        }
+impl<'b: 'a, 'a> std::fmt::LowerHex for DisplayCellSliceData<'b, 'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut bytes = [0u8; 128];
+        std::fmt::LowerHex::fmt(&ok!(make_bitstring(self.0, &mut bytes)), f)
+    }
+}
+
+impl<'b: 'a, 'a> std::fmt::UpperHex for DisplayCellSliceData<'b, 'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut bytes = [0u8; 128];
+        std::fmt::UpperHex::fmt(&ok!(make_bitstring(self.0, &mut bytes)), f)
+    }
+}
+
+impl<'b: 'a, 'a> std::fmt::Binary for DisplayCellSliceData<'b, 'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut bytes = [0u8; 128];
+        std::fmt::Binary::fmt(&ok!(make_bitstring(self.0, &mut bytes)), f)
+    }
+}
 
-        DisplayData(self)
+fn make_bitstring<'b: 'a, 'a>(
+    s: &'b CellSlice<'a>,
+    bytes: &'b mut [u8; 128],
+) -> Result<Bitstring<'b>, std::fmt::Error> {
+    let bit_len = s.size_bits();
+    if s.get_raw(0, bytes, bit_len).is_err() {
+        return Err(std::fmt::Error);
     }
+    Ok(Bitstring { bytes, bit_len })
 }
 
 impl ExactSize for CellSlice<'_> {

src/util.rs

@@ -301,10 +301,8 @@ impl Bitstring<'_> {
 
         Ok((data, bit_len))
     }
-}
 
-impl std::fmt::Display for Bitstring<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt_hex<const UPPER: bool>(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         const CHUNK_LEN: usize = 16;
 
         let bit_len = std::cmp::min(self.bit_len as usize, self.bytes.len() * 8) as u16;
@@ -325,7 +323,12 @@ impl std::fmt::Display for Bitstring<'_> {
         let mut chunk = [0u8; CHUNK_LEN * 2];
         for data in bytes.chunks(CHUNK_LEN) {
             let chunk = &mut chunk[..data.len() * 2];
-            hex::encode_to_slice(data, chunk).unwrap();
+
+            if UPPER {
+                encode_to_hex_slice(data, chunk, HEX_CHARS_UPPER).unwrap();
+            } else {
+                encode_to_hex_slice(data, chunk, HEX_CHARS_LOWER).unwrap();
+            }
 
             // SAFETY: result was constructed from valid ascii `HEX_CHARS_LOWER`
             ok!(f.write_str(unsafe { std::str::from_utf8_unchecked(chunk) }));
@@ -337,13 +340,39 @@ impl std::fmt::Display for Bitstring<'_> {
             if rem == 1 {
                 last_byte >>= 4;
             }
-            ok!(write!(f, "{last_byte:0rem$x}{tag}"));
+
+            if UPPER {
+                ok!(write!(f, "{last_byte:0rem$X}{tag}"));
+            } else {
+                ok!(write!(f, "{last_byte:0rem$x}{tag}"));
+            }
         }
 
         Ok(())
     }
 }
 
+impl std::fmt::Display for Bitstring<'_> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl std::fmt::LowerHex for Bitstring<'_> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::fmt_hex::<false>(self, f)
+    }
+}
+
+impl std::fmt::UpperHex for Bitstring<'_> {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::fmt_hex::<true>(self, f)
+    }
+}
+
 impl std::fmt::Binary for Bitstring<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let bit_len = std::cmp::min(self.bit_len as usize, self.bytes.len() * 8) as u16;
@@ -369,6 +398,36 @@ impl std::fmt::Binary for Bitstring<'_> {
     }
 }
 
+pub(crate) fn encode_to_hex_slice(
+    input: &[u8],
+    output: &mut [u8],
+    table: &[u8; 16],
+) -> Result<(), hex::FromHexError> {
+    if input.len() * 2 != output.len() {
+        return Err(hex::FromHexError::InvalidStringLength);
+    }
+
+    for (byte, output) in input.iter().zip(output.chunks_exact_mut(2)) {
+        let (high, low) = byte2hex(*byte, table);
+        output[0] = high;
+        output[1] = low;
+    }
+
+    Ok(())
+}
+
+#[inline]
+#[must_use]
+fn byte2hex(byte: u8, table: &[u8; 16]) -> (u8, u8) {
+    let high = table[((byte & 0xf0) >> 4) as usize];
+    let low = table[(byte & 0x0f) as usize];
+
+    (high, low)
+}
+
+pub(crate) const HEX_CHARS_LOWER: &[u8; 16] = b"0123456789abcdef";
+pub(crate) const HEX_CHARS_UPPER: &[u8; 16] = b"0123456789ABCDEF";
+
 #[allow(unused)]
 pub(crate) fn debug_tuple_field1_finish(
     f: &mut std::fmt::Formatter<'_>,