This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9860

rust: replace Node::encode_hex with std::fmt::LowerHex
ClosedPublic

Authored by SimonSapin on Jan 25 2021, 4:12 PM.

Details

Reviewers
pulkit
Alphare
Group Reviewers
hg-reviewers
Commits
rHG6380efb82191: rust: replace Node::encode_hex with std::fmt::LowerHex
Summary

This avoids allocating intermediate strings.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.Jan 25 2021, 4:12 PM
pulkit accepted this revision.Jan 27 2021, 5:34 AM
This revision is now accepted and ready to land.Jan 27 2021, 5:34 AM
SimonSapin updated this revision to Diff 25348.Jan 28 2021, 2:38 PM
Alphare accepted this revision.Jan 29 2021, 6:32 AM

Revision Contents
Changeset List

Diff 25414

rust/hg-core/examples/nodemap/main.rs

index index
.node((rng.gen::<u32>() % len) as Revision) .node((rng.gen::<u32>() % len) as Revision)
.unwrap() .unwrap()
.clone() .clone()
}) })
.collect(); .collect();
if queries < 10 { if queries < 10 {
let nodes_hex: Vec<String> = let nodes_hex: Vec<String> =
nodes.iter().map(|n| n.encode_hex()).collect(); nodes.iter().map(|n| format!("{:x}", n)).collect();
println!("Nodes: {:?}", nodes_hex); println!("Nodes: {:?}", nodes_hex);
} }
let mut last: Option<Revision> = None; let mut last: Option<Revision> = None;
let start = Instant::now(); let start = Instant::now();
for node in nodes.iter() { for node in nodes.iter() {
last = nm.find_bin(index, node.into()).unwrap(); last = nm.find_bin(index, node.into()).unwrap();
} }
let elapsed = start.elapsed(); let elapsed = start.elapsed();
println!( println!(
"Did {} queries in {:?} (mean {:?}), last was {:?} with result {:?}", "Did {} queries in {:?} (mean {:?}), last was {:x} with result {:?}",
queries, queries,
elapsed, elapsed,
elapsed / (queries as u32), elapsed / (queries as u32),
nodes.last().unwrap().encode_hex(), nodes.last().unwrap(),
last last
); );
} }
fn main() { fn main() {
let matches = App::new("Nodemap pure Rust example") let matches = App::new("Nodemap pure Rust example")
.arg( .arg(
Arg::with_name("REPOSITORY") Arg::with_name("REPOSITORY")

rust/hg-core/src/revlog/node.rs

// Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Definitions and utilities for Revision nodes //! Definitions and utilities for Revision nodes
//! //!
//! In Mercurial code base, it is customary to call "a node" the binary SHA //! In Mercurial code base, it is customary to call "a node" the binary SHA
//! of a revision. //! of a revision.
use bytes_cast::BytesCast; use bytes_cast::BytesCast;
use hex::{self, FromHex, FromHexError}; use hex::{self, FromHex, FromHexError};
use std::convert::TryFrom; use std::convert::TryFrom;
use std::fmt;
/// The length in bytes of a `Node` /// The length in bytes of a `Node`
/// ///
/// This constant is meant to ease refactors of this module, and /// This constant is meant to ease refactors of this module, and
/// are private so that calling code does not expect all nodes have /// are private so that calling code does not expect all nodes have
/// the same size, should we support several formats concurrently in /// the same size, should we support several formats concurrently in
/// the future. /// the future.
pub const NODE_BYTES_LENGTH: usize = 20; pub const NODE_BYTES_LENGTH: usize = 20;
fn try_from(bytes: &'a [u8]) -> Result<&'a Node, Self::Error> { fn try_from(bytes: &'a [u8]) -> Result<&'a Node, Self::Error> {
match Node::from_bytes(bytes) { match Node::from_bytes(bytes) {
Ok((node, rest)) if rest.is_empty() => Ok(node), Ok((node, rest)) if rest.is_empty() => Ok(node),
_ => Err(()), _ => Err(()),
} }
} }
} }
impl fmt::LowerHex for Node {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for &byte in &self.data {
write!(f, "{:02x}", byte)?
}
Ok(())
}
}
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum NodeError { pub enum NodeError {
ExactLengthRequired(usize, String), ExactLengthRequired(usize, String),
PrefixTooLong(String), PrefixTooLong(String),
HexError(FromHexError, String), HexError(FromHexError, String),
} }
/// Low level utility function, also for prefixes /// Low level utility function, also for prefixes
/// To be used in FFI and I/O only, in order to facilitate future /// To be used in FFI and I/O only, in order to facilitate future
/// changes of hash format. /// changes of hash format.
pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Node, NodeError> { pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Node, NodeError> {
Ok(NodeData::from_hex(hex.as_ref()) Ok(NodeData::from_hex(hex.as_ref())
.map_err(|e| NodeError::from((e, hex)))? .map_err(|e| NodeError::from((e, hex)))?
.into()) .into())
} }
/// Convert to hexadecimal string representation
///
/// To be used in FFI and I/O only, in order to facilitate future
/// changes of hash format.
pub fn encode_hex(&self) -> String {
hex::encode(self.data)
}
/// Provide access to binary data /// Provide access to binary data
/// ///
/// This is needed by FFI layers, for instance to return expected /// This is needed by FFI layers, for instance to return expected
/// binary values to Python. /// binary values to Python.
pub fn as_bytes(&self) -> &[u8] { pub fn as_bytes(&self) -> &[u8] {
&self.data &self.data
} }
} }
FromHexError::InvalidHexCharacter { c: '.', index: 3 }, FromHexError::InvalidHexCharacter { c: '.', index: 3 },
not_hex, not_hex,
)), )),
); );
} }
#[test] #[test]
fn test_node_encode_hex() { fn test_node_encode_hex() {
assert_eq!(sample_node().encode_hex(), sample_node_hex()); assert_eq!(format!("{:x}", sample_node()), sample_node_hex());
} }
#[test] #[test]
fn test_prefix_from_hex() -> Result<(), NodeError> { fn test_prefix_from_hex() -> Result<(), NodeError> {
assert_eq!( assert_eq!(
NodePrefix::from_hex("0e1")?, NodePrefix::from_hex("0e1")?,
NodePrefix { NodePrefix {
buf: vec![14, 16], buf: vec![14, 16],
fn test_prefix_from_hex_errors() { fn test_prefix_from_hex_errors() {
assert_eq!( assert_eq!(
NodePrefix::from_hex("testgr"), NodePrefix::from_hex("testgr"),
Err(NodeError::HexError( Err(NodeError::HexError(
FromHexError::InvalidHexCharacter { c: 't', index: 0 }, FromHexError::InvalidHexCharacter { c: 't', index: 0 },
"testgr".to_string() "testgr".to_string()
)) ))
); );
let mut long = NULL_NODE.encode_hex(); let mut long = format!("{:x}", NULL_NODE);
long.push('c'); long.push('c');
match NodePrefix::from_hex(&long) match NodePrefix::from_hex(&long)
.expect_err("should be refused as too long") .expect_err("should be refused as too long")
{ {
NodeError::PrefixTooLong(s) => assert_eq!(s, long), NodeError::PrefixTooLong(s) => assert_eq!(s, long),
err => panic!(format!("Should have been TooLong, got {:?}", err)), err => panic!(format!("Should have been TooLong, got {:?}", err)),
} }
} }