icann-rdap-common 0.0.29

Common RDAP data structures.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use std::any::TypeId;

use crate::response::rir_search::{AutnumSearchResults, IpSearchResults};
use crate::response::search::{DomainSearchResults, EntitySearchResults, NameserverSearchResults};

use super::{CheckParams, Checks, GetChecks, GetGroupChecks};

impl GetChecks for DomainSearchResults {
    fn get_checks(&self, index: Option<usize>, params: CheckParams) -> super::Checks {
        let sub_checks: Vec<Checks> = {
            let mut sub_checks = self
                .common
                .get_group_checks(params.from_parent(TypeId::of::<Self>()));
            self.results.iter().enumerate().for_each(|(i, result)| {
                sub_checks
                    .push(result.get_checks(Some(i), params.from_parent(TypeId::of::<Self>())))
            });
            sub_checks
        };
        Checks {
            rdap_struct: super::RdapStructure::DomainSearchResults,
            index,
            items: vec![],
            sub_checks,
        }
    }
}

impl GetChecks for NameserverSearchResults {
    fn get_checks(&self, index: Option<usize>, params: CheckParams) -> super::Checks {
        let sub_checks: Vec<Checks> = {
            let mut sub_checks: Vec<Checks> = self
                .common
                .get_group_checks(params.from_parent(TypeId::of::<Self>()));
            self.results.iter().enumerate().for_each(|(i, result)| {
                sub_checks
                    .push(result.get_checks(Some(i), params.from_parent(TypeId::of::<Self>())))
            });
            sub_checks
        };
        Checks {
            rdap_struct: super::RdapStructure::NameserverSearchResults,
            index,
            items: vec![],
            sub_checks,
        }
    }
}

impl GetChecks for EntitySearchResults {
    fn get_checks(&self, index: Option<usize>, params: CheckParams) -> super::Checks {
        let sub_checks: Vec<Checks> = {
            let mut sub_checks: Vec<Checks> = self
                .common
                .get_group_checks(params.from_parent(TypeId::of::<Self>()));
            self.results.iter().enumerate().for_each(|(i, result)| {
                sub_checks
                    .push(result.get_checks(Some(i), params.from_parent(TypeId::of::<Self>())))
            });
            sub_checks
        };
        Checks {
            rdap_struct: super::RdapStructure::EntitySearchResults,
            index,
            items: vec![],
            sub_checks,
        }
    }
}

impl GetChecks for IpSearchResults {
    fn get_checks(&self, index: Option<usize>, params: CheckParams) -> super::Checks {
        let sub_checks: Vec<Checks> = {
            let mut sub_checks: Vec<Checks> = self
                .common
                .get_group_checks(params.from_parent(TypeId::of::<Self>()));
            self.results.iter().enumerate().for_each(|(i, result)| {
                sub_checks
                    .push(result.get_checks(Some(i), params.from_parent(TypeId::of::<Self>())))
            });
            sub_checks
        };
        Checks {
            rdap_struct: super::RdapStructure::IpSearchResults,
            index,
            items: vec![],
            sub_checks,
        }
    }
}

impl GetChecks for AutnumSearchResults {
    fn get_checks(&self, index: Option<usize>, params: CheckParams) -> super::Checks {
        let sub_checks: Vec<Checks> = {
            let mut sub_checks: Vec<Checks> = self
                .common
                .get_group_checks(params.from_parent(TypeId::of::<Self>()));
            self.results.iter().enumerate().for_each(|(i, result)| {
                sub_checks
                    .push(result.get_checks(Some(i), params.from_parent(TypeId::of::<Self>())))
            });
            sub_checks
        };
        Checks {
            rdap_struct: super::RdapStructure::AutnumSearchResults,
            index,
            items: vec![],
            sub_checks,
        }
    }
}