safe_drive/msg/jazzy/common_interfaces/std_srvs/srv/
trigger.rs

1// This file was automatically generated by ros2msg_to_rs (https://github.com/tier4/ros2msg_to_rs).
2use super::super::super::*;
3use super::super::*;
4use crate::msg::common_interfaces::*;
5use crate::msg::*;
6use crate::rcl;
7
8extern "C" {
9    fn std_srvs__srv__Trigger_Request__init(msg: *mut TriggerRequest) -> bool;
10    fn std_srvs__srv__Trigger_Request__fini(msg: *mut TriggerRequest);
11    fn std_srvs__srv__Trigger_Request__Sequence__init(
12        msg: *mut TriggerRequestSeqRaw,
13        size: usize,
14    ) -> bool;
15    fn std_srvs__srv__Trigger_Request__Sequence__fini(msg: *mut TriggerRequestSeqRaw);
16    fn std_srvs__srv__Trigger_Response__init(msg: *mut TriggerResponse) -> bool;
17    fn std_srvs__srv__Trigger_Response__fini(msg: *mut TriggerResponse);
18    fn std_srvs__srv__Trigger_Response__Sequence__init(
19        msg: *mut TriggerResponseSeqRaw,
20        size: usize,
21    ) -> bool;
22    fn std_srvs__srv__Trigger_Response__Sequence__fini(msg: *mut TriggerResponseSeqRaw);
23    fn rosidl_typesupport_c__get_service_type_support_handle__std_srvs__srv__Trigger(
24    ) -> *const rcl::rosidl_service_type_support_t;
25    fn rosidl_typesupport_c__get_message_type_support_handle__std_srvs__srv__Trigger_Request(
26    ) -> *const rcl::rosidl_message_type_support_t;
27    fn rosidl_typesupport_c__get_message_type_support_handle__std_srvs__srv__Trigger_Response(
28    ) -> *const rcl::rosidl_message_type_support_t;
29}
30
31#[repr(C)]
32#[derive(Debug)]
33pub struct TriggerRequest {
34    _unused: u8,
35}
36
37#[repr(C)]
38#[derive(Debug)]
39pub struct TriggerResponse {
40    pub success: bool,
41    pub message: crate::msg::RosString<0>,
42}
43
44impl TriggerRequest {
45    pub fn new() -> Option<Self> {
46        let mut msg: Self = unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
47        if unsafe { std_srvs__srv__Trigger_Request__init(&mut msg) } {
48            Some(msg)
49        } else {
50            None
51        }
52    }
53}
54
55impl Drop for TriggerRequest {
56    fn drop(&mut self) {
57        unsafe { std_srvs__srv__Trigger_Request__fini(self) };
58    }
59}
60
61#[repr(C)]
62#[derive(Debug)]
63struct TriggerRequestSeqRaw {
64    data: *mut TriggerRequest,
65    size: size_t,
66    capacity: size_t,
67}
68
69/// Sequence of TriggerRequest.
70/// `N` is the maximum number of elements.
71/// If `N` is `0`, the size is unlimited.
72#[repr(C)]
73#[derive(Debug)]
74pub struct TriggerRequestSeq<const N: usize> {
75    data: *mut TriggerRequest,
76    size: size_t,
77    capacity: size_t,
78}
79
80impl<const N: usize> TriggerRequestSeq<N> {
81    /// Create a sequence of.
82    /// `N` represents the maximum number of elements.
83    /// If `N` is `0`, the sequence is unlimited.
84    pub fn new(size: usize) -> Option<Self> {
85        if N != 0 && size > N {
86            // the size exceeds in the maximum number
87            return None;
88        }
89
90        let mut msg: TriggerRequestSeqRaw =
91            unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
92        if unsafe { std_srvs__srv__Trigger_Request__Sequence__init(&mut msg, size) } {
93            Some(Self {
94                data: msg.data,
95                size: msg.size,
96                capacity: msg.capacity,
97            })
98        } else {
99            None
100        }
101    }
102
103    pub fn null() -> Self {
104        let msg: TriggerRequestSeqRaw = unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
105        Self {
106            data: msg.data,
107            size: msg.size,
108            capacity: msg.capacity,
109        }
110    }
111
112    pub fn as_slice(&self) -> &[TriggerRequest] {
113        if self.data.is_null() {
114            &[]
115        } else {
116            let s = unsafe { std::slice::from_raw_parts(self.data, self.size as _) };
117            s
118        }
119    }
120
121    pub fn as_slice_mut(&mut self) -> &mut [TriggerRequest] {
122        if self.data.is_null() {
123            &mut []
124        } else {
125            let s = unsafe { std::slice::from_raw_parts_mut(self.data, self.size as _) };
126            s
127        }
128    }
129
130    pub fn iter(&self) -> std::slice::Iter<'_, TriggerRequest> {
131        self.as_slice().iter()
132    }
133
134    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, TriggerRequest> {
135        self.as_slice_mut().iter_mut()
136    }
137
138    pub fn len(&self) -> usize {
139        self.as_slice().len()
140    }
141
142    pub fn is_empty(&self) -> bool {
143        self.len() == 0
144    }
145}
146
147impl<const N: usize> Drop for TriggerRequestSeq<N> {
148    fn drop(&mut self) {
149        let mut msg = TriggerRequestSeqRaw {
150            data: self.data,
151            size: self.size,
152            capacity: self.capacity,
153        };
154        unsafe { std_srvs__srv__Trigger_Request__Sequence__fini(&mut msg) };
155    }
156}
157
158unsafe impl<const N: usize> Send for TriggerRequestSeq<N> {}
159unsafe impl<const N: usize> Sync for TriggerRequestSeq<N> {}
160
161impl TriggerResponse {
162    pub fn new() -> Option<Self> {
163        let mut msg: Self = unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
164        if unsafe { std_srvs__srv__Trigger_Response__init(&mut msg) } {
165            Some(msg)
166        } else {
167            None
168        }
169    }
170}
171
172impl Drop for TriggerResponse {
173    fn drop(&mut self) {
174        unsafe { std_srvs__srv__Trigger_Response__fini(self) };
175    }
176}
177
178#[repr(C)]
179#[derive(Debug)]
180struct TriggerResponseSeqRaw {
181    data: *mut TriggerResponse,
182    size: size_t,
183    capacity: size_t,
184}
185
186/// Sequence of TriggerResponse.
187/// `N` is the maximum number of elements.
188/// If `N` is `0`, the size is unlimited.
189#[repr(C)]
190#[derive(Debug)]
191pub struct TriggerResponseSeq<const N: usize> {
192    data: *mut TriggerResponse,
193    size: size_t,
194    capacity: size_t,
195}
196
197impl<const N: usize> TriggerResponseSeq<N> {
198    /// Create a sequence of.
199    /// `N` represents the maximum number of elements.
200    /// If `N` is `0`, the sequence is unlimited.
201    pub fn new(size: usize) -> Option<Self> {
202        if N != 0 && size > N {
203            // the size exceeds in the maximum number
204            return None;
205        }
206
207        let mut msg: TriggerResponseSeqRaw =
208            unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
209        if unsafe { std_srvs__srv__Trigger_Response__Sequence__init(&mut msg, size) } {
210            Some(Self {
211                data: msg.data,
212                size: msg.size,
213                capacity: msg.capacity,
214            })
215        } else {
216            None
217        }
218    }
219
220    pub fn null() -> Self {
221        let msg: TriggerResponseSeqRaw = unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
222        Self {
223            data: msg.data,
224            size: msg.size,
225            capacity: msg.capacity,
226        }
227    }
228
229    pub fn as_slice(&self) -> &[TriggerResponse] {
230        if self.data.is_null() {
231            &[]
232        } else {
233            let s = unsafe { std::slice::from_raw_parts(self.data, self.size as _) };
234            s
235        }
236    }
237
238    pub fn as_slice_mut(&mut self) -> &mut [TriggerResponse] {
239        if self.data.is_null() {
240            &mut []
241        } else {
242            let s = unsafe { std::slice::from_raw_parts_mut(self.data, self.size as _) };
243            s
244        }
245    }
246
247    pub fn iter(&self) -> std::slice::Iter<'_, TriggerResponse> {
248        self.as_slice().iter()
249    }
250
251    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, TriggerResponse> {
252        self.as_slice_mut().iter_mut()
253    }
254
255    pub fn len(&self) -> usize {
256        self.as_slice().len()
257    }
258
259    pub fn is_empty(&self) -> bool {
260        self.len() == 0
261    }
262}
263
264impl<const N: usize> Drop for TriggerResponseSeq<N> {
265    fn drop(&mut self) {
266        let mut msg = TriggerResponseSeqRaw {
267            data: self.data,
268            size: self.size,
269            capacity: self.capacity,
270        };
271        unsafe { std_srvs__srv__Trigger_Response__Sequence__fini(&mut msg) };
272    }
273}
274
275unsafe impl<const N: usize> Send for TriggerResponseSeq<N> {}
276unsafe impl<const N: usize> Sync for TriggerResponseSeq<N> {}
277
278pub struct Trigger;
279
280impl ServiceMsg for Trigger {
281    type Request = TriggerRequest;
282    type Response = TriggerResponse;
283    fn type_support() -> *const rcl::rosidl_service_type_support_t {
284        unsafe { rosidl_typesupport_c__get_service_type_support_handle__std_srvs__srv__Trigger() }
285    }
286}
287
288impl TypeSupport for TriggerRequest {
289    fn type_support() -> *const rcl::rosidl_message_type_support_t {
290        unsafe {
291            rosidl_typesupport_c__get_message_type_support_handle__std_srvs__srv__Trigger_Request()
292        }
293    }
294}
295
296impl TypeSupport for TriggerResponse {
297    fn type_support() -> *const rcl::rosidl_message_type_support_t {
298        unsafe {
299            rosidl_typesupport_c__get_message_type_support_handle__std_srvs__srv__Trigger_Response()
300        }
301    }
302}
safe_drive/msg/jazzy/common_interfaces/std_srvs/srv/trigger.rs

safe_drive/msg/jazzy/common_interfaces/std_srvs/srv/
trigger.rs
