Struct IcmpRxCounters 

pub struct IcmpRxCounters<I: IcmpCountersIpExt, C: CounterRepr = Counter> {
    pub error: C,
    pub error_delivered_to_transport_layer: C,
    pub error_delivered_to_socket: C,
    pub echo_request: C,
    pub echo_reply: C,
    pub timestamp_request: C,
    pub dest_unreachable: <I::DestUnreachableCounters as CounterCollectionSpec>::CounterCollection<C>,
    pub time_exceeded: <I::TimeExceededCounters as CounterCollectionSpec>::CounterCollection<C>,
    pub parameter_problem: <I::ParameterProblemCounters as CounterCollectionSpec>::CounterCollection<C>,
    pub packet_too_big: C,
    pub queue_full: C,
}

ICMP rx path counters.

Fields

error: C

Count of error messages received.

error_delivered_to_transport_layer: C

Count of error messages delivered to the transport layer.

error_delivered_to_socket: C

Count of error messages delivered to a socket.

echo_request: C

Count of echo request messages received.

echo_reply: C

Count of echo reply messages received.

timestamp_request: C

Count of timestamp request messages received.

dest_unreachable: <I::DestUnreachableCounters as CounterCollectionSpec>::CounterCollection<C>

Count of destination unreachable messages received.

time_exceeded: <I::TimeExceededCounters as CounterCollectionSpec>::CounterCollection<C>

Count of time exceeded messages received.

parameter_problem: <I::ParameterProblemCounters as CounterCollectionSpec>::CounterCollection<C>

Count of parameter problem messages received.

packet_too_big: C

Count of packet too big messages received.

queue_full: C

Count of ICMP Echo datagrams that could not be delivered to the socket because its receive buffer was full.

Trait Implementations

impl<I: IcmpCountersIpExt, C: CounterRepr + CounterRepr> CounterCollection for IcmpRxCounters<I, C>

type Spec = IcmpRxCounters<I>

The CounterCollectionSpec associated with this collection.

type Repr = C

The counter representation held by this collection.

fn cast<C>(&self) -> <Self::Spec as CounterCollectionSpec>::CounterCollection<C>

where C: CounterRepr,

A utility method to cast this collection of counters into a different underlying counter representation.

impl<I: IcmpCountersIpExt> CounterCollectionSpec for IcmpRxCounters<I, Counter>

type CounterCollection<C: CounterRepr> = IcmpRxCounters<I, C>

The underlying CounterCollection for this specification.

fn transform<C1: CounterRepr, C2: CounterRepr>( counters: &IcmpRxCounters<I, C1>, ) -> IcmpRxCounters<I, C2>

A utility method to transform the underlying counter representation within Self::CounterCollection.

impl<I: Debug + IcmpCountersIpExt, C: Debug + CounterRepr> Debug for IcmpRxCounters<I, C>

where I::DestUnreachableCounters: Debug, I::TimeExceededCounters: Debug, I::ParameterProblemCounters: Debug,

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

Formats the value using the given formatter.

impl<I: Default + IcmpCountersIpExt, C: Default + CounterRepr> Default for IcmpRxCounters<I, C>

where I::DestUnreachableCounters: Default, I::TimeExceededCounters: Default, I::ParameterProblemCounters: Default,

fn default() -> IcmpRxCounters<I, C>

Returns the “default value” for a type.

impl<I: IcmpCountersIpExt> Inspectable for IcmpRxCounters<I>

fn record<II: Inspector>(&self, inspector: &mut II)

Records this value into inspector.

impl<I: PartialEq + IcmpCountersIpExt, C: PartialEq + CounterRepr> PartialEq for IcmpRxCounters<I, C>

where I::DestUnreachableCounters: PartialEq, I::TimeExceededCounters: PartialEq, I::ParameterProblemCounters: PartialEq,

fn eq(&self, other: &IcmpRxCounters<I, C>) -> 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<I: IcmpCountersIpExt, C: CounterRepr> StructuralPartialEq for IcmpRxCounters<I, C>