Digestible ![Build Status] ![Latest Version]

A more dynamic Hash and Hashable trait for Rust

Key Difference over STD Hash and Hashable

• ByteOrder is built in. So you can digest number types in any byte order. ByteOrder
• Output is a Generic Associated Type. So you can Digest into a ByteArray, String with Base64 or any type the Digester uses.
• Skip Fields with #[digestible(skip)]
• 'digestwith' and 'with' to override the default digest behavior. digestwith
• Support for all Hashing Algorithms that implement digest::Digest such as SHA2, md-5, and many more.

  - Writing Type Headers to prevent collisions with similar types. (This is optional and can be disabled with #[digestible(type_header = none)])

Features

• No STD Support
• Digest to implement Digester for all types that implement digest::Digest
• Float and Atomic Support using digest_with

Working with Hash

For types that do not Implement Digestible

you can add #[digestible(digest_with = digest_with_hash)] to your variable to tell Digestible to use Hash to digest it.

Implementing Hash with Digestible.

Adding #[digestible(hash)] to your struct or enum will implement Hash for it. Using the digest function. Allowing you to have a Hash and Digestible that are the same.

Example Using SHA2

```rust

[derive(Digestible)]

pub struct MyStruct { pub id: u32, pub name: String, #[digestible(skip)] pub password: String, } fn digesttobytes(){ let test = MyStruct{ id: 0, name: "Test".tostring(), password: "Test".tostring(), }; let mut hasher = sha2::Sha256::new(); let result = hasher.digestnative(&test); // This will be the type of sha2 Output } fn digesttobase64(){ let test = MyStruct{ id: 0, name: "Test".tostring(), password: "Test".tostring(), }; let hasher = sha2::Sha256::new().intobase64(); let result = hasher.digest_native(&test); // This is a base64 encoded string } ```