rhai 0.15.0

Embedded scripting for Rust
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

use super::logic::{eq, gt, gte, lt, lte, ne};
use super::math_basic::MAX_INT;

use crate::def_package;
use crate::module::FuncReturn;
use crate::parser::INT;
use crate::result::EvalAltResult;
use crate::token::Position;

#[cfg(not(feature = "no_std"))]
use crate::stdlib::time::Instant;

#[cfg(not(feature = "no_float"))]
use crate::parser::FLOAT;

#[cfg(not(feature = "no_std"))]
def_package!(crate:BasicTimePackage:"Basic timing utilities.", lib, {
    // Register date/time functions
    lib.set_fn_0("timestamp", || Ok(Instant::now()));

    lib.set_fn_2(
        "-",
        |ts1: Instant, ts2: Instant| {
            if ts2 > ts1 {
                #[cfg(not(feature = "no_float"))]
                return Ok(-(ts2 - ts1).as_secs_f64());

                #[cfg(feature = "no_float")]
                {
                    let seconds = (ts2 - ts1).as_secs();

                    #[cfg(not(feature = "unchecked"))]
                    {
                        if seconds > (MAX_INT as u64) {
                            return Err(Box::new(EvalAltResult::ErrorArithmetic(
                                format!(
                                    "Integer overflow for timestamp duration: {}",
                                    -(seconds as i64)
                                ),
                                Position::none(),
                            )));
                        }
                    }
                    return Ok(-(seconds as INT));
                }
            } else {
                #[cfg(not(feature = "no_float"))]
                return Ok((ts1 - ts2).as_secs_f64());

                #[cfg(feature = "no_float")]
                {
                    let seconds = (ts1 - ts2).as_secs();

                    #[cfg(not(feature = "unchecked"))]
                    {
                        if seconds > (MAX_INT as u64) {
                            return Err(Box::new(EvalAltResult::ErrorArithmetic(
                                format!("Integer overflow for timestamp duration: {}", seconds),
                                Position::none(),
                            )));
                        }
                    }
                    return Ok(seconds as INT);
                }
            }
        },
    );

    lib.set_fn_2("<", lt::<Instant>);
    lib.set_fn_2("<=", lte::<Instant>);
    lib.set_fn_2(">", gt::<Instant>);
    lib.set_fn_2(">=", gte::<Instant>);
    lib.set_fn_2("==", eq::<Instant>);
    lib.set_fn_2("!=", ne::<Instant>);

    #[cfg(not(feature = "no_float"))]
    fn elapsed (timestamp: &mut Instant) -> Result<FLOAT, Box<EvalAltResult>> {
        Ok(timestamp.elapsed().as_secs_f64())
    }

    #[cfg(feature = "no_float")]
    fn elapsed (timestamp: &mut Instant) -> Result<INT, Box<EvalAltResult>> {
        let seconds = timestamp.elapsed().as_secs();

        #[cfg(not(feature = "unchecked"))]
        {
            if seconds > (MAX_INT as u64) {
                return Err(Box::new(EvalAltResult::ErrorArithmetic(
                    format!("Integer overflow for timestamp.elapsed: {}", seconds),
                    Position::none(),
                )));
            }
        }
        Ok(seconds as INT)
    }

    lib.set_fn_1_mut("elapsed", elapsed);

    #[cfg(not(feature = "no_object"))]
    lib.set_getter_fn("elapsed", elapsed);
});