Struct TargetDescription 

pub struct TargetDescription { /* private fields */ }

Description of a target, used in verification.

Implementations

impl TargetDescription

pub fn new( length: u64, hashes: HashMap<HashAlgorithm, HashValue>, custom: HashMap<String, Value>, ) -> Result<Self>

Create a new TargetDescription.

Note: Creating this manually could lead to errors, and the from_reader method is preferred.

pub fn from_slice(buf: &[u8], hash_algs: &[HashAlgorithm]) -> Result<Self>

Read the from the given slice and calculate the length and hash values.

let bytes: &[u8] = b"it was a pleasure to burn";

let target_description = TargetDescription::from_slice(
    bytes,
    &[HashAlgorithm::Sha256, HashAlgorithm::Sha512],
).unwrap();

let s = "Rd9zlbzrdWfeL7gnIEi05X-Yv2TCpy4qqZM1N72ZWQs=";
let sha256 = HashValue::new(BASE64URL.decode(s.as_bytes()).unwrap());

let s ="tuIxwKybYdvJpWuUj6dubvpwhkAozWB6hMJIRzqn2jOUdtDTBg381brV4K\
    BU1zKP8GShoJuXEtCf5NkDTCEJgQ==";
let sha512 = HashValue::new(BASE64URL.decode(s.as_bytes()).unwrap());

assert_eq!(target_description.length(), bytes.len() as u64);
assert_eq!(target_description.hashes().get(&HashAlgorithm::Sha256), Some(&sha256));
assert_eq!(target_description.hashes().get(&HashAlgorithm::Sha512), Some(&sha512));

pub fn from_slice_with_custom( buf: &[u8], hash_algs: &[HashAlgorithm], custom: HashMap<String, Value>, ) -> Result<Self>

Read the from the given reader and custom metadata and calculate the length and hash values.

let bytes: &[u8] = b"it was a pleasure to burn";

let mut custom = HashMap::new();
custom.insert("Hello".into(), "World".into());

let target_description = TargetDescription::from_slice_with_custom(
    bytes,
    &[HashAlgorithm::Sha256, HashAlgorithm::Sha512],
    custom,
).unwrap();

let s = "Rd9zlbzrdWfeL7gnIEi05X-Yv2TCpy4qqZM1N72ZWQs=";
let sha256 = HashValue::new(BASE64URL.decode(s.as_bytes()).unwrap());

let s ="tuIxwKybYdvJpWuUj6dubvpwhkAozWB6hMJIRzqn2jOUdtDTBg381brV4K\
    BU1zKP8GShoJuXEtCf5NkDTCEJgQ==";
let sha512 = HashValue::new(BASE64URL.decode(s.as_bytes()).unwrap());

assert_eq!(target_description.length(), bytes.len() as u64);
assert_eq!(target_description.hashes().get(&HashAlgorithm::Sha256), Some(&sha256));
assert_eq!(target_description.hashes().get(&HashAlgorithm::Sha512), Some(&sha512));
assert_eq!(target_description.custom().get("Hello"), Some(&"World".into()));

pub async fn from_reader<R>( read: R, hash_algs: &[HashAlgorithm], ) -> Result<Self>

where R: AsyncRead + Unpin,

Read the from the given reader and calculate the length and hash values.

let bytes: &[u8] = b"it was a pleasure to burn";

let target_description = TargetDescription::from_reader(
    bytes,
    &[HashAlgorithm::Sha256, HashAlgorithm::Sha512],
).await.unwrap();

let s = "Rd9zlbzrdWfeL7gnIEi05X-Yv2TCpy4qqZM1N72ZWQs=";
let sha256 = HashValue::new(BASE64URL.decode(s.as_bytes()).unwrap());

let s ="tuIxwKybYdvJpWuUj6dubvpwhkAozWB6hMJIRzqn2jOUdtDTBg381brV4K\
    BU1zKP8GShoJuXEtCf5NkDTCEJgQ==";
let sha512 = HashValue::new(BASE64URL.decode(s.as_bytes()).unwrap());

assert_eq!(target_description.length(), bytes.len() as u64);
assert_eq!(target_description.hashes().get(&HashAlgorithm::Sha256), Some(&sha256));
assert_eq!(target_description.hashes().get(&HashAlgorithm::Sha512), Some(&sha512));

pub async fn from_reader_with_custom<R>( read: R, hash_algs: &[HashAlgorithm], custom: HashMap<String, Value>, ) -> Result<Self>

where R: AsyncRead + Unpin,

Read the from the given reader and custom metadata and calculate the length and hash values.

let bytes: &[u8] = b"it was a pleasure to burn";

let mut custom = HashMap::new();
custom.insert("Hello".into(), "World".into());

let target_description = TargetDescription::from_reader_with_custom(
    bytes,
    &[HashAlgorithm::Sha256, HashAlgorithm::Sha512],
    custom,
).await.unwrap();

let s = "Rd9zlbzrdWfeL7gnIEi05X-Yv2TCpy4qqZM1N72ZWQs=";
let sha256 = HashValue::new(BASE64URL.decode(s.as_bytes()).unwrap());

let s ="tuIxwKybYdvJpWuUj6dubvpwhkAozWB6hMJIRzqn2jOUdtDTBg381brV4K\
    BU1zKP8GShoJuXEtCf5NkDTCEJgQ==";
let sha512 = HashValue::new(BASE64URL.decode(s.as_bytes()).unwrap());

assert_eq!(target_description.length(), bytes.len() as u64);
assert_eq!(target_description.hashes().get(&HashAlgorithm::Sha256), Some(&sha256));
assert_eq!(target_description.hashes().get(&HashAlgorithm::Sha512), Some(&sha512));
assert_eq!(target_description.custom().get("Hello"), Some(&"World".into()));
})

pub fn length(&self) -> u64

The maximum length of the target.

pub fn hashes(&self) -> &HashMap<HashAlgorithm, HashValue>

An immutable reference to the list of calculated hashes.

pub fn custom(&self) -> &HashMap<String, Value>

An immutable reference to the custom metadata.

Trait Implementations

impl Clone for TargetDescription

fn clone(&self) -> TargetDescription

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TargetDescription

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TargetDescription

fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl PartialEq for TargetDescription

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

fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TargetDescription

impl StructuralPartialEq for TargetDescription