Enum netstack3_core::ip::device::IpDeviceEvent

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

Events emitted from IP devices.

Variants

AddressAdded

Fields

device: DeviceId

The device.

addr: AddrSubnet<I::Addr>

The new address.

state: IpAddressState

Initial address state.

valid_until: Lifetime<Instant>

The lifetime for which the address is valid.

Address was assigned.

AddressRemoved

Fields

device: DeviceId

The device.

addr: SpecifiedAddr<I::Addr>

The removed address.

reason: RemovedReason

The reason the address was removed.

Address was unassigned.

AddressStateChanged

Fields

device: DeviceId

The device.

addr: SpecifiedAddr<I::Addr>

The address whose state was changed.

state: IpAddressState

The new address state.

Address state changed.

EnabledChanged

Fields

device: DeviceId

The device.

ip_enabled: bool

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

IP was enabled/disabled on the device

Trait Implementations

impl<DeviceId: Debug, I: Debug + Ip, Instant: Debug> Debug for IpDeviceEvent<DeviceId, I, Instant>where I::Addr: Debug,

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

Formats the value using the given formatter.

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

impl<DeviceId, I: Ip, Instant> StructuralEq for IpDeviceEvent<DeviceId, I, Instant>

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