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

use crate::console::Console;
use crate::enums::{SessionState, SessionType};
use crate::machine::Machine;
use crate::session::Session;
use crate::utility::macros::macros::{
    get_function_result_number, get_function_result_pointer, get_function_result_str,
    get_function_result_unit,
};
use crate::VboxError;
use vbox_raw::sys_lib::{IConsole, IMachine};

impl Session {
    /// Unlocks a machine that was previously locked for the current session.
    ///
    /// # Returns
    ///
    /// Returns Ok(()) on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::{Session, VirtualBox};
    /// use virtualbox_rs::enums::SessionType;
    ///
    /// let vbox = VirtualBox::init().unwrap();
    /// let mut session = Session::init().unwrap();
    /// let machine = vbox.
    ///         find_machines("Freebsd_14").unwrap();
    /// machine.lock_machine(&mut session, SessionType::Shared).unwrap();
    ///
    /// session.unlock_machine().unwrap();

    pub fn unlock_machine(&self) -> Result<(), VboxError> {
        get_function_result_unit!(self.object, UnlockMachine)
    }

    /// Current state of this session.
    ///
    /// # Returns
    ///
    /// Returns [`SessionState`] on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::{Session, VirtualBox};
    /// use virtualbox_rs::enums::SessionType;
    ///
    /// let vbox = VirtualBox::init().unwrap();
    /// let mut session = Session::init().unwrap();
    /// let machine = vbox.
    ///         find_machines("Freebsd_14").unwrap();
    /// machine.lock_machine(&mut session, SessionType::Shared).unwrap();
    ///
    /// let state = session.get_state().unwrap();
    pub fn get_state(&self) -> Result<SessionState, VboxError> {
        let session_type = get_function_result_number!(self.object, GetState, u32)?;
        Ok(SessionState::from(session_type))
    }

    /// Type of this session.
    ///
    /// # Returns
    ///
    /// Returns [`SessionType`] on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::{Session, VirtualBox};
    /// use virtualbox_rs::enums::SessionType;
    ///
    /// let vbox = VirtualBox::init().unwrap();
    /// let mut session = Session::init().unwrap();
    /// let machine = vbox.
    ///         find_machines("Freebsd_14").unwrap();
    /// machine.lock_machine(&mut session, SessionType::Shared).unwrap();
    ///
    /// let session_type = session.get_type().unwrap();
    pub fn get_type(&self) -> Result<SessionType, VboxError> {
        let session_type = get_function_result_number!(self.object, GetType, u32)?;
        Ok(SessionType::from(session_type))
    }

    /// Name of this session.
    ///
    /// # Returns
    ///
    /// Returns [&str] on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::{Session, VirtualBox};
    /// use virtualbox_rs::enums::SessionType;
    ///
    /// let vbox = VirtualBox::init().unwrap();
    /// let mut session = Session::init().unwrap();
    /// let machine = vbox.
    ///         find_machines("Freebsd_14").unwrap();
    /// machine.lock_machine(&mut session, SessionType::Shared).unwrap();
    ///
    /// let name = session.get_name().unwrap();
    pub fn get_name(&self) -> Result<&'static str, VboxError> {
        get_function_result_str!(self.object, GetName)
    }
    /// Machine object associated with this session.
    ///
    /// # Returns
    ///
    /// Returns [`Machine`] on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::{Session, VirtualBox};
    /// use virtualbox_rs::enums::SessionType;
    ///
    /// let vbox = VirtualBox::init().unwrap();
    /// let mut session = Session::init().unwrap();
    /// let machine = vbox.
    ///         find_machines("Freebsd_14").unwrap();
    /// machine.lock_machine(&mut session, SessionType::Shared).unwrap();
    ///
    /// let machine_mut = session.get_machine().unwrap();

    pub fn get_machine(&self) -> Result<Machine, VboxError> {
        let machine = get_function_result_pointer!(self.object, GetMachine, *mut IMachine)?;
        Ok(Machine::new(machine))
    }

    /// Console object associated with this session.
    ///
    /// # Returns
    ///
    /// Returns [`Console`] on success, or a [`VboxError`] on failure.
    ///
    ///  # Example
    ///
    /// ```no_run
    ///
    /// use virtualbox_rs::{Session, VirtualBox};
    /// use virtualbox_rs::enums::SessionType;
    ///
    /// let vbox = VirtualBox::init().unwrap();
    /// let mut session = Session::init().unwrap();
    /// let machine = vbox.
    ///         find_machines("Freebsd_14").unwrap();
    /// machine.lock_machine(&mut session, SessionType::Shared).unwrap();
    ///
    /// let console = session.get_console().unwrap();
    pub fn get_console(&self) -> Result<Console, VboxError> {
        let console = get_function_result_pointer!(self.object, GetConsole, *mut IConsole)?;
        Ok(Console::new(console))
    }
}