ximu3 1.9.1

x-IMU3 API
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

use crate::command_message::*;
use crate::ffi::helpers::*;
use std::mem;
use std::os::raw::c_char;

#[no_mangle]
pub extern "C" fn XIMU3_json_type_to_string(json_type: JsonType) -> *const c_char {
    str_to_char_ptr(&json_type.to_string())
}

#[repr(C)]
pub struct CommandMessageC {
    pub json: [c_char; CHAR_ARRAY_SIZE],
    pub key: [c_char; CHAR_ARRAY_SIZE],
    pub value: [c_char; CHAR_ARRAY_SIZE],
    pub value_type: JsonType,
    pub error: [c_char; CHAR_ARRAY_SIZE],
}

impl From<Option<CommandMessage>> for CommandMessageC {
    fn from(message: Option<CommandMessage>) -> Self {
        match message {
            Some(message) => Self {
                json: bytes_to_char_array(&message.json),
                key: bytes_to_char_array(&message.key),
                value: bytes_to_char_array(&message.value),
                value_type: message.value_type,
                error: str_to_char_array(message.error.unwrap_or("".to_owned()).as_str()),
            },
            None => Self {
                json: EMPTY_CHAR_ARRAY,
                key: EMPTY_CHAR_ARRAY,
                value: EMPTY_CHAR_ARRAY,
                value_type: JsonType::Null,
                error: EMPTY_CHAR_ARRAY,
            },
        }
    }
}

#[no_mangle]
pub extern "C" fn XIMU3_command_message_parse(json: *const c_char) -> CommandMessageC {
    let json = unsafe { char_ptr_to_bytes(json) };

    CommandMessage::parse(&json).into()
}

#[repr(C)]
pub struct CommandMessages {
    array: *mut CommandMessageC,
    length: u32,
    capacity: u32,
}

impl From<Vec<Option<CommandMessage>>> for CommandMessages {
    fn from(messages: Vec<Option<CommandMessage>>) -> Self {
        let mut vector: Vec<CommandMessageC> = messages.iter().map(|message| message.clone().into()).collect();

        let messages = Self {
            length: vector.len() as u32,
            array: vector.as_mut_ptr(),
            capacity: vector.capacity() as u32,
        };

        mem::forget(vector);

        messages
    }
}

#[no_mangle]
pub extern "C" fn XIMU3_command_messages_free(messages: CommandMessages) {
    if messages.array.is_null() {
        return;
    }

    unsafe {
        let _ = Vec::from_raw_parts(messages.array, messages.length as usize, messages.capacity as usize);
    }
}