Enum ObjectHash 

pub enum ObjectHash {
    Sha1([u8; 20]),
    Sha256([u8; 32]),
}

Concrete object ID value carrying the bytes for the selected algorithm (SHA-1 or SHA-256). Used for Git object hashes. Supports conversion to/from hex strings, byte slices, and stream reading.

Variants

Sha1([u8; 20])

Sha256([u8; 32])

Implementations

impl ObjectHash

pub fn zero_str(kind: HashKind) -> String

Zero-filled hex string for a given hash kind.

pub fn kind(&self) -> HashKind

Return the hash kind for this value.

pub fn size(&self) -> usize

Return the hash size in bytes.

pub fn new(data: &[u8]) -> ObjectHash

Compute hash of data using current thread-local HashKind.

pub fn from_type_and_data(object_type: ObjectType, data: &[u8]) -> ObjectHash

Create ObjectHash from object type and data

pub fn from_bytes(bytes: &[u8]) -> Result<ObjectHash, String>

Create ObjectHash from raw bytes matching the current hash size.

pub fn from_bytes_infer_kind(bytes: &[u8]) -> Result<ObjectHash, String>

Create ObjectHash from raw bytes, inferring the hash kind from the byte length (20 → SHA-1, 32 → SHA-256).

Unlike ObjectHash::from_bytes, this does not consult the thread-local HashKind, so it is safe on threads where set_hash_kind was never called. The pack encoder finalizes its running checksum on whichever async worker thread happens to run the task; the checksum bytes already carry the correct length, while the worker’s thread-local may still hold the default SHA-1 kind — the mismatch used to panic with “Invalid byte length: got 32, expected 20”.

pub fn from_stream(data: &mut impl Read) -> Result<ObjectHash>

Read hash bytes from a stream according to current hash size.

pub fn to_color_str(self) -> String

Format hash as colored string (for terminal display).

pub fn to_data(self) -> Vec<u8>

Return raw bytes of the hash.

pub fn _to_string(&self) -> String

Faster string conversion than Display.

pub fn as_mut_bytes(&mut self) -> &mut [u8]

Get mutable access to inner byte slice.

Trait Implementations

impl Archive for ObjectHash

where [u8; 20]: Archive, [u8; 32]: Archive,

type Archived = ArchivedObjectHash

The archived representation of this type.

type Resolver = ObjectHashResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <Self as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl AsRef<[u8]> for ObjectHash

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for ObjectHash

fn clone(&self) -> ObjectHash

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ObjectHash

impl Debug for ObjectHash

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

Formats the value using the given formatter.

impl Default for ObjectHash

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ObjectHash

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<ObjectHash, __D> for Archived<ObjectHash>

where [u8; 20]: Archive, <[u8; 20] as Archive>::Archived: Deserialize<[u8; 20], __D>, [u8; 32]: Archive, <[u8; 32] as Archive>::Archived: Deserialize<[u8; 32], __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ObjectHash, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Display for ObjectHash

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

Formats the value using the given formatter.

impl Eq for ObjectHash

impl FromStr for ObjectHash

Parse hex (40 for SHA1, 64 for SHA-256) into ObjectHash.

type Err = String

The associated error which can be returned from parsing.

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

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

impl Hash for ObjectHash

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 HeapSize for ObjectHash

fn heap_size(&self) -> usize

The size of the referenced data that is owned by this value in bytes, usually allocated on the heap (such as the value of a Box or the elements and reserved memory of a Vec).

fn heap_size_sum_iter<'item, Fun, Iter>(make_iter: Fun) -> usize

where Self: 'item, Fun: Fn() -> Iter, Iter: Iterator<Item = &'item Self>,

The total sum of the sizes of referenced data that is owned by a value in an iterator constructed with the given constructor, in bytes. This is default-implemented by computing HeapSize::heap_size on every element and summing them. In some cases, specialized implementations may be more performant. This is common for types which do not allocate any memory at all, where this function can be implemented by a constant zero.

fn heap_size_sum_exact_size_iter<'item, Fun, Iter>(make_iter: Fun) -> usize

where Self: 'item, Fun: Fn() -> Iter, Iter: ExactSizeIterator<Item = &'item Self>,

The total sum of the sizes of referenced data that is owned by a value in an exact-size-iterator constructed with the given constructor, in bytes. This is default-implemented by using HeapSize::heap_size_sum_iter. In some cases, specialized implementations relying on the iterator’s size may be more performant. This is common for types which allocate a constant amount of memory, where this function can multiply the iterator’s length.

impl Ord for ObjectHash

fn cmp(&self, other: &ObjectHash) -> 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 for ObjectHash

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for ObjectHash

fn partial_cmp(&self, other: &ObjectHash) -> 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 Serialize for ObjectHash

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for ObjectHash

where [u8; 20]: Serialize<__S>, [u8; 32]: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for ObjectHash