menoh 0.2.2

Binding for Menoh.
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

use std::error;
use std::ffi::{CStr, NulError};
use std::fmt::{self, Display, Formatter};

#[derive(Debug)]
pub enum Error {
    StdError(String),
    UnknownError(String),
    InvalidFilename(String),
    UnsupportedOnnxOpsetVersion(String),
    OnnxParseError(String),
    InvalidDtype(String),
    InvalidAttributeType(String),
    UnsupportedOperatorAttribute(String),
    DimensionMismatch(String),
    VariableNotFound(String),
    IndexOutOfRange(String),
    JsonParseError(String),
    InvalidBackendName(String),
    UnsupportedOperator(String),
    FailedToConfigureOperator(String),
    BackendError(String),
    SameNamedVariableAlreadyExist(String),
    UnsupportedInputDims(String),
    SameNamedParameterAlreadyExist(String),
    SameNamedAttributeAlreadyExist(String),
    InvalidBackendConfigError(String),
    InputNotFoundError(String),
    OutputNotFoundError(String),

    DtypeMismatch {
        /// Actual dtype.
        actual: menoh_sys::menoh_dtype,
        /// Requested dtype.
        expected: menoh_sys::menoh_dtype,
    },
    NulError(NulError),
}
use self::Error::*;

impl Display for Error {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            StdError(message)
            | UnknownError(message)
            | InvalidFilename(message)
            | UnsupportedOnnxOpsetVersion(message)
            | OnnxParseError(message)
            | InvalidDtype(message)
            | InvalidAttributeType(message)
            | UnsupportedOperatorAttribute(message)
            | DimensionMismatch(message)
            | VariableNotFound(message)
            | IndexOutOfRange(message)
            | JsonParseError(message)
            | InvalidBackendName(message)
            | UnsupportedOperator(message)
            | FailedToConfigureOperator(message)
            | BackendError(message)
            | SameNamedVariableAlreadyExist(message)
            | UnsupportedInputDims(message)
            | SameNamedParameterAlreadyExist(message)
            | SameNamedAttributeAlreadyExist(message)
            | InvalidBackendConfigError(message)
            | InputNotFoundError(message)
            | OutputNotFoundError(message) => write!(f, "{}", message),

            DtypeMismatch { actual, expected } => write!(
                f,
                "menoh dtype mismatch error: actural {}, expected {}",
                actual, expected
            ),
            NulError(err) => err.fmt(f),
        }
    }
}

impl error::Error for Error {}

pub fn check(code: menoh_sys::menoh_error_code) -> Result<(), Error> {
    let code = code as menoh_sys::menoh_error_code_constant;

    if code == menoh_sys::menoh_error_code_success {
        Ok(())
    } else {
        let message = String::from_utf8_lossy(
            unsafe { CStr::from_ptr(menoh_sys::menoh_get_last_error_message()) }.to_bytes(),
        )
        .into_owned();
        let err = match code {
            menoh_sys::menoh_error_code_std_error => StdError(message),
            menoh_sys::menoh_error_code_unknown_error => UnknownError(message),
            menoh_sys::menoh_error_code_invalid_filename => InvalidFilename(message),
            menoh_sys::menoh_error_code_unsupported_onnx_opset_version => {
                UnsupportedOnnxOpsetVersion(message)
            }
            menoh_sys::menoh_error_code_onnx_parse_error => OnnxParseError(message),
            menoh_sys::menoh_error_code_invalid_dtype => InvalidDtype(message),
            menoh_sys::menoh_error_code_invalid_attribute_type => InvalidAttributeType(message),
            menoh_sys::menoh_error_code_unsupported_operator_attribute => {
                UnsupportedOperatorAttribute(message)
            }
            menoh_sys::menoh_error_code_dimension_mismatch => DimensionMismatch(message),
            menoh_sys::menoh_error_code_variable_not_found => VariableNotFound(message),
            menoh_sys::menoh_error_code_index_out_of_range => IndexOutOfRange(message),
            menoh_sys::menoh_error_code_json_parse_error => JsonParseError(message),
            menoh_sys::menoh_error_code_invalid_backend_name => InvalidBackendName(message),
            menoh_sys::menoh_error_code_unsupported_operator => UnsupportedOperator(message),
            menoh_sys::menoh_error_code_failed_to_configure_operator => {
                FailedToConfigureOperator(message)
            }
            menoh_sys::menoh_error_code_backend_error => BackendError(message),
            menoh_sys::menoh_error_code_same_named_variable_already_exist => {
                SameNamedVariableAlreadyExist(message)
            }
            menoh_sys::menoh_error_code_unsupported_input_dims => UnsupportedInputDims(message),
            menoh_sys::menoh_error_code_same_named_parameter_already_exist => {
                SameNamedParameterAlreadyExist(message)
            }
            menoh_sys::menoh_error_code_same_named_attribute_already_exist => {
                SameNamedAttributeAlreadyExist(message)
            }
            menoh_sys::menoh_error_code_invalid_backend_config_error => {
                InvalidBackendConfigError(message)
            }
            menoh_sys::menoh_error_code_input_not_found_error => InputNotFoundError(message),
            menoh_sys::menoh_error_code_output_not_found_error => OutputNotFoundError(message),
            _ => unreachable!(),
        };
        Err(err)
    }
}

impl From<NulError> for Error {
    fn from(value: NulError) -> Self {
        NulError(value)
    }
}