cpe 0.1.5

CPE 2.2 and 2.3 handling in Rust
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! # CPE Component
//!
//! The `Compenent` structs represent an avstring as defined in
//! [CPE-N:5.3](https://nvlpubs.nist.gov/nistpubs/Legacy/IR/nistir7695.pdf), or a CPE 2.2
//! component (one of vendor, product, version, etc.) as defined in
//! [CPE-N:6.1](https://nvlpubs.nist.gov/nistpubs/Legacy/IR/nistir7695.pdf),
//! Different functions are provided for parsing each TODO insert links.
//!
//! Note that these functions are primarily for internal use, and parsing the whole
//! WFN or URI (with TODO: links) is preferred.

use crate::error::Result;
use crate::parse::*;

use std::borrow::Cow;
use std::fmt;

pub type PackedComponents<'a> = (
    Component<'a>,
    Component<'a>,
    Component<'a>,
    Component<'a>,
    Component<'a>,
);

#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
pub enum Component<'a> {
    #[default]
    Any,
    NotApplicable,
    Value(Cow<'a, str>),
}

impl fmt::Display for Component<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if f.alternate() {
            match self {
                Self::Any => write!(f, "*"),
                Self::NotApplicable => write!(f, "?"),
                Self::Value(val) => write!(f, "{}", val),
            }
        } else {
            match self {
                Self::Any => write!(f, "ANY"),
                Self::NotApplicable => write!(f, "NA"),
                Self::Value(val) => write!(f, "{}", val),
            }
        }
    }
}

impl<'a> Component<'a> {
    pub fn new(val: &'a str) -> Self {
        if val == "-" || val == "NA" {
            Self::NotApplicable
        } else if val.is_empty() || val == "ANY" {
            Self::Any
        } else {
            Self::Value(Cow::Borrowed(val))
        }
    }

    pub fn new_string(val: String) -> Self {
        if val == "-" || val == "NA" {
            Self::NotApplicable
        } else if val.is_empty() || val == "ANY" {
            Self::Any
        } else {
            Self::Value(Cow::Owned(val))
        }
    }

    pub fn parse_wfn_field(value: &'a str) -> Result<Self> {
        parse_wfn_attribute(value)
    }

    pub fn parse_uri_field(value: &'a str) -> Result<Self> {
        parse_uri_attribute(value)
    }

    pub fn to_owned(&self) -> OwnedComponent {
        self.into()
    }

    pub fn encode_uri(&'a self) -> Cow<'a, str> {
        crate::parse::encode_uri_attribute(self)
    }

    pub fn encode_wfn(&'a self) -> Cow<'a, str> {
        crate::parse::encode_wfn_attribute(self)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum OwnedComponent {
    Any,
    NotApplicable,
    Value(String),
}

impl Default for OwnedComponent {
    fn default() -> Self {
        Self::Any
    }
}

impl OwnedComponent {
    pub fn parse_wfn_field(value: &str) -> Result<Self> {
        Component::parse_wfn_field(value).map(|component| component.into())
    }

    pub fn parse_uri_field(value: &str) -> Result<Self> {
        Component::parse_uri_field(value).map(|component| component.into())
    }

    pub fn as_component(&self) -> Component {
        match self {
            Self::Any => Component::Any,
            Self::NotApplicable => Component::NotApplicable,
            Self::Value(s) => Component::Value(Cow::Borrowed(s.as_str())),
        }
    }

    pub(crate) fn to_owned(&self) -> OwnedComponent {
        self.clone()
    }
}

impl From<&Component<'_>> for OwnedComponent {
    fn from(attribute: &Component<'_>) -> Self {
        match attribute {
            Component::Any => Self::Any,
            Component::NotApplicable => Self::NotApplicable,
            Component::Value(value) => Self::Value(value.clone().into_owned()),
        }
    }
}

impl From<Component<'_>> for OwnedComponent {
    fn from(attribute: Component<'_>) -> Self {
        match attribute {
            Component::Any => Self::Any,
            Component::NotApplicable => Self::NotApplicable,
            Component::Value(value) => Self::Value((*value).to_owned()),
        }
    }
}