virtualbox_rs 0.4.2

A Rust library for interacting with VirtualBox, providing a safe and idiomatic interface to the VirtualBox API.
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

#[cfg(doc)]
use crate::enums::HWVirtExPropertyType;
#[cfg(doc)]
use crate::Machine;
use crate::{PlatformProperties, VboxError};
use crate::utility::macros::macros::{get_function_result_bool, get_function_result_number, get_function_result_unit};

impl PlatformProperties {
    /// Indicates whether VirtualBox was built with raw-mode support.
    ///
    /// When this reads as False, the [`HWVirtExPropertyType::Enabled`] setting will be ignored and assumed to be True.
    ///
    /// # Returns
    ///
    /// Returns bool on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::PlatformProperties;
    ///
    /// let platform_properties = PlatformProperties::init().unwrap();
    /// let raw_mode_supported = platform_properties.get_raw_mode_supported().unwrap();
    ///```
    pub fn get_raw_mode_supported(&self) -> Result<bool, VboxError> {
        get_function_result_bool!(self.object, GetRawModeSupported)
    }

    /// Exclusive use of hardware virtualization by VirtualBox.
    ///
    /// When enabled, VirtualBox assumes it can obtain full and exclusive access to the VT-x or AMD-V feature of the host. To share hardware virtualization with other hypervisors, this property must be disabled.
    ///
    /// # Returns
    ///
    /// Returns bool on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::PlatformProperties;
    ///
    /// let platform_properties = PlatformProperties::init().unwrap();
    /// let exclusive_hw_virt = platform_properties.get_exclusive_hw_virt().unwrap();
    ///```
    pub fn get_exclusive_hw_virt(&self) -> Result<bool, VboxError> {
        get_function_result_bool!(self.object, GetExclusiveHwVirt)
    }

    /// Exclusive use of hardware virtualization by VirtualBox.
    ///
    /// When enabled, VirtualBox assumes it can obtain full and exclusive access to the VT-x or AMD-V feature of the host. To share hardware virtualization with other hypervisors, this property must be disabled.
    ///
    /// # Arguments
    ///
    /// * `exclusive_hw_virt` - bool
    ///
    /// # Returns
    ///
    /// Returns () on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::PlatformProperties;
    ///
    /// let platform_properties = PlatformProperties::init().unwrap();
    /// platform_properties.set_exclusive_hw_virt(true).unwrap();
    ///```
    pub fn set_exclusive_hw_virt(&self, exclusive_hw_virt: bool) -> Result<(), VboxError> {
        let exclusive_hw_virt = if exclusive_hw_virt { 1 } else { 0 };
        get_function_result_unit!(self.object, SetExclusiveHwVirt, exclusive_hw_virt)
    }

    /// Maximum number of serial ports associated with every [`Machine`] instance.
    ///
    /// # Returns
    ///
    /// Returns u32 on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::PlatformProperties;
    ///
    /// let platform_properties = PlatformProperties::init().unwrap();
    /// let serial_port_count = platform_properties.get_serial_port_count().unwrap();
    ///```
    pub fn get_serial_port_count(&self) -> Result<u32, VboxError> {
        get_function_result_number!(self.object, GetSerialPortCount, u32)
    }

    /// Maximum number of parallel ports associated with every [`Machine`] instance.
    ///
    /// # Returns
    ///
    /// Returns u32 on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::PlatformProperties;
    ///
    /// let platform_properties = PlatformProperties::init().unwrap();
    /// let parallel_port_count = platform_properties.get_parallel_port_count().unwrap();
    ///```
    pub fn get_parallel_port_count(&self) -> Result<u32, VboxError> {
        get_function_result_number!(self.object, GetParallelPortCount, u32)
    }

    /// Maximum device position in the boot order.
    ///
    /// This value corresponds to the total number of devices a machine can boot from, to make it possible to include all possible devices to the boot list.
    ///
    /// # Returns
    ///
    /// Returns u32 on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::PlatformProperties;
    ///
    /// let platform_properties = PlatformProperties::init().unwrap();
    /// let max_boot_position =  platform_properties.get_max_boot_position().unwrap();
    ///```
    pub fn get_max_boot_position(&self) -> Result<u32, VboxError> {
        get_function_result_number!(self.object, GetMaxBootPosition, u32)
    }
}