endurox-rs 0.1.1

Dev middleware utilities for Enduro/X projects (Rust bindings).
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

use crate::raw;
use crate::AtmiCtx;
use std::ffi::CString;
use std::os::raw::{c_char, c_int, c_long};

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum LogLevel {
    Always = 1,
    Error = 2,
    Warn = 3,
    Info = 4,
    Debug = 5,
    Dump = 6,
}

impl From<LogLevel> for c_int {
    fn from(l: LogLevel) -> Self {
        l as c_int
    }
}

fn call_logex(
    f: unsafe extern "C" fn(c_int, *const c_char, c_long, *const c_char),
    level: LogLevel,
    file: &'static str,
    line: u32,
    msg: &str,
) {
    // sanitize and convert
    let c_file = match CString::new(file) {
        Ok(s) => s,
        Err(_) => return,
    };
    let c_msg = match CString::new(msg.replace('\0', "")) {
        Ok(s) => s,
        Err(_) => return,
    };
    unsafe {
        f(
            level.into(),
            c_file.as_ptr(),
            line as c_long,
            c_msg.as_ptr(),
        )
    }
}

impl AtmiCtx {
    #[inline]
    pub fn tplog_str(&self, level: LogLevel, file: &'static str, line: u32, msg: &str) {
        call_logex(raw::tplogex, level, file, line, msg);
    }

    #[inline]
    pub fn ndrxlog_str(&self, level: LogLevel, file: &'static str, line: u32, msg: &str) {
        call_logex(raw::ndrxlogex, level, file, line, msg);
    }

    #[inline]
    pub fn ubflog_str(&self, level: LogLevel, file: &'static str, line: u32, msg: &str) {
        call_logex(raw::ubflogex, level, file, line, msg);
    }
}

// ---- TP logger macros ----
#[macro_export]
macro_rules! tp_log {
    ($ctx:expr, $lvl:expr, $($arg:tt)*) => {{
        let __msg = format!($($arg)*);
        $ctx.tplog_str($lvl, file!(), line!(), &__msg);
    }};
}
#[macro_export]
macro_rules! tp_always { ($ctx:expr, $($arg:tt)*) => { $crate::tp_log!($ctx, $crate::LogLevel::Always, $($arg)*); } }
#[macro_export]
macro_rules! tp_error  { ($ctx:expr, $($arg:tt)*) => { $crate::tp_log!($ctx, $crate::LogLevel::Error,  $($arg)*); } }
#[macro_export]
macro_rules! tp_warn   { ($ctx:expr, $($arg:tt)*) => { $crate::tp_log!($ctx, $crate::LogLevel::Warn,   $($arg)*); } }
#[macro_export]
macro_rules! tp_info   { ($ctx:expr, $($arg:tt)*) => { $crate::tp_log!($ctx, $crate::LogLevel::Info,   $($arg)*); } }
#[macro_export]
macro_rules! tp_debug  { ($ctx:expr, $($arg:tt)*) => { $crate::tp_log!($ctx, $crate::LogLevel::Debug,  $($arg)*); } }
#[macro_export]
macro_rules! tp_dump   { ($ctx:expr, $($arg:tt)*) => { $crate::tp_log!($ctx, $crate::LogLevel::Dump,   $($arg)*); } }

// ---- NDRX logger macros ----
#[macro_export]
macro_rules! ndrx_log {
    ($ctx:expr, $lvl:expr, $($arg:tt)*) => {{
        let __msg = format!($($arg)*);
        $ctx.ndrxlog_str($lvl, file!(), line!(), &__msg);
    }};
}
#[macro_export]
macro_rules! ndrx_always { ($ctx:expr, $($arg:tt)*) => { $crate::ndrx_log!($ctx, $crate::LogLevel::Always, $($arg)*); } }
#[macro_export]
macro_rules! ndrx_error  { ($ctx:expr, $($arg:tt)*) => { $crate::ndrx_log!($ctx, $crate::LogLevel::Error,  $($arg)*); } }
#[macro_export]
macro_rules! ndrx_warn   { ($ctx:expr, $($arg:tt)*) => { $crate::ndrx_log!($ctx, $crate::LogLevel::Warn,   $($arg)*); } }
#[macro_export]
macro_rules! ndrx_info   { ($ctx:expr, $($arg:tt)*) => { $crate::ndrx_log!($ctx, $crate::LogLevel::Info,   $($arg)*); } }
#[macro_export]
macro_rules! ndrx_debug  { ($ctx:expr, $($arg:tt)*) => { $crate::ndrx_log!($ctx, $crate::LogLevel::Debug,  $($arg)*); } }
#[macro_export]
macro_rules! ndrx_dump   { ($ctx:expr, $($arg:tt)*) => { $crate::ndrx_log!($ctx, $crate::LogLevel::Dump,   $($arg)*); } }

// ---- UBF logger macros ----
#[macro_export]
macro_rules! ubf_log {
    ($ctx:expr, $lvl:expr, $($arg:tt)*) => {{
        let __msg = format!($($arg)*);
        $ctx.ubflog_str($lvl, file!(), line!(), &__msg);
    }};
}
#[macro_export]
macro_rules! ubf_always { ($ctx:expr, $($arg:tt)*) => { $crate::ubf_log!($ctx, $crate::LogLevel::Always, $($arg)*); } }
#[macro_export]
macro_rules! ubf_error  { ($ctx:expr, $($arg:tt)*) => { $crate::ubf_log!($ctx, $crate::LogLevel::Error,  $($arg)*); } }
#[macro_export]
macro_rules! ubf_warn   { ($ctx:expr, $($arg:tt)*) => { $crate::ubf_log!($ctx, $crate::LogLevel::Warn,   $($arg)*); } }
#[macro_export]
macro_rules! ubf_info   { ($ctx:expr, $($arg:tt)*) => { $crate::ubf_log!($ctx, $crate::LogLevel::Info,   $($arg)*); } }
#[macro_export]
macro_rules! ubf_debug  { ($ctx:expr, $($arg:tt)*) => { $crate::ubf_log!($ctx, $crate::LogLevel::Debug,  $($arg)*); } }
#[macro_export]
macro_rules! ubf_dump   { ($ctx:expr, $($arg:tt)*) => { $crate::ubf_log!($ctx, $crate::LogLevel::Dump,   $($arg)*); } }