oci-rust-sdk 0.4.4

Unofficial Oracle OCI SDK for 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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

#[allow(unused_imports)]
use super::*;
/// Provides summary information for an erratum. An erratum is an important software change which can include security advisories, bug fixes, or enhancements.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ErratumSummary {
    /// Advisory name.
    pub name: String,

    /// Summary description of the erratum.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub synopsis: Option<String>,

    /// The date and time the erratum was issued (in [RFC 3339](https://tools.ietf.org/rfc/rfc3339) format).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time_issued: Option<DateTime<Utc>>,

    /// The date and time the erratum was updated (in [RFC 3339](https://tools.ietf.org/rfc/rfc3339) format).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time_updated: Option<DateTime<Utc>>,

    /// Type of the erratum. This property is deprecated and it will be removed in a future API release. Please refer to the advisoryType property instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub classification_type: Option<ClassificationTypes>,

    /// List of CVEs applicable to this erratum.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub related_cves: Option<Vec<String>>,

    /// List of affected OS families.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub os_families: Option<Vec<OsFamily>>,

    /// The severity advisory. Only valid for security type advisories.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub advisory_severity: Option<AdvisorySeverity>,

    /// The advisory type of the erratum.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub advisory_type: Option<AdvisoryTypes>,
}

/// Required fields for ErratumSummary
pub struct ErratumSummaryRequired {
    /// Advisory name.
    pub name: String,
}

impl ErratumSummary {
    /// Create a new ErratumSummary with required fields
    pub fn new(required: ErratumSummaryRequired) -> Self {
        Self {
            name: required.name,

            synopsis: None,

            time_issued: None,

            time_updated: None,

            classification_type: None,

            related_cves: None,

            os_families: None,

            advisory_severity: None,

            advisory_type: None,
        }
    }

    /// Set name
    pub fn set_name(mut self, value: String) -> Self {
        self.name = value;
        self
    }

    /// Set synopsis
    pub fn set_synopsis(mut self, value: Option<String>) -> Self {
        self.synopsis = value;
        self
    }

    /// Set time_issued
    pub fn set_time_issued(mut self, value: Option<DateTime<Utc>>) -> Self {
        self.time_issued = value;
        self
    }

    /// Set time_updated
    pub fn set_time_updated(mut self, value: Option<DateTime<Utc>>) -> Self {
        self.time_updated = value;
        self
    }

    /// Set classification_type
    pub fn set_classification_type(mut self, value: Option<ClassificationTypes>) -> Self {
        self.classification_type = value;
        self
    }

    /// Set related_cves
    pub fn set_related_cves(mut self, value: Option<Vec<String>>) -> Self {
        self.related_cves = value;
        self
    }

    /// Set os_families
    pub fn set_os_families(mut self, value: Option<Vec<OsFamily>>) -> Self {
        self.os_families = value;
        self
    }

    /// Set advisory_severity
    pub fn set_advisory_severity(mut self, value: Option<AdvisorySeverity>) -> Self {
        self.advisory_severity = value;
        self
    }

    /// Set advisory_type
    pub fn set_advisory_type(mut self, value: Option<AdvisoryTypes>) -> Self {
        self.advisory_type = value;
        self
    }

    /// Set synopsis (unwraps Option)
    pub fn with_synopsis(mut self, value: impl Into<String>) -> Self {
        self.synopsis = Some(value.into());
        self
    }

    /// Set time_issued (unwraps Option)
    pub fn with_time_issued(mut self, value: DateTime<Utc>) -> Self {
        self.time_issued = Some(value);
        self
    }

    /// Set time_updated (unwraps Option)
    pub fn with_time_updated(mut self, value: DateTime<Utc>) -> Self {
        self.time_updated = Some(value);
        self
    }

    /// Set classification_type (unwraps Option)
    pub fn with_classification_type(mut self, value: ClassificationTypes) -> Self {
        self.classification_type = Some(value);
        self
    }

    /// Set related_cves (unwraps Option)
    pub fn with_related_cves(mut self, value: Vec<String>) -> Self {
        self.related_cves = Some(value);
        self
    }

    /// Set os_families (unwraps Option)
    pub fn with_os_families(mut self, value: Vec<OsFamily>) -> Self {
        self.os_families = Some(value);
        self
    }

    /// Set advisory_severity (unwraps Option)
    pub fn with_advisory_severity(mut self, value: AdvisorySeverity) -> Self {
        self.advisory_severity = Some(value);
        self
    }

    /// Set advisory_type (unwraps Option)
    pub fn with_advisory_type(mut self, value: AdvisoryTypes) -> Self {
        self.advisory_type = Some(value);
        self
    }
}