Struct Hash

pub struct Hash<T> { /* private fields */ }

A SHA-1 or SHA-256 reference to a git Commit, Tree, or Blob

Implementations

impl<T> Hash<T>

pub fn from_str(s: &str) -> Result<Self, HashParseError>

Construct a Hash from a hexidecimal string. The entire hash must be specified: 40 characters (SHA-1) or 64 (SHA-256)

Examples

use clgit::unknown::Hash; // aka clgit::generic::Hash<()>
 
for good in [
    // Legal SHA-1 hashes (20 bytes / 40 characters)
    "74da26a93c3eac22884a62bd8d70aab3434c9174",
    "89dd60cc88e4f89e0af91e2739c42a31c3a106bb",
    "eb6c43cb699caa2ccbc4e28f9ab75a2a17e4ee7c",

    // Uppercase is legal too
    "74DA26A93C3EAC22884A62BD8D70AAB3434C9174",
    "89DD60CC88E4F89E0AF91E2739C42A31C3A106BB",
    "EB6C43CB699CAA2CCBC4E28F9AB75A2A17E4EE7C",
 
    // SHA-256 hashes (40 bytes / 64 characters)
    "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
].iter().cloned() {
    Hash::from_str(good).unwrap_or_else(|e| panic!("Failed to parse {}: {}", good, e));
}

for bad in [
    "eb6c43cb699caa2ccbc4e28f9ab75a2a17e4ee7c0", // too long
    "eb6c43cb699caa2ccbc4e28f9ab75a2a17e4ee7",   // too short
    "eb6c43cb699caa2ccbc4e28f9ab75a2a17e4ee7!",  // invalid character
    "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcde",   // too short
    "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0", // too long
].iter().cloned() {
    assert!(Hash::from_str(bad).is_err(), "Didn't expect to parse {}", bad);
}

pub fn from_bytes(src: &[u8]) -> Result<Self, HashParseError>

Construct a Hash from a slice of bytes. The entire hash must be specified: 20 bytes (SHA-1) or 32 (SHA-256)

Examples

Hash::from_bytes(&[0u8; 20][..]).expect("20 bytes OK");
Hash::from_bytes(&[0u8; 32][..]).expect("32 bytes OK");
 
Hash::from_bytes(&[0u8; 19][..]).expect_err("19 bytes invalid");
Hash::from_bytes(&[0u8; 21][..]).expect_err("21 bytes invalid");
Hash::from_bytes(&[0u8; 31][..]).expect_err("31 bytes invalid");
Hash::from_bytes(&[0u8; 33][..]).expect_err("33 bytes invalid");

pub fn read_sha1(r: &mut impl Read) -> Result<Self>

Read 20 bytes from r and treat it as a SHA-1 Hash

Example

let mut io = std::io::Cursor::new(vec![0; 128]);
Hash::read_sha1(&mut io).unwrap();

pub fn read_sha256(r: &mut impl Read) -> Result<Self>

Read 32 bytes from r and treat it as a SHA-256 Hash

Example

let mut io = std::io::Cursor::new(vec![0; 128]);
Hash::read_sha256(&mut io).unwrap();

pub fn len(&self) -> usize

Get the number of bytes in this hash (20 or 32)

Example

assert!(hash.len() == 20 || hash.len() == 32);

pub fn bytes(&self) -> &[u8]

Get the bytes in this hash (length of 20 or 32)

Example

let bytes : &[u8] = hash.bytes();
assert!(bytes.len() == 20 || bytes.len() == 32);

pub fn first_byte(&self) -> u8

Get the first byte of this hash

Example

println!("byte: {:02x}", hash.first_byte());

pub fn typeless(&self) -> Hash<()>

Discard type information for this hash

impl Hash<()>

pub fn cast<T>(&self) -> Hash<T>

Acquire type information for this hash

Trait Implementations

impl<T> Clone for Hash<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Hash<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for Hash<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Display for Hash<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> FromStr for Hash<T>

type Err = HashParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, HashParseError>

Parses a string s to return a value of this type.

impl<T> Hash for Hash<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Ord for Hash<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<Hash<()>> for Hash<Commit>

fn eq(&self, other: &Hash<()>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Hash<()>> for Hash<Tree>

fn eq(&self, other: &Hash<()>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Hash<Commit>> for Hash<()>

fn eq(&self, other: &Hash<Commit>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Hash<Tree>> for Hash<()>

fn eq(&self, other: &Hash<Tree>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> PartialEq for Hash<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> PartialOrd for Hash<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Eq for Hash<T>