ristretto_vm 0.32.1

Java Virtual Machine
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

use crate::java_object::JavaObject;
use crate::thread::Thread;
use crate::{Result, RustValue, Value};

/// Convert a vector of Rust values to a vector of `Value`. Rust value
pub async fn process_values(thread: &Thread, values: &[impl RustValue]) -> Result<Vec<Value>> {
    if values.is_empty() {
        return Ok(Vec::new());
    }

    let mut results = Vec::with_capacity(values.len());
    let vm = thread.vm()?;
    let garbage_collector = vm.garbage_collector();
    for value in values {
        if let Some(string_value) = value.as_rust_string() {
            let value = string_value.to_object(thread).await?;
            results.push(value);
        } else {
            results.push(value.to_value(garbage_collector));
        }
    }
    Ok(results)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_process_values() -> Result<()> {
        let (_vm, thread) = crate::test::thread().await.expect("thread");

        let empty: [Value; 0] = [];
        assert!(process_values(&thread, &empty).await?.is_empty());

        let strings = ["hello"];
        let values = process_values(&thread, &strings).await?;
        let value = values.first().expect("processed value");
        assert_eq!("hello", value.as_string()?);

        let processed_again = process_values(&thread, &values).await?;
        assert_eq!(values, processed_again);
        Ok(())
    }
}