Struct SHA1 

pub struct SHA1(pub [u8; 20]);

The SHA1 struct, encapsulating a [u8; 20] array, is specifically designed to represent Git hash IDs. In Git’s context, these IDs are 40-character hexadecimal strings generated via the SHA-1 algorithm. Each Git object receives a unique hash ID based on its content, serving as an identifier for its location within the Git internal database. Utilizing a dedicated struct for these hash IDs enhances code readability and maintainability by providing a clear, structured format for their manipulation and storage.

Change Log

In previous versions of the ‘mega’ project, Hash was used to denote hash values. However, in newer versions, SHA1 is employed for this purpose. Future updates plan to extend support to SHA256 and SHA512, or potentially other hash algorithms. By abstracting the hash model to Hash, and using specific imports like use crate::hash::SHA1 or use crate::hash::SHA256, the codebase maintains a high level of clarity and maintainability. This design choice allows for easier adaptation to different hash algorithms while keeping the underlying implementation consistent and understandable. - Nov 26, 2023 (by @genedna)

Tuple Fields

0: [u8; 20]

Implementations

impl SHA1

Implementation of the SHA1 struct.

The naming conventions for the methods in this implementation are designed to be intuitive and self-explanatory:

1. new Prefix: Methods starting with new are used for computing an SHA-1 hash from given data, signifying the creation of a new SHA1 instance. For example, pub fn new(data: &Vec<u8>) -> SHA1 takes a byte vector and calculates its SHA-1 hash.

2. from Prefix: Methods beginning with from are intended for creating a SHA1 instance from an existing, pre-calculated value. This implies direct derivation of the SHA1 object from the provided input. For instance, pub fn from_bytes(bytes: &[u8]) -> SHA1 constructs a SHA1 from a 20-byte array representing an SHA-1 hash.

3. to Prefix: Methods with the to prefix are used for outputting the SHA1 value in various formats. This prefix indicates a transformation or conversion of the SHA1 instance into another representation. For example, pub fn to_string(self) -> String converts the SHA1 value to a plain hexadecimal string, and pub fn to_data(self) -> Vec<u8> converts it into a byte vector. The to prefix thus serves as a clear indicator that the method is exporting or transforming the SHA1 value into a different format.

These method naming conventions (new, from, to) provide clarity and predictability in the API, making it easier for users to understand the intended use and functionality of each method within the SHA1 struct.

pub const SIZE: usize = 20usize

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

Calculate the SHA-1 hash of the byte slice, then create a Hash value

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

Create a Hash from the object type and data This function is used to create a SHA1 hash from the object type and data. It constructs a byte vector that includes the object type, the size of the data, and the data itself, and then computes the SHA1 hash of this byte vector.

Hash compute <- {Object Type}+{ }+{Object Size（before compress）}+{\x00}+{Object Content(before compress)}

pub fn from_bytes(bytes: &[u8]) -> SHA1

Create Hash from a byte array, which is a 20-byte array already calculated

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

Read the Hash value from the stream This function will read exactly 20 bytes from the 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

Trait Implementations

impl AsRef<[u8]> for SHA1

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 SHA1

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 SHA1

fn clone(&self) -> SHA1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SHA1

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for SHA1

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

Attempt to decode this type with the given Decode.

impl Default for SHA1

fn default() -> SHA1

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SHA1

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SHA1

Display trait for SHA1.

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

Allows [SHA1::to_string()] to be used. Note: If you want a terminal-friendly colorized output, use SHA1::to_color_str().

impl Encode for SHA1

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

Encode a given type.

impl FromStr for SHA1

Implementation of the std::str::FromStr trait for the SHA1 type.

To effectively use the from_str method for converting a string to a SHA1 object, consider the following:

1. The input string s should be a pre-calculated hexadecimal string, exactly 40 characters in length. This string represents a SHA1 hash and should conform to the standard SHA1 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 that the from_str method is available for converting strings to SHA1 objects.

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 SHA1

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 SHA1

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 SHA1

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

fn eq(&self, other: &SHA1) -> 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 SHA1

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

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 SHA1

impl Eq for SHA1

impl StructuralPartialEq for SHA1