Struct ResourceRecord

pub struct ResourceRecord<'a> {
    pub name: Name<'a>,
    pub class: CLASS,
    pub ttl: u32,
    pub rdata: RData<'a>,
    pub cache_flush: bool,
}

Resource Records are used to represent the answer, authority, and additional sections in DNS packets.

Fields

name: Name<'a>

A Name to which this resource record pertains.

class: CLASS

A CLASS that defines the class of the rdata field

ttl: u32

The time interval (in seconds) that the resource record may becached before it should be discarded.
Zero values are interpreted to mean that the RR can only be used for the transaction in progress, and should not be cached.

rdata: RData<'a>

A RData with the contents of this resource record

cache_flush: bool

Indicates if this RR is a cache flush

Implementations

impl<'a> ResourceRecord<'a>

pub fn new(name: Name<'a>, class: CLASS, ttl: u32, rdata: RData<'a>) -> Self

Creates a new ResourceRecord

pub fn with_cache_flush(self, cache_flush: bool) -> Self

Consume self and change the cache_flush bit

pub fn to_cache_flush_record(&self) -> Self

Returns a cloned self with cache_flush = true

pub fn match_qclass(&self, qclass: QCLASS) -> bool

Return true if current resource match given query class

pub fn match_qtype(&self, qtype: QTYPE) -> bool

Return true if current resource match given query type

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

Transforms the inner data into its owned type

Trait Implementations

impl<'a> Clone for ResourceRecord<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ResourceRecord<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for ResourceRecord<'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 ResourceRecord<'a>

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