Enum MulticastForwardingEvent

pub enum MulticastForwardingEvent<I, D>
where
    I: IpLayerIpExt,
{
    MissingRoute {
        key: MulticastRouteKey<I>,
        input_interface: D,
    },
    WrongInputInterface {
        key: MulticastRouteKey<I>,
        actual_input_interface: D,
        expected_input_interface: D,
    },
}

Events that may be published by the multicast forwarding engine.

Variants

MissingRoute

A multicast packet was received for which there was no applicable route.

Fields

key: MulticastRouteKey<I>

The key of the route that’s missing.

input_interface: D

The interface on which the packet was received.

WrongInputInterface

A multicast packet was received on an unexpected input interface.

Fields

key: MulticastRouteKey<I>

The key of the route with the unexpected input interface.

actual_input_interface: D

The interface on which the packet was received.

expected_input_interface: D

The interface on which the packet was expected (as specified in the multicast route).

Implementations

impl<I, D> MulticastForwardingEvent<I, D>

where I: IpLayerIpExt, D: WeakDeviceIdentifier,

pub fn upgrade_device_id( self, ) -> Option<MulticastForwardingEvent<I, <D as WeakDeviceIdentifier>::Strong>>

Upgrades the device IDs held by this event.

Trait Implementations

impl<I, D> Debug for MulticastForwardingEvent<I, D>

where I: Debug + IpLayerIpExt, D: 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<I, D, IpType> GenericOverIp<IpType> for MulticastForwardingEvent<I, D>

where I: IpLayerIpExt, IpType: Ip + IpLayerIpExt,

type Type = MulticastForwardingEvent<IpType, D>

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

impl<I, D> Hash for MulticastForwardingEvent<I, D>

where I: Hash + IpLayerIpExt, D: 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<I, D> PartialEq for MulticastForwardingEvent<I, D>

where I: PartialEq + IpLayerIpExt, D: PartialEq,

fn eq(&self, other: &MulticastForwardingEvent<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, D> Eq for MulticastForwardingEvent<I, D>

where I: Eq + IpLayerIpExt, D: Eq,

impl<I, D> StructuralPartialEq for MulticastForwardingEvent<I, D>

where I: IpLayerIpExt,