Struct Event

pub struct Event<L: LinkUnicastAddress, DeviceId, I: Ip, Instant> {
    pub device: DeviceId,
    pub addr: SpecifiedAddr<I::Addr>,
    pub kind: EventKind<L>,
    pub at: Instant,
}

Neighbor event.

Fields

device: DeviceId

The device.

addr: SpecifiedAddr<I::Addr>

The neighbor’s address.

kind: EventKind<L>

The kind of this neighbor event.

at: Instant

Time of this event.

Implementations

impl<L: LinkUnicastAddress, DeviceId, I: Ip, Instant> Event<L, DeviceId, I, Instant>

pub fn map_device<N, F: FnOnce(DeviceId) -> N>( self, map: F, ) -> Event<L, N, I, Instant>

Changes the device id type with map.

Trait Implementations

impl<L: Debug + LinkUnicastAddress, DeviceId: Debug, I: Debug + Ip, Instant: Debug> Debug for Event<L, DeviceId, I, Instant>

where I::Addr: Debug,

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

Formats the value using the given formatter.

impl<L: LinkUnicastAddress, DeviceId, I: Ip, Instant, IpType> GenericOverIp<IpType> for Event<L, DeviceId, I, Instant>

where IpType: Ip,

type Type = Event<L, DeviceId, IpType, Instant>

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

impl<L: Hash + LinkUnicastAddress, DeviceId: Hash, I: Hash + Ip, Instant: Hash> Hash for Event<L, 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<L: PartialEq + LinkUnicastAddress, DeviceId: PartialEq, I: PartialEq + Ip, Instant: PartialEq> PartialEq for Event<L, DeviceId, I, Instant>

where I::Addr: PartialEq,

fn eq(&self, other: &Event<L, DeviceId, I, Instant>) -> 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<L: Eq + LinkUnicastAddress, DeviceId: Eq, I: Eq + Ip, Instant: Eq> Eq for Event<L, DeviceId, I, Instant>

where I::Addr: Eq,

impl<L: LinkUnicastAddress, DeviceId, I: Ip, Instant> StructuralPartialEq for Event<L, DeviceId, I, Instant>