wasi-nn 0.6.0

High-level Rust bindings for wasi-nn
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

//! Wraps `wasi-nn` API errors.

/// Wraps `wasi-nn` API errors.
#[derive(thiserror::Error, Debug)]
pub enum Error {
    #[error("IO Error: {0}")]
    IoError(#[from] std::io::Error),

    #[error("Backend Error: {0}")]
    BackendError(#[from] BackendError),
}

#[derive(thiserror::Error, Debug)]
pub enum BackendError {
    #[error("WASI-NN Backend Error: Caller module passed an invalid argument")]
    InvalidArgument,
    #[error("WASI-NN Backend Error: Invalid Encoding")]
    InvalidEncoding,
    #[error("WASI-NN Backend Error: Caller module is missing a memory export")]
    MissingMemory,
    #[error("WASI-NN Backend Error: Device or resource busy")]
    Busy,
    #[error("WASI-NN Backend Error: Runtime Error")]
    RuntimeError,
    #[error("WASI-NN Backend Error: Unsupported Operation")]
    UnsupportedOperation,
    #[error("WASI-NN Backend Error: Too Large")]
    TooLarge,
    #[error("WASI-NN Backend Error: Not Found")]
    NotFound,
    #[error("Unknown Wasi-NN Backend Error Code `{0}`")]
    UnknownError(i32),
}

impl From<i32> for BackendError {
    fn from(value: i32) -> Self {
        match value {
            1 => Self::InvalidArgument,
            2 => Self::InvalidEncoding,
            3 => Self::MissingMemory,
            4 => Self::Busy,
            5 => Self::RuntimeError,
            6 => Self::UnsupportedOperation,
            7 => Self::TooLarge,
            8 => Self::NotFound,
            _ => Self::UnknownError(value),
        }
    }
}

#[cfg(test)]
mod test {
    use super::BackendError;
    use crate::generated;

    macro_rules! test_enum_eq {
        ( $v:expr, $enum_name:ident, $enum_element:ident ) => {
            match $enum_name::from($v) {
                $enum_name::$enum_element => {}
                _ => {
                    assert!(false);
                }
            }
        };
    }

    #[test]
    fn test_wasi_nn_backend_error_from_i32() {
        test_enum_eq!(1, BackendError, InvalidArgument);
        test_enum_eq!(2, BackendError, InvalidEncoding);
        test_enum_eq!(3, BackendError, MissingMemory);
        test_enum_eq!(4, BackendError, Busy);
        test_enum_eq!(5, BackendError, RuntimeError);
        test_enum_eq!(6, BackendError, UnsupportedOperation);
        test_enum_eq!(7, BackendError, TooLarge);
        test_enum_eq!(8, BackendError, NotFound);
    }

    #[test]
    fn test_backend_error_with_generated() {
        test_enum_eq!(
            crate::generated::NN_ERRNO_INVALID_ARGUMENT.raw() as i32,
            BackendError,
            InvalidArgument
        );
        test_enum_eq!(
            generated::NN_ERRNO_INVALID_ENCODING.raw() as i32,
            BackendError,
            InvalidEncoding
        );
        test_enum_eq!(
            generated::NN_ERRNO_MISSING_MEMORY.raw() as i32,
            BackendError,
            MissingMemory
        );
        test_enum_eq!(generated::NN_ERRNO_BUSY.raw() as i32, BackendError, Busy);
        test_enum_eq!(
            generated::NN_ERRNO_RUNTIME_ERROR.raw() as i32,
            BackendError,
            RuntimeError
        );
    }
}