Struct Proven

pub struct Proven<T> { /* private fields */ }

Available on crate feature dnssec only.

A wrapper type to ensure that the state of a DNSSEC proof is evaluated before use

Implementations

impl<T> Proven<T>

pub fn new(proof: Proof, value: T) -> Self

Wrap the value with the given proof

pub fn proof(&self) -> Proof

Get the associated proof

pub fn require_as_ref<I: Into<ProofFlags>>(&self, flags: I) -> Result<&T, Proof>

Attempts to borrow the value only if it matches flags, returning the associated proof on failure

use hickory_proto::dnssec::{Proof, Proven};

let proven = Proven::new(Proof::Bogus, 42u32);

assert_eq!(*proven.require_as_ref(Proof::Bogus).unwrap(), 42_u32);
assert_eq!(*proven.require_as_ref(Proof::Bogus | Proof::Indeterminate).unwrap(), 42_u32);
assert_eq!(proven.require_as_ref(Proof::Secure | Proof::Insecure).unwrap_err(), Proof::Bogus);

pub fn require<I: Into<ProofFlags>>(self, flags: I) -> Result<T, Self>

Attempts to take the value only if it matches flags, returning the associated proof on failure

use hickory_proto::dnssec::{Proof, Proven};

let proven = Proven::new(Proof::Bogus, 42u32);

assert_eq!(proven.clone().require(Proof::Bogus).unwrap(), 42_u32);
assert_eq!(proven.clone().require(Proof::Bogus | Proof::Indeterminate).unwrap(), 42_u32);
assert!(proven.require(Proof::Secure | Proof::Insecure).is_err());

pub fn map<U, F>(self, f: F) -> Proven<U>

where F: FnOnce(T) -> U,

Map the value with the associated function, carrying forward the proof

pub fn into_parts(self) -> (Proof, T)

Unwraps the Proven type into it’s parts

impl<T> Proven<Option<T>>

pub fn transpose(self) -> Option<Proven<T>>

If the inner type is an Option this will transpose them so that it’s an option wrapped Proven

Trait Implementations

impl<T: Clone> Clone for Proven<T>

fn clone(&self) -> Proven<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Proven<T>

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

Formats the value using the given formatter.

impl<'a> From<&'a Record> for Proven<&'a Record>

fn from(record: &'a Record) -> Self

Converts to this type from the input type.

impl From<Record> for Proven<Record>

fn from(record: Record) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Proven<T>

fn eq(&self, other: &Proven<T>) -> 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<T: Eq> Eq for Proven<T>

impl<T> StructuralPartialEq for Proven<T>