Enum IpLayerEvent

pub enum IpLayerEvent<DeviceId, I>
where
    I: IpLayerIpExt,
{
    AddRoute(AddableEntry<<I as Ip>::Addr, DeviceId>),
    RemoveRoutes {
        subnet: Subnet<<I as Ip>::Addr>,
        device: DeviceId,
        gateway: Option<SpecifiedAddr<<I as Ip>::Addr>>,
    },
    MulticastForwarding(MulticastForwardingEvent<I, DeviceId>),
}

Events observed at the IP layer.

Variants

AddRoute(AddableEntry<<I as Ip>::Addr, DeviceId>)

A route needs to be added.

RemoveRoutes

Routes matching these specifiers need to be removed.

Fields

subnet: Subnet<<I as Ip>::Addr>

Destination subnet

device: DeviceId

Outgoing interface

gateway: Option<SpecifiedAddr<<I as Ip>::Addr>>

Gateway/next-hop

MulticastForwarding(MulticastForwardingEvent<I, DeviceId>)

The multicast forwarding engine emitted an event.

Implementations

impl<DeviceId, I> IpLayerEvent<DeviceId, I>

where I: IpLayerIpExt,

pub fn map_device<N, F>(self, map: F) -> IpLayerEvent<N, I>

where F: Fn(DeviceId) -> N,

Changes the device id type with map.

Trait Implementations

impl<DeviceId, I> Debug for IpLayerEvent<DeviceId, I>

where DeviceId: Debug, I: Debug + IpLayerIpExt, <I as Ip>::Addr: Debug,

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

Formats the value using the given formatter.

impl<DeviceId, I> From<MulticastForwardingEvent<I, DeviceId>> for IpLayerEvent<DeviceId, I>

where I: IpLayerIpExt,

fn from( event: MulticastForwardingEvent<I, DeviceId>, ) -> IpLayerEvent<DeviceId, I>

Converts to this type from the input type.

impl<DeviceId, I, IpType> GenericOverIp<IpType> for IpLayerEvent<DeviceId, I>

where I: IpLayerIpExt, IpType: Ip + IpLayerIpExt,

type Type = IpLayerEvent<DeviceId, IpType>

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

impl<DeviceId, I> Hash for IpLayerEvent<DeviceId, I>

where DeviceId: Hash, I: Hash + IpLayerIpExt, <I as Ip>::Addr: 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<DeviceId, I> PartialEq for IpLayerEvent<DeviceId, I>

where DeviceId: PartialEq, I: PartialEq + IpLayerIpExt, <I as Ip>::Addr: PartialEq,

fn eq(&self, other: &IpLayerEvent<DeviceId, I>) -> 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<DeviceId, I> Eq for IpLayerEvent<DeviceId, I>

where DeviceId: Eq, I: Eq + IpLayerIpExt, <I as Ip>::Addr: Eq,

impl<DeviceId, I> StructuralPartialEq for IpLayerEvent<DeviceId, I>

where I: IpLayerIpExt,