Enum IpLayerEvent

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

Events observed at the IP layer.

Variants

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

A route needs to be added.

RemoveRoutes

Routes matching these specifiers need to be removed.

Fields

subnet: Subnet<I::Addr>

Destination subnet

device: DeviceId

Outgoing interface

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

Gateway/next-hop

MulticastForwarding(MulticastForwardingEvent<I, DeviceId>)

The multicast forwarding engine emitted an event.

Implementations

impl<DeviceId, I: IpLayerIpExt> IpLayerEvent<DeviceId, I>

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

Changes the device id type with map.

Trait Implementations

impl<DeviceId: Debug, I: Debug + IpLayerIpExt> Debug for IpLayerEvent<DeviceId, I>

where I::Addr: Debug,

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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

where IpType: IpLayerIpExt + Ip,

type Type = IpLayerEvent<DeviceId, IpType>

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

impl<DeviceId: Hash, I: Hash + IpLayerIpExt> Hash for IpLayerEvent<DeviceId, I>

where I::Addr: Hash,

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<DeviceId: PartialEq, I: PartialEq + IpLayerIpExt> PartialEq for IpLayerEvent<DeviceId, I>

where I::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: Eq, I: Eq + IpLayerIpExt> Eq for IpLayerEvent<DeviceId, I>

where I::Addr: Eq,

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