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
112
113

//! RDAP RIR Search Results.
use std::collections::HashSet;

use crate::prelude::ContentExtensions;

use {
    crate::prelude::{Common, Extension},
    serde::{Deserialize, Serialize},
};

use super::{autnum::Autnum, network::Network, CommonFields, ToResponse};

/// Represents RDAP IP search results as defined in RFC 9910 Section 4.2.
#[derive(Serialize, Deserialize, Clone, PartialEq, Debug, Eq)]
pub struct IpSearchResults {
    #[serde(flatten)]
    pub common: Common,

    #[serde(rename = "ipSearchResults")]
    pub results: Vec<Network>,
}

#[buildstructor::buildstructor]
impl IpSearchResults {
    /// Builds an IP search result.
    #[builder(entry = "response_obj", visibility = "pub")]
    fn new_response_obj(results: Vec<Network>, extensions: Vec<Extension>) -> Self {
        Self {
            common: Common::level0().extensions(extensions).build(),
            results,
        }
    }

    /// Get the networks in the search.
    pub fn results(&self) -> &[Network] {
        self.results.as_ref()
    }
}

impl CommonFields for IpSearchResults {
    fn common(&self) -> &Common {
        &self.common
    }
}

impl ToResponse for IpSearchResults {
    fn to_response(self) -> super::RdapResponse {
        super::RdapResponse::IpSearchResults(Box::new(self))
    }
}

impl ContentExtensions for IpSearchResults {
    fn content_extensions(&self) -> std::collections::HashSet<super::ExtensionId> {
        let mut exts = HashSet::new();
        exts.insert(super::ExtensionId::IpSearchResults);
        self.results()
            .iter()
            .for_each(|n| exts.extend(n.content_extensions()));
        exts.extend(self.common().content_extensions());
        exts
    }
}

/// Represents RDAP autnum search results as defined in RFC 9910 Section 4.3.
#[derive(Serialize, Deserialize, Clone, PartialEq, Debug, Eq)]
pub struct AutnumSearchResults {
    #[serde(flatten)]
    pub common: Common,

    #[serde(rename = "autnumSearchResults")]
    pub results: Vec<Autnum>,
}

#[buildstructor::buildstructor]
impl AutnumSearchResults {
    /// Builds an autnum search result.
    #[builder(entry = "response_obj", visibility = "pub")]
    fn new_response_obj(results: Vec<Autnum>, extensions: Vec<Extension>) -> Self {
        Self {
            common: Common::level0().extensions(extensions).build(),
            results,
        }
    }

    /// Get the autnums in the search.
    pub fn results(&self) -> &[Autnum] {
        self.results.as_ref()
    }
}

impl CommonFields for AutnumSearchResults {
    fn common(&self) -> &Common {
        &self.common
    }
}

impl ToResponse for AutnumSearchResults {
    fn to_response(self) -> super::RdapResponse {
        super::RdapResponse::AutnumSearchResults(Box::new(self))
    }
}

impl ContentExtensions for AutnumSearchResults {
    fn content_extensions(&self) -> std::collections::HashSet<super::ExtensionId> {
        let mut exts = HashSet::new();
        exts.insert(super::ExtensionId::AutnumSearchResults);
        self.results()
            .iter()
            .for_each(|a| exts.extend(a.content_extensions()));
        exts.extend(self.common().content_extensions());
        exts
    }
}