a653rs_xng/apex/
sampling.rs

1use core::mem::MaybeUninit;
2
3use a653rs::bindings::*;
4
5use super::XngHypervisor;
6use crate::bindings::*;
7
8impl ApexSamplingPortP4 for XngHypervisor {
9    fn create_sampling_port(
10        sampling_port_name: SamplingPortName,
11        max_message_size: MessageSize,
12        port_direction: PortDirection,
13        refresh_period: ApexSystemTime,
14    ) -> Result<SamplingPortId, ErrorReturnCode> {
15        let mut return_code = MaybeUninit::uninit();
16        let mut port_id = MaybeUninit::uninit();
17        const XNG_1_4_CREATE_SAMPLING_PORT_MAGIC_MINIMUM_REFRESH_PERIOD: ApexSystemTime = 2000; // ns
18        let refresh_period = if port_direction == PortDirection::Source {
19            XNG_1_4_CREATE_SAMPLING_PORT_MAGIC_MINIMUM_REFRESH_PERIOD
20        } else {
21            refresh_period
22        };
23        unsafe {
24            CREATE_SAMPLING_PORT(
25                sampling_port_name.map(|c| c as cty::c_char).as_mut_ptr(),
26                max_message_size as MESSAGE_SIZE_TYPE,
27                port_direction as PORT_DIRECTION_TYPE,
28                refresh_period as SYSTEM_TIME_TYPE,
29                port_id.as_mut_ptr(),
30                return_code.as_mut_ptr(),
31            );
32            ErrorReturnCode::from(return_code.assume_init())?;
33            Ok(port_id.assume_init() as SamplingPortId)
34        }
35    }
36
37    fn write_sampling_message(
38        sampling_port_id: SamplingPortId,
39        message: &[ApexByte],
40    ) -> Result<(), ErrorReturnCode> {
41        let mut return_code = MaybeUninit::uninit();
42        unsafe {
43            WRITE_SAMPLING_MESSAGE(
44                sampling_port_id as SAMPLING_PORT_ID_TYPE,
45                message.as_ptr() as *mut _,
46                message.len() as MESSAGE_SIZE_TYPE,
47                return_code.as_mut_ptr(),
48            );
49            ErrorReturnCode::from(return_code.assume_init())
50        }
51    }
52
53    unsafe fn read_sampling_message(
54        sampling_port_id: SamplingPortId,
55        message: &mut [ApexByte],
56    ) -> Result<(Validity, MessageSize), ErrorReturnCode> {
57        let mut return_code = MaybeUninit::uninit();
58        let mut msg_len = MaybeUninit::uninit();
59        let mut validity = MaybeUninit::uninit();
60        READ_SAMPLING_MESSAGE(
61            sampling_port_id as SAMPLING_PORT_ID_TYPE,
62            message.as_mut_ptr(),
63            msg_len.as_mut_ptr(),
64            validity.as_mut_ptr(),
65            return_code.as_mut_ptr(),
66        );
67        ErrorReturnCode::from(return_code.assume_init())?;
68        Ok((
69            Validity::from_repr(validity.assume_init()).unwrap(),
70            msg_len.assume_init() as MessageSize,
71        ))
72    }
73}
74
75impl ApexSamplingPortP1 for XngHypervisor {
76    fn get_sampling_port_id(
77        sampling_port_name: SamplingPortName,
78    ) -> Result<SamplingPortId, ErrorReturnCode> {
79        let mut return_code = MaybeUninit::uninit();
80        let mut port_id = MaybeUninit::uninit();
81        unsafe {
82            GET_SAMPLING_PORT_ID(
83                sampling_port_name.map(|c| c as cty::c_char).as_mut_ptr(),
84                port_id.as_mut_ptr(),
85                return_code.as_mut_ptr(),
86            );
87            ErrorReturnCode::from(return_code.assume_init())?;
88            Ok(port_id.assume_init() as SamplingPortId)
89        }
90    }
91
92    fn get_sampling_port_status(
93        sampling_port_id: SamplingPortId,
94    ) -> Result<ApexSamplingPortStatus, ErrorReturnCode> {
95        let mut return_code = MaybeUninit::uninit();
96        let mut status = MaybeUninit::uninit();
97        unsafe {
98            GET_SAMPLING_PORT_STATUS(
99                sampling_port_id as SAMPLING_PORT_ID_TYPE,
100                status.as_mut_ptr(),
101                return_code.as_mut_ptr(),
102            );
103            ErrorReturnCode::from(return_code.assume_init())?;
104            let status = status.assume_init();
105            Ok(ApexSamplingPortStatus {
106                refresh_period: status.REFRESH_PERIOD,
107                max_message_size: status.MAX_MESSAGE_SIZE as MessageSize,
108                port_direction: PortDirection::from_repr(status.PORT_DIRECTION).unwrap(),
109                last_msg_validity: Validity::from_repr(status.LAST_MSG_VALIDITY).unwrap(),
110            })
111        }
112    }
113}