Enum ObjectHash 

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

Variants

Sha1([u8; 20])

Sha256([u8; 32])

Implementations

impl ObjectHash

Implementation of methods for the ObjectHash enum.

1. The kind method determines the type of hash (SHA1 or SHA256) based on the variant of the ObjectHash enum.
2. The size method returns the size of the hash in bytes, utilizing the kind method to determine the appropriate size.
3. The new method computes the hash of the provided data using the specified hash kind (SHA1 or SHA256) and returns an ObjectHash instance containing the computed hash.
4. from Prefix:Methods to create an ObjectHash from different sources:

• from_type_and_data: Constructs an ObjectHash from an object type and its associated data.
• from_bytes: Creates an ObjectHash from a byte slice, ensuring the length matches the expected hash size.
• from_stream: Reads bytes from a stream to create an ObjectHash, ensuring the correct number of bytes are read based on the hash kind.

5. to Prefix:Methods to convert an ObjectHash to different formats:

• to_color_str: Converts the hash to a colored string representation for display purposes
• to_data: Converts the hash to a byte vector.
• _to_string: Converts the hash to a hexadecimal string representation.

pub fn zero_str(kind: HashKind) -> String

returns a zeroed hash value for the given hash kind

pub fn kind(&self) -> HashKind

returns the kind of hash

pub fn size(&self) -> usize

returns the size of hash in bytes

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

Calculates the hash of the given data using the specified hash kind.

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 a byte slice

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

Create ObjectHash from a stream

pub fn to_color_str(self) -> String

Export sha1 value to String with the color

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

Export sha1 value to a byte array

pub fn _to_string(&self) -> String

core::fmt::Display is somewhat expensive, use this hack to get a string more efficiently

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

Get mutable hash as byte slice

Trait Implementations

impl AsRef<[u8]> for ObjectHash

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

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

impl<'__de, __Context> BorrowDecode<'__de, __Context> for ObjectHash

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

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

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for ObjectHash

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

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

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

Formats the value using the given formatter.

impl Encode for ObjectHash

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl FromStr for ObjectHash

Implementation of the std::str::FromStr trait for the ObjectHash enum. To effectively use the from_str method for converting a string to an ObjectHash object, consider the following:

1. The input string s should be a pre-calculated hexadecimal string, either 40 characters in length for SHA1 or 64 characters for SHA256. This string represents a hash and should conform to the standard hash format.
2. It is necessary to explicitly import the FromStr trait to utilize the from_str method. Include the import statement use std::str::FromStr; in your code before invoking the from_str function. This import ensures

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

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

impl Eq for ObjectHash

impl StructuralPartialEq for ObjectHash