Enum netstack3_core::ip::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: AddressRemovedReason,
    },
    AddressStateChanged {
        device: DeviceId,
        addr: SpecifiedAddr<I::Addr>,
        state: IpAddressState,
    },
    AddressPropertiesChanged {
        device: DeviceId,
        addr: SpecifiedAddr<I::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::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::Addr>

The removed address.

reason: AddressRemovedReason

The reason the address was removed.

AddressStateChanged

Address state changed.

Fields

device: DeviceId

The device.

addr: SpecifiedAddr<I::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::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.

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<I: Ip> From<IpDeviceEvent<DeviceId<FakeBindingsCtx>, I, FakeInstant>> for DispatchedEvent

fn from( e: IpDeviceEvent<DeviceId<FakeBindingsCtx>, I, FakeInstant> ) -> DispatchedEvent

Converts to this type from the input type.

impl<I: Ip> From<IpDeviceEvent<DeviceId<FakeBindingsCtx>, I, FakeInstant>> for IpDeviceEvent<WeakDeviceId<FakeBindingsCtx>, I, FakeInstant>

fn from( e: IpDeviceEvent<DeviceId<FakeBindingsCtx>, I, FakeInstant> ) -> IpDeviceEvent<WeakDeviceId<FakeBindingsCtx>, I, FakeInstant>

Converts to this type from the input type.

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

where 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: 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 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> StructuralPartialEq for IpDeviceEvent<DeviceId, I, Instant>