Struct domain::base::opt::algsig::Understood

pub struct Understood<Variant, Octs: ?Sized> { /* private fields */ }

Option data for understood DNSSEC algorithms.

This type provides the option data for the three options DAU, DHU, and N3U which allow a client to specify the cryptographic algorithms it supports for DNSSEC signatures, DS hashes, and NSEC3 hashes respectively. Each of them contains a sequence of SecAlg values in wire format.

Which exact option is to be used is specified via the Variant type argument. Three marker types DauVariant, DhuVariant and N3uVariant are defined with accompanying type aliases Dau, Dhu, and N3u.

You can create a new value from anything that can be turned into an iterator over SecAlg via the from_sec_algs associated function. Once you have a value, you can iterate over the algorithms via the iter method or use the IntoIterator implementation for a reference.

Implementations

impl<Variant, Octs> Understood<Variant, Octs>

pub fn from_octets(octets: Octs) -> Result<Self, ParseError>

where Octs: AsRef<[u8]>,

Creates a new value from an octets sequence.

Returns an error if the slice does not contain a value in wire format or is longer than 65,535 octets.

pub unsafe fn from_octets_unchecked(octets: Octs) -> Self

Creates a new value from an octets sequence without checking.

Safety

The caller needs to make sure that the slice contains a sequence of 16 bit values that is no longer than 65,535 octets.

pub fn from_sec_algs( sec_algs: impl IntoIterator<Item = SecAlg>, ) -> Result<Self, BuildDataError>

where Octs: FromBuilder, <Octs as FromBuilder>::Builder: EmptyBuilder,

Creates a new value from a sequence of algorithms.

The operation will fail if the iterator returns more than 32,767 algorithms.

impl<Variant> Understood<Variant, [u8]>

pub fn from_slice(slice: &[u8]) -> Result<&Self, ParseError>

Creates a new value from an octets slice.

Returns an error if the slice does not contain a value in wire format or is longer than 65,535 octets.

pub unsafe fn from_slice_unchecked(slice: &[u8]) -> &Self

Creates a new value from an octets slice without checking.

Safety

The caller needs to make sure that the slice contains a sequence of 16 bit values that is no longer than 65,535 octets.

impl<Variant, Octs: AsRef<[u8]>> Understood<Variant, Octs>

pub fn parse<'a, Src: Octets<Range<'a> = Octs> + ?Sized>( parser: &mut Parser<'a, Src>, ) -> Result<Self, ParseError>

Parses a value from its wire format.

impl<Variant, Octs: ?Sized> Understood<Variant, Octs>

pub fn as_octets(&self) -> &Octs

Returns a reference to the underlying octets.

pub fn into_octets(self) -> Octs

where Octs: Sized,

Converts a value into its underlying octets.

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

where Octs: AsRef<[u8]>,

Returns the data as an octets slice.

pub fn for_slice(&self) -> &Understood<Variant, [u8]>

where Octs: AsRef<[u8]>,

Returns a reference to a value over an octets slice.

pub fn iter(&self) -> SecAlgsIter<'_>

where Octs: AsRef<[u8]>,

Returns an iterator over the algorithms in the data.

Trait Implementations

impl<Variant, Octs> AsRef<[u8]> for Understood<Variant, Octs>

where Octs: AsRef<[u8]> + ?Sized,

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<Variant, Octs> Borrow<[u8]> for Understood<Variant, Octs>

where Octs: AsRef<[u8]> + ?Sized,

fn borrow(&self) -> &[u8]

Immutably borrows from an owned value.

impl<Variant: Clone, Octs: Clone + ?Sized> Clone for Understood<Variant, Octs>

fn clone(&self) -> Understood<Variant, Octs>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Variant, Octs> ComposeOptData for Understood<Variant, Octs>

where Self: OptData, Octs: AsRef<[u8]> + ?Sized,

fn compose_len(&self) -> u16

fn compose_option<Target: OctetsBuilder + ?Sized>( &self, target: &mut Target, ) -> Result<(), Target::AppendError>

impl<Variant: Debug, Octs: Debug + ?Sized> Debug for Understood<Variant, Octs>

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

Formats the value using the given formatter.

impl<Variant, Octs> Display for Understood<Variant, Octs>

where Octs: AsRef<[u8]> + ?Sized,

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

Formats the value using the given formatter.

impl<Octs, Name> From<Understood<DauVariant, Octs>> for AllOptData<Octs, Name>

fn from(value: Dau<Octs>) -> Self

Converts to this type from the input type.

impl<Octs, Name> From<Understood<DhuVariant, Octs>> for AllOptData<Octs, Name>

fn from(value: Dhu<Octs>) -> Self

Converts to this type from the input type.

impl<Octs, Name> From<Understood<N3uVariant, Octs>> for AllOptData<Octs, Name>

fn from(value: N3u<Octs>) -> Self

Converts to this type from the input type.

impl<Variant, Octs: AsRef<[u8]>> Hash for Understood<Variant, Octs>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, Variant, Octs> IntoIterator for &'a Understood<Variant, Octs>

where Octs: AsRef<[u8]> + ?Sized,

type Item = SecAlg

The type of the elements being iterated over.

type IntoIter = SecAlgsIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Variant, O, OO> OctetsFrom<Understood<Variant, O>> for Understood<Variant, OO>

where OO: OctetsFrom<O>,

type Error = <OO as OctetsFrom<O>>::Error

fn try_octets_from(source: Understood<Variant, O>) -> Result<Self, Self::Error>

Performs the conversion.

impl<Octs: ?Sized> OptData for Understood<DauVariant, Octs>

fn code(&self) -> OptionCode

Returns the option code associated with this option.

impl<Octs: ?Sized> OptData for Understood<DhuVariant, Octs>

fn code(&self) -> OptionCode

Returns the option code associated with this option.

impl<Octs: ?Sized> OptData for Understood<N3uVariant, Octs>

fn code(&self) -> OptionCode

Returns the option code associated with this option.

impl<'a, Octs: Octets + ?Sized> ParseOptData<'a, Octs> for Understood<DauVariant, Octs::Range<'a>>

fn parse_option( code: OptionCode, parser: &mut Parser<'a, Octs>, ) -> Result<Option<Self>, ParseError>

Parses the option code data.

impl<'a, Octs: Octets + ?Sized> ParseOptData<'a, Octs> for Understood<DhuVariant, Octs::Range<'a>>

fn parse_option( code: OptionCode, parser: &mut Parser<'a, Octs>, ) -> Result<Option<Self>, ParseError>

Parses the option code data.

impl<'a, Octs: Octets + ?Sized> ParseOptData<'a, Octs> for Understood<N3uVariant, Octs::Range<'a>>

fn parse_option( code: OptionCode, parser: &mut Parser<'a, Octs>, ) -> Result<Option<Self>, ParseError>

Parses the option code data.

impl<Var, OtherVar, Octs, OtherOcts> PartialEq<Understood<OtherVar, OtherOcts>> for Understood<Var, Octs>

where Octs: AsRef<[u8]> + ?Sized, OtherOcts: AsRef<[u8]> + ?Sized,

fn eq(&self, other: &Understood<OtherVar, OtherOcts>) -> 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<Variant: Copy, Octs: Copy + ?Sized> Copy for Understood<Variant, Octs>

impl<Variant, Octs: AsRef<[u8]> + ?Sized> Eq for Understood<Variant, Octs>