rsciter 0.0.11

Unofficial Rust bindings for Sciter
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

use std::{num::TryFromIntError, sync::Arc};

use crate::api::{GraphinError, RequestError};

#[derive(thiserror::Error, Debug, Clone)]
pub enum Error {
    #[error("'{dll}' loading error: {message}")]
    Library {
        dll: String,
        message: String,
        source: Arc<libloading::Error>,
    },

    #[error("No '{name}' exported: {message}")]
    Symbol {
        name: String,
        message: String,
        source: Arc<libloading::Error>,
    },

    #[error("'{0}' API method unavailable")]
    ApiMethod(&'static str),

    #[error("'{0}' API method call failed")]
    ApiMethodFailed(&'static str),

    #[error("Invalid atom value: '{0}'")]
    InvalidAtom(crate::bindings::som_atom_t),

    #[error("Request error: '{0:?}'")]
    BadRequest(RequestError),

    #[error("Graphin error: '{0:?}'")]
    GraphinError(GraphinError),

    #[error("Invalid archive data'")]
    InvalidArchive,

    #[error("Archive item {0} not found'")]
    ArchiveItemNotFound(String),

    #[error("Script evaluation failed")]
    EvalFailed,

    #[error("Value error: {0}")]
    ValueError(#[from] ValueError),

    #[error("Script error: {0}")]
    ScriptError(String),

    #[error("Scripting error, no such method: {0}")]
    ScriptingNoMethod(String),

    #[error("Scripting error, invalid arguments count: {0}")]
    ScriptingInvalidArgCount(String),

    #[error("Scripting error, invalid argument: {0}: {1}")]
    ScriptingInvalidArgument(&'static str, Box<Error>),

    #[error("unknown Sciter error")]
    Unknown,
}

#[cfg_attr(feature = "static", allow(dead_code))]
impl Error {
    pub(crate) fn library(name: &str, err: libloading::Error) -> Self {
        Self::Library {
            dll: name.to_string(),
            message: Self::get_message(&err),
            source: Arc::new(err),
        }
    }

    pub(crate) fn symbol(name: &str, err: libloading::Error) -> Self {
        Self::Symbol {
            name: name.to_string(),
            message: Self::get_message(&err),
            source: Arc::new(err),
        }
    }

    fn get_message(err: &libloading::Error) -> String {
        match std::error::Error::source(&err) {
            Some(src) => format!("{src}"),
            None => format!("{err}"),
        }
    }
}

#[derive(thiserror::Error, Debug, Copy, Clone, PartialEq, Eq)]
pub enum ValueError {
    #[error("Bad parameters")]
    BadParameters,

    #[error("Incompatible type")]
    IncompatibleType,

    #[error("from_string did not parse the rest: {0}")]
    FromStringNonParsed(u32),

    #[error("{0}")]
    TryFromIntError(#[from] TryFromIntError),

    #[error("Unknown: {0}")]
    Unknown(i32),
}

impl From<crate::bindings::VALUE_RESULT> for ValueError {
    fn from(value: crate::bindings::VALUE_RESULT) -> Self {
        match value {
            crate::bindings::VALUE_RESULT::HV_BAD_PARAMETER => ValueError::BadParameters,
            crate::bindings::VALUE_RESULT::HV_INCOMPATIBLE_TYPE => ValueError::IncompatibleType,
            unknown => ValueError::Unknown(unknown.0),
        }
    }
}