rclrs 0.7.0

A ROS 2 client library for developing robotics applications in 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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

pub mod rmw {
    #[cfg(feature = "serde")]
    use serde::{Deserialize, Serialize};

    #[link(name = "unique_identifier_msgs__rosidl_typesupport_c")]
    unsafe extern "C" {
        fn rosidl_typesupport_c__get_message_type_support_handle__unique_identifier_msgs__msg__UUID(
        ) -> *const std::ffi::c_void;
    }

    #[link(name = "unique_identifier_msgs__rosidl_generator_c")]
    unsafe extern "C" {
        fn unique_identifier_msgs__msg__UUID__init(msg: *mut UUID) -> bool;
        fn unique_identifier_msgs__msg__UUID__Sequence__init(
            seq: *mut rosidl_runtime_rs::Sequence<UUID>,
            size: usize,
        ) -> bool;
        fn unique_identifier_msgs__msg__UUID__Sequence__fini(
            seq: *mut rosidl_runtime_rs::Sequence<UUID>,
        );
        fn unique_identifier_msgs__msg__UUID__Sequence__copy(
            in_seq: &rosidl_runtime_rs::Sequence<UUID>,
            out_seq: *mut rosidl_runtime_rs::Sequence<UUID>,
        ) -> bool;
    }

    // Corresponds to unique_identifier_msgs__msg__UUID
    #[repr(C)]
    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
    #[derive(Clone, Debug, PartialEq, PartialOrd)]
    pub struct UUID {
        pub uuid: [u8; 16],
    }

    impl Default for UUID {
        fn default() -> Self {
            unsafe {
                let mut msg = std::mem::zeroed();
                if !unique_identifier_msgs__msg__UUID__init(&mut msg as *mut _) {
                    panic!("Call to unique_identifier_msgs__msg__UUID__init() failed");
                }
                msg
            }
        }
    }

    impl rosidl_runtime_rs::SequenceAlloc for UUID {
        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
            unsafe { unique_identifier_msgs__msg__UUID__Sequence__init(seq as *mut _, size) }
        }
        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
            unsafe { unique_identifier_msgs__msg__UUID__Sequence__fini(seq as *mut _) }
        }
        fn sequence_copy(
            in_seq: &rosidl_runtime_rs::Sequence<Self>,
            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
        ) -> bool {
            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
            unsafe { unique_identifier_msgs__msg__UUID__Sequence__copy(in_seq, out_seq as *mut _) }
        }
    }

    impl rosidl_runtime_rs::Message for UUID {
        type RmwMsg = Self;
        fn into_rmw_message(
            msg_cow: std::borrow::Cow<'_, Self>,
        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
            msg_cow
        }
        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
            msg
        }
    }

    impl rosidl_runtime_rs::RmwMessage for UUID
    where
        Self: Sized,
    {
        const TYPE_NAME: &'static str = "unique_identifier_msgs/msg/UUID";
        fn get_type_support() -> *const std::ffi::c_void {
            // SAFETY: No preconditions for this function.
            unsafe {
                rosidl_typesupport_c__get_message_type_support_handle__unique_identifier_msgs__msg__UUID()
            }
        }
    }
} // mod rmw

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
#[derive(Clone, Debug, PartialEq, PartialOrd)]
pub struct UUID {
    pub uuid: [u8; 16],
}

impl Default for UUID {
    fn default() -> Self {
        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
            crate::vendor::unique_identifier_msgs::msg::rmw::UUID::default(),
        )
    }
}

impl rosidl_runtime_rs::Message for UUID {
    type RmwMsg = crate::vendor::unique_identifier_msgs::msg::rmw::UUID;

    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
        match msg_cow {
            std::borrow::Cow::Owned(msg) => {
                std::borrow::Cow::Owned(Self::RmwMsg { uuid: msg.uuid })
            }
            std::borrow::Cow::Borrowed(msg) => {
                std::borrow::Cow::Owned(Self::RmwMsg { uuid: msg.uuid })
            }
        }
    }

    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
        Self { uuid: msg.uuid }
    }
}