Struct trust_dns::rr::domain::Name

pub struct Name {
    // some fields omitted
}

TODO: all Names should be stored in a global "intern" space, and then everything that uses them should be through references. As a workaround the Strings are all Rc as well as the array TODO: Currently this probably doesn't support binary names, it would be nice to do that.

Methods

impl Name

fn new() -> Self

fn root() -> Self

fn is_root(&self) -> bool

fn label(self, label: &'static str) -> Self

inline builder

fn with_labels(labels: Vec<String>) -> Self

for mutating over time

fn prepend_label(&self, label: Rc<String>) -> Self

prepend the String to the label

fn add_label(&mut self, label: Rc<String>) -> &mut Self

appends the String to this label at the end

fn append(&mut self, other: &Self) -> &mut Self

appends the other to this name

fn base_name(&self) -> Name

Trims off the first part of the name, to help with searching for the domain piece ``` use trust_dns::rr::domain::Name;

let example_com = Name::new().label("example").label("com"); assert_eq!(example_com.base_name(), Name::new().label("com")); assert_eq!(Name::new().label("com").base_name(), Name::root()); assert_eq!(Name::root().base_name(), Name::root()); ```

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

Trims to the number of labels specified ``` use trust_dns::rr::domain::Name;

let example_com = Name::new().label("example").label("com"); assert_eq!(example_com.trim_to(2), Name::new().label("example").label("com")); assert_eq!(example_com.trim_to(1), Name::new().label("com")); assert_eq!(example_com.trim_to(0), Name::root()); ```

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

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

fn num_labels(&self) -> u8

fn len(&self) -> usize

returns the length in bytes of the labels. '.' counts as 1

fn parse(local: &str, origin: Option<&Self>) -> ParseResult<Self>

fn emit_as_canonical(&self, encoder: &mut BinEncoder, canonical: bool) -> EncodeResult

fn cmp_with_case(&self, other: &Self, ignore_case: bool) -> Ordering

compares with the other label, ignoring case

Trait Implementations

impl Hash for Name

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl Clone for Name

fn clone(&self) -> Name

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Eq for Name

impl PartialEq for Name

fn eq(&self, __arg_0: &Name) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Name) -> bool

This method tests for !=.

impl Debug for Name

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl BinSerializable<Name> for Name

fn read(decoder: &mut BinDecoder) -> DecodeResult<Name>

parses the chain of labels this has a max of 255 octets, with each label being less than 63. all names will be stored lowercase internally. This will consume the portions of the Vec which it is reading...

fn emit(&self, encoder: &mut BinEncoder) -> EncodeResult

impl Display for Name

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

Formats the value using the given formatter.

impl Index<usize> for Name

type Output = String

The returned type after indexing

fn index<'a>(&'a self, _index: usize) -> &'a String

The method for the indexing (Foo[Bar]) operation

impl PartialOrd<Name> for Name

fn partial_cmp(&self, other: &Name) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Ord for Name

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

RFC 4034 DNSSEC Resource Records March 2005

6.1.  Canonical DNS Name Order

 For the purposes of DNS security, owner names are ordered by treating
 individual labels as unsigned left-justified octet strings.  The
 absence of a octet sorts before a zero value octet, and uppercase
 US-ASCII letters are treated as if they were lowercase US-ASCII
 letters.

 To compute the canonical ordering of a set of DNS names, start by
 sorting the names according to their most significant (rightmost)
 labels.  For names in which the most significant label is identical,
 continue sorting according to their next most significant label, and
 so forth.

 For example, the following names are sorted in canonical DNS name
 order.  The most significant label is "example".  At this level,
 "example" sorts first, followed by names ending in "a.example", then
 by names ending "z.example".  The names within each level are sorted
 in the same way.

           example
           a.example
           yljkjljk.a.example
           Z.a.example
           zABC.a.EXAMPLE
           z.example
           \001.z.example
           *.z.example
           \200.z.example