safe_drive 0.4.3

safe_drive: Formally Specified Rust Bindings for ROS2
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

use crate::{context::Context, error::RCLResult, get_allocator, rcl};
use std::sync::Arc;

pub(crate) struct RCLGuardCondition {
    pub(crate) cond: Box<rcl::rcl_guard_condition_t>,
    _context: Arc<Context>,
}

impl RCLGuardCondition {
    pub(crate) fn as_ptr(&self) -> *const rcl::rcl_guard_condition_t {
        self.cond.as_ref() as *const _
    }

    pub(crate) unsafe fn as_ptr_mut(&self) -> *mut rcl::rcl_guard_condition_t {
        self.cond.as_ref() as *const _ as *mut _
    }
}

impl Drop for RCLGuardCondition {
    fn drop(&mut self) {
        let guard = rcl::MT_UNSAFE_FN.lock();
        guard.rcl_guard_condition_fini(self.cond.as_mut()).unwrap();
    }
}

#[derive(Clone)]
pub(crate) struct GuardCondition {
    pub(crate) cond: Arc<RCLGuardCondition>,
}

impl GuardCondition {
    pub(crate) fn new(context: Arc<Context>) -> RCLResult<Self> {
        let mut guard_condition = rcl::MTSafeFn::rcl_get_zero_initialized_guard_condition();
        let allocator = get_allocator();

        {
            let guard = rcl::MT_UNSAFE_FN.lock();
            guard.rcl_guard_condition_init(
                &mut guard_condition,
                unsafe { context.as_ptr_mut() },
                rcl::rcl_guard_condition_options_t { allocator },
            )?;
        }

        let cond = Arc::new(RCLGuardCondition {
            cond: Box::new(guard_condition),
            _context: context,
        });
        Ok(GuardCondition { cond })
    }

    pub(crate) fn trigger(&self) -> RCLResult<()> {
        let guard = rcl::MT_UNSAFE_FN.lock();
        guard.rcl_trigger_guard_condition(unsafe { self.cond.as_ptr_mut() })
    }
}

unsafe impl Sync for GuardCondition {}
unsafe impl Send for GuardCondition {}