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

use serde::{Deserialize, Serialize};

#[allow(unused_imports)]
use super::*;
/// Provides information about the system architecture and operating system.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SystemDetails {
    /// Architecture type.
    pub architecture: ArchType,

    /// Operating system type.
    pub os_family: OsFamily,

    /// Name of the operating system.
    pub os_name: String,

    /// Version of the operating system.
    pub os_system_version: String,

    /// Version of the Ksplice effective kernel.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ksplice_effective_kernel_version: Option<String>,

    /// Release of the kernel.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub os_kernel_release: Option<String>,

    /// Version of the kernel.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub os_kernel_version: Option<String>,
}

/// Required fields for SystemDetails
pub struct SystemDetailsRequired {
    /// Architecture type.
    pub architecture: ArchType,

    /// Operating system type.
    pub os_family: OsFamily,

    /// Name of the operating system.
    pub os_name: String,

    /// Version of the operating system.
    pub os_system_version: String,
}

impl SystemDetails {
    /// Create a new SystemDetails with required fields
    pub fn new(required: SystemDetailsRequired) -> Self {
        Self {
            architecture: required.architecture,

            os_family: required.os_family,

            os_name: required.os_name,

            os_system_version: required.os_system_version,

            ksplice_effective_kernel_version: None,

            os_kernel_release: None,

            os_kernel_version: None,
        }
    }

    /// Set architecture
    pub fn set_architecture(mut self, value: ArchType) -> Self {
        self.architecture = value;
        self
    }

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

    /// Set os_family
    pub fn set_os_family(mut self, value: OsFamily) -> Self {
        self.os_family = value;
        self
    }

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

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

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

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

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

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

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