Struct DataHash 

pub struct DataHash {
    pub exclusions: Option<Vec<HashRange>>,
    pub name: Option<String>,
    pub alg: Option<String>,
    pub hash: Vec<u8>,
    pub pad: Vec<u8>,
    pub pad2: Option<ByteBuf>,
    pub url: Option<UriT>,
    pub path: PathBuf,
}

Helper class to create DataHash assertion

Fields

exclusions: Option<Vec<HashRange>>

name: Option<String>

alg: Option<String>

hash: Vec<u8>

pad: Vec<u8>

pad2: Option<ByteBuf>

url: Option<UriT>

path: PathBuf

Implementations

impl DataHash

pub const LABEL: &'static str = labels::DATA_HASH

pub fn new(name: &str, alg: &str) -> Self

Create new DataHash instance

pub fn add_exclusion(&mut self, exclusion: HashRange)

pub fn set_hash(&mut self, hash: Vec<u8>)

pub fn add_padding(&mut self, padding: Vec<u8>)

pub fn is_remote_hash(&self) -> bool

Checks if this is a remote hash

pub fn gen_hash(&mut self, asset_path: &Path) -> Result<()>

generate the hash value for the Asset using the range from the DataHash

pub fn gen_hash_from_stream<R>(&mut self, stream: &mut R) -> Result<()>

where R: Read + Seek + ?Sized,

generate the hash value for the Asset stream using the range from the DataHash

pub fn pad_to_size(&mut self, desired_size: usize) -> Result<()>

pub fn hash_from_stream<R>(&mut self, stream: &mut R) -> Result<Vec<u8>>

where R: Read + Seek + ?Sized,

generate the asset hash from a stream using the constructed start and length values

pub fn verify_in_memory_hash( &self, data: &[u8], alg: Option<&str>, ) -> Result<()>

pub fn verify_hash(&self, asset_path: &Path, alg: Option<&str>) -> Result<()>

Used to verify a DataHash against an asset.

pub fn verify_stream_hash( &self, reader: &mut dyn CAIRead, alg: Option<&str>, ) -> Result<()>

pub fn from_assertion(assertion: &Assertion) -> Result<Self>

Create a new instance from Assertion

Trait Implementations

impl Debug for DataHash

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataHash

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for DataHash

impl PartialEq for DataHash

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for DataHash

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DataHash