comparison rust/hg-core/src/revlog/node.rs @ 46427:6380efb82191

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

This avoids allocating intermediate strings.

Differential Revision: https://phab.mercurial-scm.org/D9860

46426:0da465780bba

//! of a revision.

use bytes_cast::BytesCast;
use hex::{self, FromHex, FromHexError};
use std::convert::TryFrom;

/// The length in bytes of a `Node`
///
/// This constant is meant to ease refactors of this module, and
/// are private so that calling code does not expect all nodes have

            _ => Err(()),
        }
    }
}

#[derive(Debug, PartialEq)]
pub enum NodeError {
    ExactLengthRequired(usize, String),
    PrefixTooLong(String),
    HexError(FromHexError, String),

    /// changes of hash format.
    pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Node, NodeError> {
        Ok(NodeData::from_hex(hex.as_ref())
            .map_err(|e| NodeError::from((e, hex)))?
            .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
    ///
    /// This is needed by FFI layers, for instance to return expected

        );
    }

    #[test]
    fn test_node_encode_hex() {
        assert_eq!(sample_node().encode_hex(), sample_node_hex());
    }

    #[test]
    fn test_prefix_from_hex() -> Result<(), NodeError> {
        assert_eq!(

            Err(NodeError::HexError(
                FromHexError::InvalidHexCharacter { c: 't', index: 0 },
                "testgr".to_string()
            ))
        );
        let mut long = NULL_NODE.encode_hex();
        long.push('c');
        match NodePrefix::from_hex(&long)
            .expect_err("should be refused as too long")
        {
            NodeError::PrefixTooLong(s) => assert_eq!(s, long),

46427:6380efb82191

//! of a revision.

use bytes_cast::BytesCast;
use hex::{self, FromHex, FromHexError};
use std::convert::TryFrom;
use std::fmt;

/// The length in bytes of a `Node`
///
/// This constant is meant to ease refactors of this module, and
/// are private so that calling code does not expect all nodes have

            _ => 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)]
pub enum NodeError {
    ExactLengthRequired(usize, String),
    PrefixTooLong(String),
    HexError(FromHexError, String),

    /// changes of hash format.
    pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Node, NodeError> {
        Ok(NodeData::from_hex(hex.as_ref())
            .map_err(|e| NodeError::from((e, hex)))?
            .into())
    }

    /// Provide access to binary data
    ///
    /// This is needed by FFI layers, for instance to return expected

        );
    }

    #[test]
    fn test_node_encode_hex() {
        assert_eq!(format!("{:x}", sample_node()), sample_node_hex());
    }

    #[test]
    fn test_prefix_from_hex() -> Result<(), NodeError> {
        assert_eq!(

            Err(NodeError::HexError(
                FromHexError::InvalidHexCharacter { c: 't', index: 0 },
                "testgr".to_string()
            ))
        );
        let mut long = format!("{:x}", NULL_NODE);
        long.push('c');
        match NodePrefix::from_hex(&long)
            .expect_err("should be refused as too long")
        {
            NodeError::PrefixTooLong(s) => assert_eq!(s, long),