Enum snmp_parser::snmp::ObjectSyntax

pub enum ObjectSyntax<'a> {
    Number(i32),
    String(&'a [u8]),
    Object(Oid<'a>),
    BitString(BitString<'a>),
    Empty,
    UnknownSimple(Any<'a>),
    IpAddress(NetworkAddress),
    Counter32(Counter),
    Gauge32(Gauge),
    TimeTicks(TimeTicks),
    Opaque(&'a [u8]),
    NsapAddress(&'a [u8]),
    Counter64(u64),
    UInteger32(u32),
    UnknownApplication(Any<'a>),
}

Variants

Number(i32)

String(&'a [u8])

Object(Oid<'a>)

BitString(BitString<'a>)

Empty

UnknownSimple(Any<'a>)

IpAddress(NetworkAddress)

Counter32(Counter)

Gauge32(Gauge)

TimeTicks(TimeTicks)

Opaque(&'a [u8])

NsapAddress(&'a [u8])

Counter64(u64)

UInteger32(u32)

UnknownApplication(Any<'a>)

Trait Implementations

impl<'a> Debug for ObjectSyntax<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<ObjectSyntax<'a>> for ObjectSyntax<'a>

fn eq(&self, other: &ObjectSyntax<'a>) -> 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<'a> TryFrom<Any<'a>> for ObjectSyntax<'a>

ObjectSyntax ::= CHOICE {
    simple           SimpleSyntax,
    application-wide ApplicationSyntax }

SimpleSyntax ::= CHOICE {
    integer-value   INTEGER (-2147483648..2147483647),
    string-value    OCTET STRING (SIZE (0..65535)),
    objectID-value  OBJECT IDENTIFIER }

ApplicationSyntax ::= CHOICE {
    ipAddress-value        IpAddress,
    counter-value          Counter32,
    timeticks-value        TimeTicks,
    arbitrary-value        Opaque,
    big-counter-value      Counter64,
    unsigned-integer-value Unsigned32 }

type Error = Error

The type returned in the event of a conversion error.

fn try_from(any: Any<'a>) -> Result<ObjectSyntax<'a>, Self::Error>

Performs the conversion.

impl<'a> StructuralPartialEq for ObjectSyntax<'a>