Struct ion_binary_rs::IonHash

pub struct IonHash<D: Digest = Sha256> { /* private fields */ }

Ion Hash implementation. Once the hasher is initialized you can add new values to it and it will perform the dot operation internally. Once you added everything you want to add just call get() and it will provide you with a &u8 slice containing the hash.

You can use the method digest if you want to hash only one IonValue.

use sha2::Sha256;
use ion_binary_rs::{IonHash, IonValue};
use std::collections::HashMap;

let mut ion_struct = HashMap::new();

ion_struct.insert("Model".to_string(), IonValue::String("CLK 350".to_string()));
ion_struct.insert("Type".to_string(), IonValue::String("Sedan".to_string()));
ion_struct.insert("Color".to_string(), IonValue::String("White".to_string()));
ion_struct.insert(
    "VIN".to_string(),
    IonValue::String("1C4RJFAG0FC625797".to_string()),
);
ion_struct.insert("Make".to_string(), IonValue::String("Mercedes".to_string()));
ion_struct.insert("Year".to_string(), IonValue::Integer(2019));

let ion_value = IonValue::Struct(ion_struct);

let hash = IonHash::digest::<Sha256>(&ion_value);

println!("{:X?}", hash);

Implementations

impl<D: Digest> IonHash<D>

pub fn add_bytes(&mut self, value: &[u8])

Hashes the bytes and perform a dot operation with current version of the IonHash hash.

pub fn add_hashed_bytes(&mut self, value: &[u8])

Assumes that the bytes are already hashed and performs the dot operation with current version of the IonHash hash.

pub fn add_ion_value(&mut self, value: &IonValue)

Serializes and hashes the Ion Value and performs the dot operation with current version of the IonHash hash.

pub fn dot(&mut self, value: IonHash<D>) -> &mut Self

performs the dot operation with current version of the IonHash hash.

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

Gets the current hash. Useful for when you need to extract the final result after several operations.

impl IonHash

pub fn new() -> IonHash

Creates an empty Ion Hash with the default hasher: Sha256

pub fn from_bytes<D: Digest>(buf: &[u8]) -> IonHash<D>

Creates a hasher with some starting bytes which will be first hashed

pub fn from_hashes_bytes<D: Digest>(buf: &[u8]) -> IonHash<D>

Creates a hasher with some starting hash

pub fn from_ion_value<D: Digest>(value: &IonValue) -> IonHash<D>

Creates a hasher with some starting Ion Value which will be first serialized and hashed

pub fn with_hasher<D: Digest>() -> IonHash<D>

Creates an empty hasher using the provided hasher

pub fn digest<D: Digest>(value: &IonValue) -> Vec<u8>

Shorthand method for hashing an Ion Value in one step.

pub fn default_digest(value: &IonValue) -> Vec<u8>

Shorthand method for hashing an Ion Value in one step. It uses the default hasher: Sha256

Trait Implementations

impl<D: Debug + Digest> Debug for IonHash<D>

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

Formats the value using the given formatter.

impl Default for IonHash

fn default() -> IonHash<Sha256>

Returns the “default value” for a type.

impl<D: Digest> PartialEq for IonHash<D>

fn eq(&self, _: &IonHash<D>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<D: Digest> PartialOrd for IonHash<D>

fn partial_cmp(&self, value: &IonHash<D>) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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