Enum netstack3_core::ip::IpDeviceEvent

pub enum IpDeviceEvent<DeviceId, I, Instant>
where
    I: Ip,
{
    AddressAdded {
        device: DeviceId,
        addr: AddrSubnet<<I as Ip>::Addr>,
        state: IpAddressState,
        valid_until: Lifetime<Instant>,
    },
    AddressRemoved {
        device: DeviceId,
        addr: SpecifiedAddr<<I as Ip>::Addr>,
        reason: AddressRemovedReason,
    },
    AddressStateChanged {
        device: DeviceId,
        addr: SpecifiedAddr<<I as Ip>::Addr>,
        state: IpAddressState,
    },
    AddressPropertiesChanged {
        device: DeviceId,
        addr: SpecifiedAddr<<I as Ip>::Addr>,
        valid_until: Lifetime<Instant>,
    },
    EnabledChanged {
        device: DeviceId,
        ip_enabled: bool,
    },
}

Events emitted from IP devices.

Variants

AddressAdded

Address was assigned.

Fields

device: DeviceId

The device.

addr: AddrSubnet<<I as Ip>::Addr>

The new address.

state: IpAddressState

Initial address state.

valid_until: Lifetime<Instant>

The lifetime for which the address is valid.

AddressRemoved

Address was unassigned.

Fields

device: DeviceId

The device.

addr: SpecifiedAddr<<I as Ip>::Addr>

The removed address.

reason: AddressRemovedReason

The reason the address was removed.

AddressStateChanged

Address state changed.

Fields

device: DeviceId

The device.

addr: SpecifiedAddr<<I as Ip>::Addr>

The address whose state was changed.

state: IpAddressState

The new address state.

AddressPropertiesChanged

Address properties changed.

Fields

device: DeviceId

The device.

addr: SpecifiedAddr<<I as Ip>::Addr>

The address whose properties were changed.

valid_until: Lifetime<Instant>

The new valid_until lifetime.

EnabledChanged

IP was enabled/disabled on the device

Fields

device: DeviceId

The device.

ip_enabled: bool

true if IP was enabled on the device; false if IP was disabled.

Implementations

impl<DeviceId, I, Instant> IpDeviceEvent<DeviceId, I, Instant>

where I: Ip,

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

where F: FnOnce(DeviceId) -> N,

Changes the device id type with map.

Trait Implementations

impl<DeviceId, I, Instant> Debug for IpDeviceEvent<DeviceId, I, Instant>

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

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

Formats the value using the given formatter.

impl<DeviceId, I, Instant, IpType> GenericOverIp<IpType> for IpDeviceEvent<DeviceId, I, Instant>

where I: Ip, IpType: Ip,

type Type = IpDeviceEvent<DeviceId, IpType, Instant>

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

impl<DeviceId, I, Instant> Hash for IpDeviceEvent<DeviceId, I, Instant>

where DeviceId: Hash, I: Hash + Ip, Instant: Hash, <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, Instant> PartialEq for IpDeviceEvent<DeviceId, I, Instant>

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

fn eq(&self, other: &IpDeviceEvent<DeviceId, I, Instant>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<DeviceId, I, Instant> Eq for IpDeviceEvent<DeviceId, I, Instant>

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

impl<DeviceId, I, Instant> StructuralPartialEq for IpDeviceEvent<DeviceId, I, Instant>

where I: Ip,