Struct StrictlyZonedAddr

pub struct StrictlyZonedAddr<A, W, Z> { /* private fields */ }

A ZonedAddr whose address is Zoned iff a zone is required.

Any address whose scope can have a zone, will be the Zoned variant. The one exception is the loopback address, which is represented as Unzoned. This is because the loopback address is allowed to have, but does not require having, a zone.

Type Parameters

A: The base IpAddress type. W: The Witness types of the A. Z: The zone of A.

Implementations

impl<A, W, Z> StrictlyZonedAddr<A, W, Z>

where A: IpAddress, W: Witness<A> + ScopeableAddress + Copy,

pub fn into_inner(self) -> ZonedAddr<W, Z>

Convert self into the inner ZonedAddr

pub fn into_inner_without_witness(self) -> ZonedAddr<A, Z>

Convert self into the inner ZonedAddr while discarding the witness.

pub fn new_with_zone( addr: W, get_zone: impl FnOnce() -> Z, ) -> StrictlyZonedAddr<A, W, Z>

Creates from a specified IP address and an optional zone.

If addr requires a zone, then get_zone will be called to provide the zone.

Panics

This method panics if the addr wants a zone and get_zone will panic when called.

Methods from Deref<Target = ZonedAddr<W, Z>>

pub fn addr(&self) -> A

where A: Copy,

Accesses the addr for this ZonedAddr.

pub fn as_ref(&self) -> ZonedAddr<&A, &Z>

Converts from &ZonedAddr<A, Z> to ZonedAddr<&A, &Z>.

Trait Implementations

impl<A, W, Z> Clone for StrictlyZonedAddr<A, W, Z>

where A: Clone, W: Clone, Z: Clone,

fn clone(&self) -> StrictlyZonedAddr<A, W, Z>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, W, Z> Debug for StrictlyZonedAddr<A, W, Z>

where A: Debug, W: Debug, Z: Debug,

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

Formats the value using the given formatter.

impl<A, W, Z> Deref for StrictlyZonedAddr<A, W, Z>

where A: IpAddress, W: Witness<A>,

type Target = ZonedAddr<W, Z>

The resulting type after dereferencing.

fn deref(&self) -> &<StrictlyZonedAddr<A, W, Z> as Deref>::Target

Dereferences the value.

impl<A, W, Z> Hash for StrictlyZonedAddr<A, W, Z>

where A: Hash, W: Hash, Z: Hash,

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

where __H: Hasher,

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, W, Z> PartialEq for StrictlyZonedAddr<A, W, Z>

where A: PartialEq, W: PartialEq, Z: PartialEq,

fn eq(&self, other: &StrictlyZonedAddr<A, W, Z>) -> 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<A, W, Z> Copy for StrictlyZonedAddr<A, W, Z>

where A: Copy, W: Copy, Z: Copy,

impl<A, W, Z> Eq for StrictlyZonedAddr<A, W, Z>

where A: Eq, W: Eq, Z: Eq,

impl<A, W, Z> StructuralPartialEq for StrictlyZonedAddr<A, W, Z>