Struct trust_dns_proto::rr::domain::usage::IN_ADDR_ARPA

pub struct IN_ADDR_ARPA { /* fields omitted */ }

zone for ipv4 reverse addresses

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) -> Name

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) -> Name

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 practive, 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 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());

Trait Implementations

impl Deref for IN_ADDR_ARPA

type Target = Name

The resulting type after dereferencing.

fn deref(&self) -> &Name

Dereferences the value.

impl LazyStatic for IN_ADDR_ARPA

fn initialize(lazy: &Self)