Struct trust_dns_proto::rr::rdata::name::NS

pub struct NS(pub Name);

new type for the RecordData of NS

Tuple Fields

0: Name

Methods from Deref<Target = Name>

pub fn is_root(&self) -> bool

Returns true if there are no labels, i.e. it’s empty.

In DNS the root is represented by .

Examples

use trust_dns_proto::rr::domain::Name;

let root = Name::root();
assert_eq!(&root.to_string(), ".");

pub fn is_fqdn(&self) -> bool

Returns true if the name is a fully qualified domain name.

If this is true, it has effects like only querying for this single name, as opposed to building up a search list in resolvers.

warning: this interface is unstable and may change in the future

Examples

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let name = Name::from_str("www").unwrap();
assert!(!name.is_fqdn());

let name = Name::from_str("www.example.com").unwrap();
assert!(!name.is_fqdn());

let name = Name::from_str("www.example.com.").unwrap();
assert!(name.is_fqdn());

pub fn iter(&self) -> LabelIter<'_>

Returns an iterator over the labels

pub fn to_lowercase(&self) -> Self

Creates a new Name with all labels lowercased

Examples

use std::cmp::Ordering;
use std::str::FromStr;

use trust_dns_proto::rr::domain::{Label, Name};

let example_com = Name::from_ascii("Example.Com").unwrap();
assert_eq!(example_com.cmp_case(&Name::from_str("example.com").unwrap()), Ordering::Less);
assert!(example_com.to_lowercase().eq_case(&Name::from_str("example.com").unwrap()));

pub fn base_name(&self) -> Self

Trims off the first part of the name, to help with searching for the domain piece

Examples

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let example_com = Name::from_str("example.com.").unwrap();
assert_eq!(example_com.base_name(), Name::from_str("com.").unwrap());
assert_eq!(Name::from_str("com.").unwrap().base_name(), Name::root());
assert_eq!(Name::root().base_name(), Name::root());

pub fn trim_to(&self, num_labels: usize) -> Self

Trims to the number of labels specified

Examples

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let example_com = Name::from_str("example.com.").unwrap();
assert_eq!(example_com.trim_to(2), Name::from_str("example.com.").unwrap());
assert_eq!(example_com.trim_to(1), Name::from_str("com.").unwrap());
assert_eq!(example_com.trim_to(0), Name::root());
assert_eq!(example_com.trim_to(3), Name::from_str("example.com.").unwrap());

pub fn zone_of_case(&self, name: &Self) -> bool

same as zone_of allows for case sensitive call

pub fn zone_of(&self, name: &Self) -> bool

returns true if the name components of self are all present at the end of name

Example

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let name = Name::from_str("www.example.com").unwrap();
let name = Name::from_str("www.example.com").unwrap();
let zone = Name::from_str("example.com").unwrap();
let another = Name::from_str("example.net").unwrap();
assert!(zone.zone_of(&name));
assert!(!name.zone_of(&zone));
assert!(!another.zone_of(&name));

pub fn num_labels(&self) -> u8

Returns the number of labels in the name, discounting *.

Examples

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let root = Name::root();
assert_eq!(root.num_labels(), 0);

let example_com = Name::from_str("example.com").unwrap();
assert_eq!(example_com.num_labels(), 2);

let star_example_com = Name::from_str("*.example.com.").unwrap();
assert_eq!(star_example_com.num_labels(), 2);

pub fn len(&self) -> usize

returns the length in bytes of the labels. ‘.’ counts as 1

This can be used as an estimate, when serializing labels, they will often be compressed and/or escaped causing the exact length to be different.

Examples

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

assert_eq!(Name::from_str("www.example.com.").unwrap().len(), 16);
assert_eq!(Name::from_str(".").unwrap().len(), 1);
assert_eq!(Name::root().len(), 1);

pub fn is_empty(&self) -> bool

Returns whether the length of the labels, in bytes is 0. In practice, since ‘.’ counts as 1, this is never the case so the method returns false.

pub fn emit_as_canonical( &self, encoder: &mut BinEncoder<'_>, canonical: bool, ) -> ProtoResult<()>

Emits the canonical version of the name to the encoder.

In canonical form, there will be no pointers written to the encoder (i.e. no compression).

pub fn emit_with_lowercase( &self, encoder: &mut BinEncoder<'_>, lowercase: bool, ) -> ProtoResult<()>

Writes the labels, as lower case, to the encoder

Arguments

• encoder - encoder for writing this name
• lowercase - if true the name will be lowercased, otherwise it will not be changed when writing

pub fn cmp_case(&self, other: &Self) -> Ordering

Case sensitive comparison

pub fn eq_case(&self, other: &Self) -> bool

Compares the Names, in a case sensitive manner

pub fn to_ascii(&self) -> String

Converts this name into an ascii safe string.

If the name is an IDNA name, then the name labels will be returned with the xn-- prefix. see to_utf8 or the Display impl for methods which convert labels to utf8.

pub fn to_utf8(&self) -> String

Converts the Name labels to the utf8 String form.

This converts the name to an unescaped format, that could be used with parse. If, the name is is followed by the final ., e.g. as in www.example.com., which represents a fully qualified Name.

pub fn parse_arpa_name(&self) -> Result<IpNet, ProtoError>

Converts a *.arpa Name in a PTR record back into an IpNet if possible.

pub fn is_localhost(&self) -> bool

Returns true if the Name is either localhost or in the localhost zone.

Example

use std::str::FromStr;
use trust_dns_proto::rr::Name;

let name = Name::from_str("localhost").unwrap();
assert!(name.is_localhost());

let name = Name::from_str("localhost.").unwrap();
assert!(name.is_localhost());

let name = Name::from_str("my.localhost.").unwrap();
assert!(name.is_localhost());

pub fn is_wildcard(&self) -> bool

True if the first label of this name is the wildcard, i.e. ‘*’

Example

use std::str::FromStr;
use trust_dns_proto::rr::Name;

let name = Name::from_str("www.example.com").unwrap();
assert!(!name.is_wildcard());

let name = Name::from_str("*.example.com").unwrap();
assert!(name.is_wildcard());

let name = Name::root();
assert!(!name.is_wildcard());

Trait Implementations

impl<'r> BinDecodable<'r> for NS

fn read(decoder: &mut BinDecoder<'r>) -> ProtoResult<Self>

Read the type from the stream

fn from_bytes(bytes: &'r [u8]) -> ProtoResult<Self>

Returns the object in binary form

impl BinEncodable for NS

fn emit(&self, encoder: &mut BinEncoder<'_>) -> ProtoResult<()>

Write the type to the stream

fn to_bytes(&self) -> ProtoResult<Vec<u8>>

Returns the object in binary form

impl Clone for NS

fn clone(&self) -> NS

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NS

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

Formats the value using the given formatter.

impl Deref for NS

type Target = Name

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for NS

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

Formats the value using the given formatter.

impl Hash for NS

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 PartialEq for NS

fn eq(&self, other: &NS) -> 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 RecordData for NS

fn try_from_rdata(data: RData) -> Result<Self, RData>

Attempts to convert to this RecordData from the RData type, if it is not the correct type the original is returned

fn try_borrow(data: &RData) -> Option<&Self>

Attempts to borrow this RecordData from the RData type, if it is not the correct type the original is returned

fn record_type(&self) -> RecordType

Get the associated RecordType for the RecordData

fn into_rdata(self) -> RData

Converts this RecordData into generic RecordData

impl Eq for NS

impl StructuralPartialEq for NS