Enum simple_dns::rdata::RData

pub enum RData<'a> {
    A(A),
    AAAA(AAAA),
    NS(NS<'a>),
    MD(MD<'a>),
    CNAME(CNAME<'a>),
    MB(MB<'a>),
    MG(MG<'a>),
    MR(MR<'a>),
    PTR(PTR<'a>),
    MF(MF<'a>),
    HINFO(HINFO<'a>),
    MINFO(MINFO<'a>),
    MX(MX<'a>),
    TXT(TXT<'a>),
    SOA(SOA<'a>),
    WKS(WKS<'a>),
    SRV(SRV<'a>),
    RP(RP<'a>),
    AFSDB(AFSDB<'a>),
    ISDN(ISDN<'a>),
    RouteThrough(RouteThrough<'a>),
    NAPTR(NAPTR<'a>),
    NSAP(NSAP),
    NSAP_PTR(NSAP_PTR<'a>),
    LOC(LOC),
    OPT(OPT<'a>),
    CAA(CAA<'a>),
    SVCB(SVCB<'a>),
    HTTPS(HTTPS<'a>),
    NULL(u16, NULL<'a>),
    Empty(TYPE),
}

Represents the RData of each TYPE

Variants

A(A)

AAAA(AAAA)

NS(NS<'a>)

MD(MD<'a>)

CNAME(CNAME<'a>)

MB(MB<'a>)

MG(MG<'a>)

MR(MR<'a>)

PTR(PTR<'a>)

MF(MF<'a>)

HINFO(HINFO<'a>)

MINFO(MINFO<'a>)

MX(MX<'a>)

TXT(TXT<'a>)

SOA(SOA<'a>)

WKS(WKS<'a>)

SRV(SRV<'a>)

RP(RP<'a>)

AFSDB(AFSDB<'a>)

ISDN(ISDN<'a>)

RouteThrough(RouteThrough<'a>)

NAPTR(NAPTR<'a>)

NSAP(NSAP)

NSAP_PTR(NSAP_PTR<'a>)

LOC(LOC)

OPT(OPT<'a>)

CAA(CAA<'a>)

SVCB(SVCB<'a>)

HTTPS(HTTPS<'a>)

NULL(u16, NULL<'a>)

Empty(TYPE)

Implementations

impl<'a> RData<'a>

pub fn type_code(&self) -> TYPE

Returns the TYPE of this RData

pub fn into_owned<'b>(self) -> RData<'b>

Transforms the inner data into its owned type

Trait Implementations

impl<'a> Clone for RData<'a>

fn clone(&self) -> RData<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for RData<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for RData<'a>

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<'a> PartialEq for RData<'a>

fn eq(&self, other: &RData<'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> Eq for RData<'a>

impl<'a> StructuralPartialEq for RData<'a>