fqdn 0.5.2

FQDN (Fully Qualified Domain Name)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::cmp::Ordering;
use crate::{Fqdn, FQDN};
use crate::check::check_and_lower_any_char;
//--------------------------------------------------------------------------------------

impl PartialOrd<FQDN> for Fqdn
{
    #[inline]
    fn partial_cmp(&self, other: &FQDN) -> Option<Ordering> { self.partial_cmp(other.as_ref()) }
}

impl PartialOrd<Fqdn> for FQDN
{
    #[inline]
    fn partial_cmp(&self, other: &Fqdn) -> Option<Ordering> { self.as_ref().partial_cmp(other) }

    #[inline]
    fn lt(&self, other: &Fqdn) -> bool { self.as_ref().lt(other) }

    #[inline]
    fn le(&self, other: &Fqdn) -> bool { self.as_ref().le(other) }

    #[inline]
    fn gt(&self, other: &Fqdn) -> bool { self.as_ref().gt(other) }

    #[inline]
    fn ge(&self, other: &Fqdn) -> bool { self.as_ref().ge(other) }
}

impl PartialEq<Fqdn> for FQDN
{
    #[inline]
    fn eq(&self, other: &Fqdn) -> bool { self.as_ref().eq(other) }
}


impl<S:AsRef<str>> PartialEq<S> for FQDN
{
    #[inline]
    fn eq(&self, other: &S) -> bool { self.as_ref().eq(other) }
}


impl PartialEq<FQDN> for Fqdn
{
    #[inline]
    fn eq(&self, other: &FQDN) -> bool { self.eq(other.as_ref()) }
}


impl<S:AsRef<str>> PartialEq<S> for Fqdn
{
    #[inline]
    fn eq(&self, other: &S) -> bool
    {
        let mut fqdn = self.as_bytes().iter().skip(1);
        let mut str = other.as_ref().as_bytes().iter();
        loop {
            match (fqdn.next(), str.next()) {
                (None, None) => return true,
                (None, Some(_)) => return false,
                #[cfg(not(feature = "domain-name-should-have-trailing-dot"))]
                (Some(0), None) => return true, // trailing dot missing on str
                (Some(_), None) => return false,
                (Some(_), Some(b'.')) => { /* continue */ }
                (Some(&a), Some(&b)) => {
                    if Ok(a) != check_and_lower_any_char(b) {
                        return false; // found mismatch
                    }
                }
            }
        }
    }
}

impl PartialEq<FQDN> for &str
{
    #[inline]
    fn eq(&self, other: &FQDN) -> bool { other.eq(self) }
}


impl PartialEq<Fqdn> for &str
{
    #[inline]
    fn eq(&self, other: &Fqdn) -> bool { other.eq(self) }
}