Struct ResolvedRoute

pub struct ResolvedRoute<I: BroadcastIpExt, D> {
    pub src_addr: IpDeviceAddr<I::Addr>,
    pub device: D,
    pub local_delivery_device: Option<D>,
    pub next_hop: NextHop<I::Addr>,
    pub internal_forwarding: InternalForwarding<D>,
}

The resolved route to a destination IP address.

Fields

src_addr: IpDeviceAddr<I::Addr>

The source address to use when forwarding packets towards the destination.

device: D

The device over which this destination can be reached.

local_delivery_device: Option<D>

Present when device is loopback with the device that the destination address is assigned to.

NB: it’s possible that local_delivery_device is itself loopback.

next_hop: NextHop<I::Addr>

The next hop via which this destination can be reached.

internal_forwarding: InternalForwarding<D>

The route’s internal forwarding semantics.

Trait Implementations

impl<I: Clone + BroadcastIpExt, D: Clone> Clone for ResolvedRoute<I, D>

where I::Addr: Clone,

fn clone(&self) -> ResolvedRoute<I, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug + BroadcastIpExt, D: Debug> Debug for ResolvedRoute<I, D>

where I::Addr: Debug,

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

Formats the value using the given formatter.

impl<I: BroadcastIpExt, D, IpType> GenericOverIp<IpType> for ResolvedRoute<I, D>

where IpType: BroadcastIpExt + Ip,

type Type = ResolvedRoute<IpType, D>

The type of Self when its IP-generic parameter is replaced with the type NewIp.

impl<I: PartialEq + BroadcastIpExt, D: PartialEq> PartialEq for ResolvedRoute<I, D>

where I::Addr: PartialEq,

fn eq(&self, other: &ResolvedRoute<I, D>) -> 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<I: Copy + BroadcastIpExt, D: Copy> Copy for ResolvedRoute<I, D>

where I::Addr: Copy,

impl<I: Eq + BroadcastIpExt, D: Eq> Eq for ResolvedRoute<I, D>

where I::Addr: Eq,

impl<I: BroadcastIpExt, D> StructuralPartialEq for ResolvedRoute<I, D>