Struct Event

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

Neighbor event.

Fields

device: DeviceId

The device.

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

The neighbor’s address.

kind: EventKind<L>

The kind of this neighbor event.

at: Instant

Time of this event.

Implementations

impl<L, DeviceId, I, Instant> Event<L, DeviceId, I, Instant>

where L: LinkUnicastAddress, I: Ip,

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

where F: FnOnce(DeviceId) -> N,

Changes the device id type with map.

Trait Implementations

impl<L, DeviceId, I, Instant> Debug for Event<L, DeviceId, I, Instant>

where L: Debug + LinkUnicastAddress, 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<L, DeviceId, I, Instant, IpType> GenericOverIp<IpType> for Event<L, DeviceId, I, Instant>

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

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

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

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

impl<L, DeviceId, I, Instant> StructuralPartialEq for Event<L, DeviceId, I, Instant>

where L: LinkUnicastAddress, I: Ip,