do_not_use_testing_rclrs/vendor/rcl_interfaces/
msg.rs

1pub mod rmw {
2    #[cfg(feature = "serde")]
3    use serde::{Deserialize, Serialize};
4
5    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
6    extern "C" {
7        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__FloatingPointRange(
8        ) -> *const std::os::raw::c_void;
9    }
10
11    #[link(name = "rcl_interfaces__rosidl_generator_c")]
12    extern "C" {
13        fn rcl_interfaces__msg__FloatingPointRange__init(msg: *mut FloatingPointRange) -> bool;
14        fn rcl_interfaces__msg__FloatingPointRange__Sequence__init(
15            seq: *mut rosidl_runtime_rs::Sequence<FloatingPointRange>,
16            size: usize,
17        ) -> bool;
18        fn rcl_interfaces__msg__FloatingPointRange__Sequence__fini(
19            seq: *mut rosidl_runtime_rs::Sequence<FloatingPointRange>,
20        );
21        fn rcl_interfaces__msg__FloatingPointRange__Sequence__copy(
22            in_seq: &rosidl_runtime_rs::Sequence<FloatingPointRange>,
23            out_seq: *mut rosidl_runtime_rs::Sequence<FloatingPointRange>,
24        ) -> bool;
25    }
26
27    // Corresponds to rcl_interfaces__msg__FloatingPointRange
28    #[repr(C)]
29    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
30    #[derive(Clone, Debug, PartialEq, PartialOrd)]
31    pub struct FloatingPointRange {
32        pub from_value: f64,
33        pub to_value: f64,
34        pub step: f64,
35    }
36
37    impl Default for FloatingPointRange {
38        fn default() -> Self {
39            unsafe {
40                let mut msg = std::mem::zeroed();
41                if !rcl_interfaces__msg__FloatingPointRange__init(&mut msg as *mut _) {
42                    panic!("Call to rcl_interfaces__msg__FloatingPointRange__init() failed");
43                }
44                msg
45            }
46        }
47    }
48
49    impl rosidl_runtime_rs::SequenceAlloc for FloatingPointRange {
50        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
51            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
52            unsafe { rcl_interfaces__msg__FloatingPointRange__Sequence__init(seq as *mut _, size) }
53        }
54        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
55            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
56            unsafe { rcl_interfaces__msg__FloatingPointRange__Sequence__fini(seq as *mut _) }
57        }
58        fn sequence_copy(
59            in_seq: &rosidl_runtime_rs::Sequence<Self>,
60            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
61        ) -> bool {
62            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
63            unsafe {
64                rcl_interfaces__msg__FloatingPointRange__Sequence__copy(in_seq, out_seq as *mut _)
65            }
66        }
67    }
68
69    impl rosidl_runtime_rs::Message for FloatingPointRange {
70        type RmwMsg = Self;
71        fn into_rmw_message(
72            msg_cow: std::borrow::Cow<'_, Self>,
73        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
74            msg_cow
75        }
76        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
77            msg
78        }
79    }
80
81    impl rosidl_runtime_rs::RmwMessage for FloatingPointRange
82    where
83        Self: Sized,
84    {
85        const TYPE_NAME: &'static str = "rcl_interfaces/msg/FloatingPointRange";
86        fn get_type_support() -> *const std::os::raw::c_void {
87            // SAFETY: No preconditions for this function.
88            unsafe {
89                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__FloatingPointRange()
90            }
91        }
92    }
93
94    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
95    extern "C" {
96        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__IntegerRange(
97        ) -> *const std::os::raw::c_void;
98    }
99
100    #[link(name = "rcl_interfaces__rosidl_generator_c")]
101    extern "C" {
102        fn rcl_interfaces__msg__IntegerRange__init(msg: *mut IntegerRange) -> bool;
103        fn rcl_interfaces__msg__IntegerRange__Sequence__init(
104            seq: *mut rosidl_runtime_rs::Sequence<IntegerRange>,
105            size: usize,
106        ) -> bool;
107        fn rcl_interfaces__msg__IntegerRange__Sequence__fini(
108            seq: *mut rosidl_runtime_rs::Sequence<IntegerRange>,
109        );
110        fn rcl_interfaces__msg__IntegerRange__Sequence__copy(
111            in_seq: &rosidl_runtime_rs::Sequence<IntegerRange>,
112            out_seq: *mut rosidl_runtime_rs::Sequence<IntegerRange>,
113        ) -> bool;
114    }
115
116    // Corresponds to rcl_interfaces__msg__IntegerRange
117    #[repr(C)]
118    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
119    #[derive(Clone, Debug, PartialEq, PartialOrd)]
120    pub struct IntegerRange {
121        pub from_value: i64,
122        pub to_value: i64,
123        pub step: u64,
124    }
125
126    impl Default for IntegerRange {
127        fn default() -> Self {
128            unsafe {
129                let mut msg = std::mem::zeroed();
130                if !rcl_interfaces__msg__IntegerRange__init(&mut msg as *mut _) {
131                    panic!("Call to rcl_interfaces__msg__IntegerRange__init() failed");
132                }
133                msg
134            }
135        }
136    }
137
138    impl rosidl_runtime_rs::SequenceAlloc for IntegerRange {
139        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
140            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
141            unsafe { rcl_interfaces__msg__IntegerRange__Sequence__init(seq as *mut _, size) }
142        }
143        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
144            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
145            unsafe { rcl_interfaces__msg__IntegerRange__Sequence__fini(seq as *mut _) }
146        }
147        fn sequence_copy(
148            in_seq: &rosidl_runtime_rs::Sequence<Self>,
149            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
150        ) -> bool {
151            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
152            unsafe { rcl_interfaces__msg__IntegerRange__Sequence__copy(in_seq, out_seq as *mut _) }
153        }
154    }
155
156    impl rosidl_runtime_rs::Message for IntegerRange {
157        type RmwMsg = Self;
158        fn into_rmw_message(
159            msg_cow: std::borrow::Cow<'_, Self>,
160        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
161            msg_cow
162        }
163        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
164            msg
165        }
166    }
167
168    impl rosidl_runtime_rs::RmwMessage for IntegerRange
169    where
170        Self: Sized,
171    {
172        const TYPE_NAME: &'static str = "rcl_interfaces/msg/IntegerRange";
173        fn get_type_support() -> *const std::os::raw::c_void {
174            // SAFETY: No preconditions for this function.
175            unsafe {
176                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__IntegerRange()
177            }
178        }
179    }
180
181    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
182    extern "C" {
183        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ListParametersResult(
184        ) -> *const std::os::raw::c_void;
185    }
186
187    #[link(name = "rcl_interfaces__rosidl_generator_c")]
188    extern "C" {
189        fn rcl_interfaces__msg__ListParametersResult__init(msg: *mut ListParametersResult) -> bool;
190        fn rcl_interfaces__msg__ListParametersResult__Sequence__init(
191            seq: *mut rosidl_runtime_rs::Sequence<ListParametersResult>,
192            size: usize,
193        ) -> bool;
194        fn rcl_interfaces__msg__ListParametersResult__Sequence__fini(
195            seq: *mut rosidl_runtime_rs::Sequence<ListParametersResult>,
196        );
197        fn rcl_interfaces__msg__ListParametersResult__Sequence__copy(
198            in_seq: &rosidl_runtime_rs::Sequence<ListParametersResult>,
199            out_seq: *mut rosidl_runtime_rs::Sequence<ListParametersResult>,
200        ) -> bool;
201    }
202
203    // Corresponds to rcl_interfaces__msg__ListParametersResult
204    #[repr(C)]
205    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
206    #[derive(Clone, Debug, PartialEq, PartialOrd)]
207    pub struct ListParametersResult {
208        pub names: rosidl_runtime_rs::Sequence<rosidl_runtime_rs::String>,
209        pub prefixes: rosidl_runtime_rs::Sequence<rosidl_runtime_rs::String>,
210    }
211
212    impl Default for ListParametersResult {
213        fn default() -> Self {
214            unsafe {
215                let mut msg = std::mem::zeroed();
216                if !rcl_interfaces__msg__ListParametersResult__init(&mut msg as *mut _) {
217                    panic!("Call to rcl_interfaces__msg__ListParametersResult__init() failed");
218                }
219                msg
220            }
221        }
222    }
223
224    impl rosidl_runtime_rs::SequenceAlloc for ListParametersResult {
225        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
226            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
227            unsafe {
228                rcl_interfaces__msg__ListParametersResult__Sequence__init(seq as *mut _, size)
229            }
230        }
231        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
232            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
233            unsafe { rcl_interfaces__msg__ListParametersResult__Sequence__fini(seq as *mut _) }
234        }
235        fn sequence_copy(
236            in_seq: &rosidl_runtime_rs::Sequence<Self>,
237            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
238        ) -> bool {
239            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
240            unsafe {
241                rcl_interfaces__msg__ListParametersResult__Sequence__copy(in_seq, out_seq as *mut _)
242            }
243        }
244    }
245
246    impl rosidl_runtime_rs::Message for ListParametersResult {
247        type RmwMsg = Self;
248        fn into_rmw_message(
249            msg_cow: std::borrow::Cow<'_, Self>,
250        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
251            msg_cow
252        }
253        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
254            msg
255        }
256    }
257
258    impl rosidl_runtime_rs::RmwMessage for ListParametersResult
259    where
260        Self: Sized,
261    {
262        const TYPE_NAME: &'static str = "rcl_interfaces/msg/ListParametersResult";
263        fn get_type_support() -> *const std::os::raw::c_void {
264            // SAFETY: No preconditions for this function.
265            unsafe {
266                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ListParametersResult()
267            }
268        }
269    }
270
271    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
272    extern "C" {
273        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__Log(
274        ) -> *const std::os::raw::c_void;
275    }
276
277    #[link(name = "rcl_interfaces__rosidl_generator_c")]
278    extern "C" {
279        fn rcl_interfaces__msg__Log__init(msg: *mut Log) -> bool;
280        fn rcl_interfaces__msg__Log__Sequence__init(
281            seq: *mut rosidl_runtime_rs::Sequence<Log>,
282            size: usize,
283        ) -> bool;
284        fn rcl_interfaces__msg__Log__Sequence__fini(seq: *mut rosidl_runtime_rs::Sequence<Log>);
285        fn rcl_interfaces__msg__Log__Sequence__copy(
286            in_seq: &rosidl_runtime_rs::Sequence<Log>,
287            out_seq: *mut rosidl_runtime_rs::Sequence<Log>,
288        ) -> bool;
289    }
290
291    // Corresponds to rcl_interfaces__msg__Log
292    #[repr(C)]
293    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
294    #[derive(Clone, Debug, PartialEq, PartialOrd)]
295    pub struct Log {
296        pub stamp: crate::vendor::builtin_interfaces::msg::rmw::Time,
297        pub level: u8,
298        pub name: rosidl_runtime_rs::String,
299        pub msg: rosidl_runtime_rs::String,
300        pub file: rosidl_runtime_rs::String,
301        pub function: rosidl_runtime_rs::String,
302        pub line: u32,
303    }
304
305    impl Log {
306        /// Debug is for pedantic information, which is useful when debugging issues.
307        pub const DEBUG: u8 = 10;
308        /// Info is the standard informational level and is used to report expected
309        /// information.
310        pub const INFO: u8 = 20;
311        /// Warning is for information that may potentially cause issues or possibly unexpected
312        /// behavior.
313        pub const WARN: u8 = 30;
314        /// Error is for information that this node cannot resolve.
315        pub const ERROR: u8 = 40;
316        /// Information about a impending node shutdown.
317        pub const FATAL: u8 = 50;
318    }
319
320    impl Default for Log {
321        fn default() -> Self {
322            unsafe {
323                let mut msg = std::mem::zeroed();
324                if !rcl_interfaces__msg__Log__init(&mut msg as *mut _) {
325                    panic!("Call to rcl_interfaces__msg__Log__init() failed");
326                }
327                msg
328            }
329        }
330    }
331
332    impl rosidl_runtime_rs::SequenceAlloc for Log {
333        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
334            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
335            unsafe { rcl_interfaces__msg__Log__Sequence__init(seq as *mut _, size) }
336        }
337        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
338            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
339            unsafe { rcl_interfaces__msg__Log__Sequence__fini(seq as *mut _) }
340        }
341        fn sequence_copy(
342            in_seq: &rosidl_runtime_rs::Sequence<Self>,
343            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
344        ) -> bool {
345            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
346            unsafe { rcl_interfaces__msg__Log__Sequence__copy(in_seq, out_seq as *mut _) }
347        }
348    }
349
350    impl rosidl_runtime_rs::Message for Log {
351        type RmwMsg = Self;
352        fn into_rmw_message(
353            msg_cow: std::borrow::Cow<'_, Self>,
354        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
355            msg_cow
356        }
357        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
358            msg
359        }
360    }
361
362    impl rosidl_runtime_rs::RmwMessage for Log
363    where
364        Self: Sized,
365    {
366        const TYPE_NAME: &'static str = "rcl_interfaces/msg/Log";
367        fn get_type_support() -> *const std::os::raw::c_void {
368            // SAFETY: No preconditions for this function.
369            unsafe {
370                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__Log()
371            }
372        }
373    }
374
375    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
376    extern "C" {
377        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterDescriptor(
378        ) -> *const std::os::raw::c_void;
379    }
380
381    #[link(name = "rcl_interfaces__rosidl_generator_c")]
382    extern "C" {
383        fn rcl_interfaces__msg__ParameterDescriptor__init(msg: *mut ParameterDescriptor) -> bool;
384        fn rcl_interfaces__msg__ParameterDescriptor__Sequence__init(
385            seq: *mut rosidl_runtime_rs::Sequence<ParameterDescriptor>,
386            size: usize,
387        ) -> bool;
388        fn rcl_interfaces__msg__ParameterDescriptor__Sequence__fini(
389            seq: *mut rosidl_runtime_rs::Sequence<ParameterDescriptor>,
390        );
391        fn rcl_interfaces__msg__ParameterDescriptor__Sequence__copy(
392            in_seq: &rosidl_runtime_rs::Sequence<ParameterDescriptor>,
393            out_seq: *mut rosidl_runtime_rs::Sequence<ParameterDescriptor>,
394        ) -> bool;
395    }
396
397    // Corresponds to rcl_interfaces__msg__ParameterDescriptor
398    #[repr(C)]
399    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
400    #[derive(Clone, Debug, PartialEq, PartialOrd)]
401    pub struct ParameterDescriptor {
402        pub name: rosidl_runtime_rs::String,
403        pub type_: u8,
404        pub description: rosidl_runtime_rs::String,
405        pub additional_constraints: rosidl_runtime_rs::String,
406        pub read_only: bool,
407        pub dynamic_typing: bool,
408        pub floating_point_range: rosidl_runtime_rs::BoundedSequence<
409            crate::vendor::rcl_interfaces::msg::rmw::FloatingPointRange,
410            1,
411        >,
412        pub integer_range: rosidl_runtime_rs::BoundedSequence<
413            crate::vendor::rcl_interfaces::msg::rmw::IntegerRange,
414            1,
415        >,
416    }
417
418    impl Default for ParameterDescriptor {
419        fn default() -> Self {
420            unsafe {
421                let mut msg = std::mem::zeroed();
422                if !rcl_interfaces__msg__ParameterDescriptor__init(&mut msg as *mut _) {
423                    panic!("Call to rcl_interfaces__msg__ParameterDescriptor__init() failed");
424                }
425                msg
426            }
427        }
428    }
429
430    impl rosidl_runtime_rs::SequenceAlloc for ParameterDescriptor {
431        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
432            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
433            unsafe { rcl_interfaces__msg__ParameterDescriptor__Sequence__init(seq as *mut _, size) }
434        }
435        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
436            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
437            unsafe { rcl_interfaces__msg__ParameterDescriptor__Sequence__fini(seq as *mut _) }
438        }
439        fn sequence_copy(
440            in_seq: &rosidl_runtime_rs::Sequence<Self>,
441            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
442        ) -> bool {
443            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
444            unsafe {
445                rcl_interfaces__msg__ParameterDescriptor__Sequence__copy(in_seq, out_seq as *mut _)
446            }
447        }
448    }
449
450    impl rosidl_runtime_rs::Message for ParameterDescriptor {
451        type RmwMsg = Self;
452        fn into_rmw_message(
453            msg_cow: std::borrow::Cow<'_, Self>,
454        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
455            msg_cow
456        }
457        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
458            msg
459        }
460    }
461
462    impl rosidl_runtime_rs::RmwMessage for ParameterDescriptor
463    where
464        Self: Sized,
465    {
466        const TYPE_NAME: &'static str = "rcl_interfaces/msg/ParameterDescriptor";
467        fn get_type_support() -> *const std::os::raw::c_void {
468            // SAFETY: No preconditions for this function.
469            unsafe {
470                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterDescriptor()
471            }
472        }
473    }
474
475    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
476    extern "C" {
477        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterEventDescriptors(
478        ) -> *const std::os::raw::c_void;
479    }
480
481    #[link(name = "rcl_interfaces__rosidl_generator_c")]
482    extern "C" {
483        fn rcl_interfaces__msg__ParameterEventDescriptors__init(
484            msg: *mut ParameterEventDescriptors,
485        ) -> bool;
486        fn rcl_interfaces__msg__ParameterEventDescriptors__Sequence__init(
487            seq: *mut rosidl_runtime_rs::Sequence<ParameterEventDescriptors>,
488            size: usize,
489        ) -> bool;
490        fn rcl_interfaces__msg__ParameterEventDescriptors__Sequence__fini(
491            seq: *mut rosidl_runtime_rs::Sequence<ParameterEventDescriptors>,
492        );
493        fn rcl_interfaces__msg__ParameterEventDescriptors__Sequence__copy(
494            in_seq: &rosidl_runtime_rs::Sequence<ParameterEventDescriptors>,
495            out_seq: *mut rosidl_runtime_rs::Sequence<ParameterEventDescriptors>,
496        ) -> bool;
497    }
498
499    // Corresponds to rcl_interfaces__msg__ParameterEventDescriptors
500    #[repr(C)]
501    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
502    #[derive(Clone, Debug, PartialEq, PartialOrd)]
503    pub struct ParameterEventDescriptors {
504        pub new_parameters: rosidl_runtime_rs::Sequence<
505            crate::vendor::rcl_interfaces::msg::rmw::ParameterDescriptor,
506        >,
507        pub changed_parameters: rosidl_runtime_rs::Sequence<
508            crate::vendor::rcl_interfaces::msg::rmw::ParameterDescriptor,
509        >,
510        pub deleted_parameters: rosidl_runtime_rs::Sequence<
511            crate::vendor::rcl_interfaces::msg::rmw::ParameterDescriptor,
512        >,
513    }
514
515    impl Default for ParameterEventDescriptors {
516        fn default() -> Self {
517            unsafe {
518                let mut msg = std::mem::zeroed();
519                if !rcl_interfaces__msg__ParameterEventDescriptors__init(&mut msg as *mut _) {
520                    panic!("Call to rcl_interfaces__msg__ParameterEventDescriptors__init() failed");
521                }
522                msg
523            }
524        }
525    }
526
527    impl rosidl_runtime_rs::SequenceAlloc for ParameterEventDescriptors {
528        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
529            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
530            unsafe {
531                rcl_interfaces__msg__ParameterEventDescriptors__Sequence__init(seq as *mut _, size)
532            }
533        }
534        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
535            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
536            unsafe { rcl_interfaces__msg__ParameterEventDescriptors__Sequence__fini(seq as *mut _) }
537        }
538        fn sequence_copy(
539            in_seq: &rosidl_runtime_rs::Sequence<Self>,
540            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
541        ) -> bool {
542            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
543            unsafe {
544                rcl_interfaces__msg__ParameterEventDescriptors__Sequence__copy(
545                    in_seq,
546                    out_seq as *mut _,
547                )
548            }
549        }
550    }
551
552    impl rosidl_runtime_rs::Message for ParameterEventDescriptors {
553        type RmwMsg = Self;
554        fn into_rmw_message(
555            msg_cow: std::borrow::Cow<'_, Self>,
556        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
557            msg_cow
558        }
559        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
560            msg
561        }
562    }
563
564    impl rosidl_runtime_rs::RmwMessage for ParameterEventDescriptors
565    where
566        Self: Sized,
567    {
568        const TYPE_NAME: &'static str = "rcl_interfaces/msg/ParameterEventDescriptors";
569        fn get_type_support() -> *const std::os::raw::c_void {
570            // SAFETY: No preconditions for this function.
571            unsafe {
572                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterEventDescriptors()
573            }
574        }
575    }
576
577    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
578    extern "C" {
579        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterEvent(
580        ) -> *const std::os::raw::c_void;
581    }
582
583    #[link(name = "rcl_interfaces__rosidl_generator_c")]
584    extern "C" {
585        fn rcl_interfaces__msg__ParameterEvent__init(msg: *mut ParameterEvent) -> bool;
586        fn rcl_interfaces__msg__ParameterEvent__Sequence__init(
587            seq: *mut rosidl_runtime_rs::Sequence<ParameterEvent>,
588            size: usize,
589        ) -> bool;
590        fn rcl_interfaces__msg__ParameterEvent__Sequence__fini(
591            seq: *mut rosidl_runtime_rs::Sequence<ParameterEvent>,
592        );
593        fn rcl_interfaces__msg__ParameterEvent__Sequence__copy(
594            in_seq: &rosidl_runtime_rs::Sequence<ParameterEvent>,
595            out_seq: *mut rosidl_runtime_rs::Sequence<ParameterEvent>,
596        ) -> bool;
597    }
598
599    // Corresponds to rcl_interfaces__msg__ParameterEvent
600    #[repr(C)]
601    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
602    #[derive(Clone, Debug, PartialEq, PartialOrd)]
603    pub struct ParameterEvent {
604        pub stamp: crate::vendor::builtin_interfaces::msg::rmw::Time,
605        pub node: rosidl_runtime_rs::String,
606        pub new_parameters:
607            rosidl_runtime_rs::Sequence<crate::vendor::rcl_interfaces::msg::rmw::Parameter>,
608        pub changed_parameters:
609            rosidl_runtime_rs::Sequence<crate::vendor::rcl_interfaces::msg::rmw::Parameter>,
610        pub deleted_parameters:
611            rosidl_runtime_rs::Sequence<crate::vendor::rcl_interfaces::msg::rmw::Parameter>,
612    }
613
614    impl Default for ParameterEvent {
615        fn default() -> Self {
616            unsafe {
617                let mut msg = std::mem::zeroed();
618                if !rcl_interfaces__msg__ParameterEvent__init(&mut msg as *mut _) {
619                    panic!("Call to rcl_interfaces__msg__ParameterEvent__init() failed");
620                }
621                msg
622            }
623        }
624    }
625
626    impl rosidl_runtime_rs::SequenceAlloc for ParameterEvent {
627        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
628            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
629            unsafe { rcl_interfaces__msg__ParameterEvent__Sequence__init(seq as *mut _, size) }
630        }
631        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
632            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
633            unsafe { rcl_interfaces__msg__ParameterEvent__Sequence__fini(seq as *mut _) }
634        }
635        fn sequence_copy(
636            in_seq: &rosidl_runtime_rs::Sequence<Self>,
637            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
638        ) -> bool {
639            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
640            unsafe {
641                rcl_interfaces__msg__ParameterEvent__Sequence__copy(in_seq, out_seq as *mut _)
642            }
643        }
644    }
645
646    impl rosidl_runtime_rs::Message for ParameterEvent {
647        type RmwMsg = Self;
648        fn into_rmw_message(
649            msg_cow: std::borrow::Cow<'_, Self>,
650        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
651            msg_cow
652        }
653        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
654            msg
655        }
656    }
657
658    impl rosidl_runtime_rs::RmwMessage for ParameterEvent
659    where
660        Self: Sized,
661    {
662        const TYPE_NAME: &'static str = "rcl_interfaces/msg/ParameterEvent";
663        fn get_type_support() -> *const std::os::raw::c_void {
664            // SAFETY: No preconditions for this function.
665            unsafe {
666                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterEvent()
667            }
668        }
669    }
670
671    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
672    extern "C" {
673        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__Parameter(
674        ) -> *const std::os::raw::c_void;
675    }
676
677    #[link(name = "rcl_interfaces__rosidl_generator_c")]
678    extern "C" {
679        fn rcl_interfaces__msg__Parameter__init(msg: *mut Parameter) -> bool;
680        fn rcl_interfaces__msg__Parameter__Sequence__init(
681            seq: *mut rosidl_runtime_rs::Sequence<Parameter>,
682            size: usize,
683        ) -> bool;
684        fn rcl_interfaces__msg__Parameter__Sequence__fini(
685            seq: *mut rosidl_runtime_rs::Sequence<Parameter>,
686        );
687        fn rcl_interfaces__msg__Parameter__Sequence__copy(
688            in_seq: &rosidl_runtime_rs::Sequence<Parameter>,
689            out_seq: *mut rosidl_runtime_rs::Sequence<Parameter>,
690        ) -> bool;
691    }
692
693    // Corresponds to rcl_interfaces__msg__Parameter
694    #[repr(C)]
695    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
696    #[derive(Clone, Debug, PartialEq, PartialOrd)]
697    pub struct Parameter {
698        pub name: rosidl_runtime_rs::String,
699        pub value: crate::vendor::rcl_interfaces::msg::rmw::ParameterValue,
700    }
701
702    impl Default for Parameter {
703        fn default() -> Self {
704            unsafe {
705                let mut msg = std::mem::zeroed();
706                if !rcl_interfaces__msg__Parameter__init(&mut msg as *mut _) {
707                    panic!("Call to rcl_interfaces__msg__Parameter__init() failed");
708                }
709                msg
710            }
711        }
712    }
713
714    impl rosidl_runtime_rs::SequenceAlloc for Parameter {
715        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
716            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
717            unsafe { rcl_interfaces__msg__Parameter__Sequence__init(seq as *mut _, size) }
718        }
719        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
720            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
721            unsafe { rcl_interfaces__msg__Parameter__Sequence__fini(seq as *mut _) }
722        }
723        fn sequence_copy(
724            in_seq: &rosidl_runtime_rs::Sequence<Self>,
725            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
726        ) -> bool {
727            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
728            unsafe { rcl_interfaces__msg__Parameter__Sequence__copy(in_seq, out_seq as *mut _) }
729        }
730    }
731
732    impl rosidl_runtime_rs::Message for Parameter {
733        type RmwMsg = Self;
734        fn into_rmw_message(
735            msg_cow: std::borrow::Cow<'_, Self>,
736        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
737            msg_cow
738        }
739        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
740            msg
741        }
742    }
743
744    impl rosidl_runtime_rs::RmwMessage for Parameter
745    where
746        Self: Sized,
747    {
748        const TYPE_NAME: &'static str = "rcl_interfaces/msg/Parameter";
749        fn get_type_support() -> *const std::os::raw::c_void {
750            // SAFETY: No preconditions for this function.
751            unsafe {
752                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__Parameter()
753            }
754        }
755    }
756
757    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
758    extern "C" {
759        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterType(
760        ) -> *const std::os::raw::c_void;
761    }
762
763    #[link(name = "rcl_interfaces__rosidl_generator_c")]
764    extern "C" {
765        fn rcl_interfaces__msg__ParameterType__init(msg: *mut ParameterType) -> bool;
766        fn rcl_interfaces__msg__ParameterType__Sequence__init(
767            seq: *mut rosidl_runtime_rs::Sequence<ParameterType>,
768            size: usize,
769        ) -> bool;
770        fn rcl_interfaces__msg__ParameterType__Sequence__fini(
771            seq: *mut rosidl_runtime_rs::Sequence<ParameterType>,
772        );
773        fn rcl_interfaces__msg__ParameterType__Sequence__copy(
774            in_seq: &rosidl_runtime_rs::Sequence<ParameterType>,
775            out_seq: *mut rosidl_runtime_rs::Sequence<ParameterType>,
776        ) -> bool;
777    }
778
779    // Corresponds to rcl_interfaces__msg__ParameterType
780    #[repr(C)]
781    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
782    #[derive(Clone, Debug, PartialEq, PartialOrd)]
783    pub struct ParameterType {
784        pub structure_needs_at_least_one_member: u8,
785    }
786
787    impl ParameterType {
788        /// Default value, which implies this is not a valid parameter.
789        pub const PARAMETER_NOT_SET: u8 = 0;
790        pub const PARAMETER_BOOL: u8 = 1;
791        pub const PARAMETER_INTEGER: u8 = 2;
792        pub const PARAMETER_DOUBLE: u8 = 3;
793        pub const PARAMETER_STRING: u8 = 4;
794        pub const PARAMETER_BYTE_ARRAY: u8 = 5;
795        pub const PARAMETER_BOOL_ARRAY: u8 = 6;
796        pub const PARAMETER_INTEGER_ARRAY: u8 = 7;
797        pub const PARAMETER_DOUBLE_ARRAY: u8 = 8;
798        pub const PARAMETER_STRING_ARRAY: u8 = 9;
799    }
800
801    impl Default for ParameterType {
802        fn default() -> Self {
803            unsafe {
804                let mut msg = std::mem::zeroed();
805                if !rcl_interfaces__msg__ParameterType__init(&mut msg as *mut _) {
806                    panic!("Call to rcl_interfaces__msg__ParameterType__init() failed");
807                }
808                msg
809            }
810        }
811    }
812
813    impl rosidl_runtime_rs::SequenceAlloc for ParameterType {
814        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
815            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
816            unsafe { rcl_interfaces__msg__ParameterType__Sequence__init(seq as *mut _, size) }
817        }
818        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
819            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
820            unsafe { rcl_interfaces__msg__ParameterType__Sequence__fini(seq as *mut _) }
821        }
822        fn sequence_copy(
823            in_seq: &rosidl_runtime_rs::Sequence<Self>,
824            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
825        ) -> bool {
826            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
827            unsafe { rcl_interfaces__msg__ParameterType__Sequence__copy(in_seq, out_seq as *mut _) }
828        }
829    }
830
831    impl rosidl_runtime_rs::Message for ParameterType {
832        type RmwMsg = Self;
833        fn into_rmw_message(
834            msg_cow: std::borrow::Cow<'_, Self>,
835        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
836            msg_cow
837        }
838        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
839            msg
840        }
841    }
842
843    impl rosidl_runtime_rs::RmwMessage for ParameterType
844    where
845        Self: Sized,
846    {
847        const TYPE_NAME: &'static str = "rcl_interfaces/msg/ParameterType";
848        fn get_type_support() -> *const std::os::raw::c_void {
849            // SAFETY: No preconditions for this function.
850            unsafe {
851                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterType()
852            }
853        }
854    }
855
856    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
857    extern "C" {
858        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterValue(
859        ) -> *const std::os::raw::c_void;
860    }
861
862    #[link(name = "rcl_interfaces__rosidl_generator_c")]
863    extern "C" {
864        fn rcl_interfaces__msg__ParameterValue__init(msg: *mut ParameterValue) -> bool;
865        fn rcl_interfaces__msg__ParameterValue__Sequence__init(
866            seq: *mut rosidl_runtime_rs::Sequence<ParameterValue>,
867            size: usize,
868        ) -> bool;
869        fn rcl_interfaces__msg__ParameterValue__Sequence__fini(
870            seq: *mut rosidl_runtime_rs::Sequence<ParameterValue>,
871        );
872        fn rcl_interfaces__msg__ParameterValue__Sequence__copy(
873            in_seq: &rosidl_runtime_rs::Sequence<ParameterValue>,
874            out_seq: *mut rosidl_runtime_rs::Sequence<ParameterValue>,
875        ) -> bool;
876    }
877
878    // Corresponds to rcl_interfaces__msg__ParameterValue
879    #[repr(C)]
880    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
881    #[derive(Clone, Debug, PartialEq, PartialOrd)]
882    pub struct ParameterValue {
883        pub type_: u8,
884        pub bool_value: bool,
885        pub integer_value: i64,
886        pub double_value: f64,
887        pub string_value: rosidl_runtime_rs::String,
888        pub byte_array_value: rosidl_runtime_rs::Sequence<u8>,
889        pub bool_array_value: rosidl_runtime_rs::Sequence<bool>,
890        pub integer_array_value: rosidl_runtime_rs::Sequence<i64>,
891        pub double_array_value: rosidl_runtime_rs::Sequence<f64>,
892        pub string_array_value: rosidl_runtime_rs::Sequence<rosidl_runtime_rs::String>,
893    }
894
895    impl Default for ParameterValue {
896        fn default() -> Self {
897            unsafe {
898                let mut msg = std::mem::zeroed();
899                if !rcl_interfaces__msg__ParameterValue__init(&mut msg as *mut _) {
900                    panic!("Call to rcl_interfaces__msg__ParameterValue__init() failed");
901                }
902                msg
903            }
904        }
905    }
906
907    impl rosidl_runtime_rs::SequenceAlloc for ParameterValue {
908        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
909            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
910            unsafe { rcl_interfaces__msg__ParameterValue__Sequence__init(seq as *mut _, size) }
911        }
912        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
913            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
914            unsafe { rcl_interfaces__msg__ParameterValue__Sequence__fini(seq as *mut _) }
915        }
916        fn sequence_copy(
917            in_seq: &rosidl_runtime_rs::Sequence<Self>,
918            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
919        ) -> bool {
920            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
921            unsafe {
922                rcl_interfaces__msg__ParameterValue__Sequence__copy(in_seq, out_seq as *mut _)
923            }
924        }
925    }
926
927    impl rosidl_runtime_rs::Message for ParameterValue {
928        type RmwMsg = Self;
929        fn into_rmw_message(
930            msg_cow: std::borrow::Cow<'_, Self>,
931        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
932            msg_cow
933        }
934        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
935            msg
936        }
937    }
938
939    impl rosidl_runtime_rs::RmwMessage for ParameterValue
940    where
941        Self: Sized,
942    {
943        const TYPE_NAME: &'static str = "rcl_interfaces/msg/ParameterValue";
944        fn get_type_support() -> *const std::os::raw::c_void {
945            // SAFETY: No preconditions for this function.
946            unsafe {
947                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterValue()
948            }
949        }
950    }
951
952    #[link(name = "rcl_interfaces__rosidl_typesupport_c")]
953    extern "C" {
954        fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__SetParametersResult(
955        ) -> *const std::os::raw::c_void;
956    }
957
958    #[link(name = "rcl_interfaces__rosidl_generator_c")]
959    extern "C" {
960        fn rcl_interfaces__msg__SetParametersResult__init(msg: *mut SetParametersResult) -> bool;
961        fn rcl_interfaces__msg__SetParametersResult__Sequence__init(
962            seq: *mut rosidl_runtime_rs::Sequence<SetParametersResult>,
963            size: usize,
964        ) -> bool;
965        fn rcl_interfaces__msg__SetParametersResult__Sequence__fini(
966            seq: *mut rosidl_runtime_rs::Sequence<SetParametersResult>,
967        );
968        fn rcl_interfaces__msg__SetParametersResult__Sequence__copy(
969            in_seq: &rosidl_runtime_rs::Sequence<SetParametersResult>,
970            out_seq: *mut rosidl_runtime_rs::Sequence<SetParametersResult>,
971        ) -> bool;
972    }
973
974    // Corresponds to rcl_interfaces__msg__SetParametersResult
975    #[repr(C)]
976    #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
977    #[derive(Clone, Debug, PartialEq, PartialOrd)]
978    pub struct SetParametersResult {
979        pub successful: bool,
980        pub reason: rosidl_runtime_rs::String,
981    }
982
983    impl Default for SetParametersResult {
984        fn default() -> Self {
985            unsafe {
986                let mut msg = std::mem::zeroed();
987                if !rcl_interfaces__msg__SetParametersResult__init(&mut msg as *mut _) {
988                    panic!("Call to rcl_interfaces__msg__SetParametersResult__init() failed");
989                }
990                msg
991            }
992        }
993    }
994
995    impl rosidl_runtime_rs::SequenceAlloc for SetParametersResult {
996        fn sequence_init(seq: &mut rosidl_runtime_rs::Sequence<Self>, size: usize) -> bool {
997            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
998            unsafe { rcl_interfaces__msg__SetParametersResult__Sequence__init(seq as *mut _, size) }
999        }
1000        fn sequence_fini(seq: &mut rosidl_runtime_rs::Sequence<Self>) {
1001            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
1002            unsafe { rcl_interfaces__msg__SetParametersResult__Sequence__fini(seq as *mut _) }
1003        }
1004        fn sequence_copy(
1005            in_seq: &rosidl_runtime_rs::Sequence<Self>,
1006            out_seq: &mut rosidl_runtime_rs::Sequence<Self>,
1007        ) -> bool {
1008            // SAFETY: This is safe since the pointer is guaranteed to be valid/initialized.
1009            unsafe {
1010                rcl_interfaces__msg__SetParametersResult__Sequence__copy(in_seq, out_seq as *mut _)
1011            }
1012        }
1013    }
1014
1015    impl rosidl_runtime_rs::Message for SetParametersResult {
1016        type RmwMsg = Self;
1017        fn into_rmw_message(
1018            msg_cow: std::borrow::Cow<'_, Self>,
1019        ) -> std::borrow::Cow<'_, Self::RmwMsg> {
1020            msg_cow
1021        }
1022        fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1023            msg
1024        }
1025    }
1026
1027    impl rosidl_runtime_rs::RmwMessage for SetParametersResult
1028    where
1029        Self: Sized,
1030    {
1031        const TYPE_NAME: &'static str = "rcl_interfaces/msg/SetParametersResult";
1032        fn get_type_support() -> *const std::os::raw::c_void {
1033            // SAFETY: No preconditions for this function.
1034            unsafe {
1035                rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__SetParametersResult()
1036            }
1037        }
1038    }
1039} // mod rmw
1040
1041#[cfg(feature = "serde")]
1042use serde::{Deserialize, Serialize};
1043
1044#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1045#[derive(Clone, Debug, PartialEq, PartialOrd)]
1046pub struct FloatingPointRange {
1047    pub from_value: f64,
1048    pub to_value: f64,
1049    pub step: f64,
1050}
1051
1052impl Default for FloatingPointRange {
1053    fn default() -> Self {
1054        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1055            crate::vendor::rcl_interfaces::msg::rmw::FloatingPointRange::default(),
1056        )
1057    }
1058}
1059
1060impl rosidl_runtime_rs::Message for FloatingPointRange {
1061    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::FloatingPointRange;
1062
1063    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1064        match msg_cow {
1065            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1066                from_value: msg.from_value,
1067                to_value: msg.to_value,
1068                step: msg.step,
1069            }),
1070            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1071                from_value: msg.from_value,
1072                to_value: msg.to_value,
1073                step: msg.step,
1074            }),
1075        }
1076    }
1077
1078    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1079        Self {
1080            from_value: msg.from_value,
1081            to_value: msg.to_value,
1082            step: msg.step,
1083        }
1084    }
1085}
1086
1087#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1088#[derive(Clone, Debug, PartialEq, PartialOrd)]
1089pub struct IntegerRange {
1090    pub from_value: i64,
1091    pub to_value: i64,
1092    pub step: u64,
1093}
1094
1095impl Default for IntegerRange {
1096    fn default() -> Self {
1097        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1098            crate::vendor::rcl_interfaces::msg::rmw::IntegerRange::default(),
1099        )
1100    }
1101}
1102
1103impl rosidl_runtime_rs::Message for IntegerRange {
1104    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::IntegerRange;
1105
1106    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1107        match msg_cow {
1108            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1109                from_value: msg.from_value,
1110                to_value: msg.to_value,
1111                step: msg.step,
1112            }),
1113            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1114                from_value: msg.from_value,
1115                to_value: msg.to_value,
1116                step: msg.step,
1117            }),
1118        }
1119    }
1120
1121    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1122        Self {
1123            from_value: msg.from_value,
1124            to_value: msg.to_value,
1125            step: msg.step,
1126        }
1127    }
1128}
1129
1130#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1131#[derive(Clone, Debug, PartialEq, PartialOrd)]
1132pub struct ListParametersResult {
1133    pub names: Vec<std::string::String>,
1134    pub prefixes: Vec<std::string::String>,
1135}
1136
1137impl Default for ListParametersResult {
1138    fn default() -> Self {
1139        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1140            crate::vendor::rcl_interfaces::msg::rmw::ListParametersResult::default(),
1141        )
1142    }
1143}
1144
1145impl rosidl_runtime_rs::Message for ListParametersResult {
1146    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::ListParametersResult;
1147
1148    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1149        match msg_cow {
1150            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1151                names: msg
1152                    .names
1153                    .into_iter()
1154                    .map(|elem| elem.as_str().into())
1155                    .collect(),
1156                prefixes: msg
1157                    .prefixes
1158                    .into_iter()
1159                    .map(|elem| elem.as_str().into())
1160                    .collect(),
1161            }),
1162            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1163                names: msg.names.iter().map(|elem| elem.as_str().into()).collect(),
1164                prefixes: msg
1165                    .prefixes
1166                    .iter()
1167                    .map(|elem| elem.as_str().into())
1168                    .collect(),
1169            }),
1170        }
1171    }
1172
1173    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1174        Self {
1175            names: msg.names.into_iter().map(|elem| elem.to_string()).collect(),
1176            prefixes: msg
1177                .prefixes
1178                .into_iter()
1179                .map(|elem| elem.to_string())
1180                .collect(),
1181        }
1182    }
1183}
1184
1185#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1186#[derive(Clone, Debug, PartialEq, PartialOrd)]
1187pub struct Log {
1188    pub stamp: crate::vendor::builtin_interfaces::msg::Time,
1189    pub level: u8,
1190    pub name: std::string::String,
1191    pub msg: std::string::String,
1192    pub file: std::string::String,
1193    pub function: std::string::String,
1194    pub line: u32,
1195}
1196
1197impl Log {
1198    /// Debug is for pedantic information, which is useful when debugging issues.
1199    pub const DEBUG: u8 = 10;
1200    /// Info is the standard informational level and is used to report expected
1201    /// information.
1202    pub const INFO: u8 = 20;
1203    /// Warning is for information that may potentially cause issues or possibly unexpected
1204    /// behavior.
1205    pub const WARN: u8 = 30;
1206    /// Error is for information that this node cannot resolve.
1207    pub const ERROR: u8 = 40;
1208    /// Information about a impending node shutdown.
1209    pub const FATAL: u8 = 50;
1210}
1211
1212impl Default for Log {
1213    fn default() -> Self {
1214        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1215            crate::vendor::rcl_interfaces::msg::rmw::Log::default(),
1216        )
1217    }
1218}
1219
1220impl rosidl_runtime_rs::Message for Log {
1221    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::Log;
1222
1223    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1224        match msg_cow {
1225            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1226                stamp: crate::vendor::builtin_interfaces::msg::Time::into_rmw_message(
1227                    std::borrow::Cow::Owned(msg.stamp),
1228                )
1229                .into_owned(),
1230                level: msg.level,
1231                name: msg.name.as_str().into(),
1232                msg: msg.msg.as_str().into(),
1233                file: msg.file.as_str().into(),
1234                function: msg.function.as_str().into(),
1235                line: msg.line,
1236            }),
1237            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1238                stamp: crate::vendor::builtin_interfaces::msg::Time::into_rmw_message(
1239                    std::borrow::Cow::Borrowed(&msg.stamp),
1240                )
1241                .into_owned(),
1242                level: msg.level,
1243                name: msg.name.as_str().into(),
1244                msg: msg.msg.as_str().into(),
1245                file: msg.file.as_str().into(),
1246                function: msg.function.as_str().into(),
1247                line: msg.line,
1248            }),
1249        }
1250    }
1251
1252    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1253        Self {
1254            stamp: crate::vendor::builtin_interfaces::msg::Time::from_rmw_message(msg.stamp),
1255            level: msg.level,
1256            name: msg.name.to_string(),
1257            msg: msg.msg.to_string(),
1258            file: msg.file.to_string(),
1259            function: msg.function.to_string(),
1260            line: msg.line,
1261        }
1262    }
1263}
1264
1265#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1266#[derive(Clone, Debug, PartialEq, PartialOrd)]
1267pub struct ParameterDescriptor {
1268    pub name: std::string::String,
1269    pub type_: u8,
1270    pub description: std::string::String,
1271    pub additional_constraints: std::string::String,
1272    pub read_only: bool,
1273    pub dynamic_typing: bool,
1274    pub floating_point_range: rosidl_runtime_rs::BoundedSequence<
1275        crate::vendor::rcl_interfaces::msg::rmw::FloatingPointRange,
1276        1,
1277    >,
1278    pub integer_range: rosidl_runtime_rs::BoundedSequence<
1279        crate::vendor::rcl_interfaces::msg::rmw::IntegerRange,
1280        1,
1281    >,
1282}
1283
1284impl Default for ParameterDescriptor {
1285    fn default() -> Self {
1286        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1287            crate::vendor::rcl_interfaces::msg::rmw::ParameterDescriptor::default(),
1288        )
1289    }
1290}
1291
1292impl rosidl_runtime_rs::Message for ParameterDescriptor {
1293    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::ParameterDescriptor;
1294
1295    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1296        match msg_cow {
1297            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1298                name: msg.name.as_str().into(),
1299                type_: msg.type_,
1300                description: msg.description.as_str().into(),
1301                additional_constraints: msg.additional_constraints.as_str().into(),
1302                read_only: msg.read_only,
1303                dynamic_typing: msg.dynamic_typing,
1304                floating_point_range: msg.floating_point_range,
1305                integer_range: msg.integer_range,
1306            }),
1307            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1308                name: msg.name.as_str().into(),
1309                type_: msg.type_,
1310                description: msg.description.as_str().into(),
1311                additional_constraints: msg.additional_constraints.as_str().into(),
1312                read_only: msg.read_only,
1313                dynamic_typing: msg.dynamic_typing,
1314                floating_point_range: msg.floating_point_range.clone(),
1315                integer_range: msg.integer_range.clone(),
1316            }),
1317        }
1318    }
1319
1320    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1321        Self {
1322            name: msg.name.to_string(),
1323            type_: msg.type_,
1324            description: msg.description.to_string(),
1325            additional_constraints: msg.additional_constraints.to_string(),
1326            read_only: msg.read_only,
1327            dynamic_typing: msg.dynamic_typing,
1328            floating_point_range: msg.floating_point_range,
1329            integer_range: msg.integer_range,
1330        }
1331    }
1332}
1333
1334#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1335#[derive(Clone, Debug, PartialEq, PartialOrd)]
1336pub struct ParameterEventDescriptors {
1337    pub new_parameters: Vec<crate::vendor::rcl_interfaces::msg::ParameterDescriptor>,
1338    pub changed_parameters: Vec<crate::vendor::rcl_interfaces::msg::ParameterDescriptor>,
1339    pub deleted_parameters: Vec<crate::vendor::rcl_interfaces::msg::ParameterDescriptor>,
1340}
1341
1342impl Default for ParameterEventDescriptors {
1343    fn default() -> Self {
1344        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1345            crate::vendor::rcl_interfaces::msg::rmw::ParameterEventDescriptors::default(),
1346        )
1347    }
1348}
1349
1350impl rosidl_runtime_rs::Message for ParameterEventDescriptors {
1351    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::ParameterEventDescriptors;
1352
1353    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1354        match msg_cow {
1355            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1356                new_parameters: msg
1357                    .new_parameters
1358                    .into_iter()
1359                    .map(|elem| {
1360                        crate::vendor::rcl_interfaces::msg::ParameterDescriptor::into_rmw_message(
1361                            std::borrow::Cow::Owned(elem),
1362                        )
1363                        .into_owned()
1364                    })
1365                    .collect(),
1366                changed_parameters: msg
1367                    .changed_parameters
1368                    .into_iter()
1369                    .map(|elem| {
1370                        crate::vendor::rcl_interfaces::msg::ParameterDescriptor::into_rmw_message(
1371                            std::borrow::Cow::Owned(elem),
1372                        )
1373                        .into_owned()
1374                    })
1375                    .collect(),
1376                deleted_parameters: msg
1377                    .deleted_parameters
1378                    .into_iter()
1379                    .map(|elem| {
1380                        crate::vendor::rcl_interfaces::msg::ParameterDescriptor::into_rmw_message(
1381                            std::borrow::Cow::Owned(elem),
1382                        )
1383                        .into_owned()
1384                    })
1385                    .collect(),
1386            }),
1387            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1388                new_parameters: msg
1389                    .new_parameters
1390                    .iter()
1391                    .map(|elem| {
1392                        crate::vendor::rcl_interfaces::msg::ParameterDescriptor::into_rmw_message(
1393                            std::borrow::Cow::Borrowed(elem),
1394                        )
1395                        .into_owned()
1396                    })
1397                    .collect(),
1398                changed_parameters: msg
1399                    .changed_parameters
1400                    .iter()
1401                    .map(|elem| {
1402                        crate::vendor::rcl_interfaces::msg::ParameterDescriptor::into_rmw_message(
1403                            std::borrow::Cow::Borrowed(elem),
1404                        )
1405                        .into_owned()
1406                    })
1407                    .collect(),
1408                deleted_parameters: msg
1409                    .deleted_parameters
1410                    .iter()
1411                    .map(|elem| {
1412                        crate::vendor::rcl_interfaces::msg::ParameterDescriptor::into_rmw_message(
1413                            std::borrow::Cow::Borrowed(elem),
1414                        )
1415                        .into_owned()
1416                    })
1417                    .collect(),
1418            }),
1419        }
1420    }
1421
1422    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1423        Self {
1424            new_parameters: msg
1425                .new_parameters
1426                .into_iter()
1427                .map(crate::vendor::rcl_interfaces::msg::ParameterDescriptor::from_rmw_message)
1428                .collect(),
1429            changed_parameters: msg
1430                .changed_parameters
1431                .into_iter()
1432                .map(crate::vendor::rcl_interfaces::msg::ParameterDescriptor::from_rmw_message)
1433                .collect(),
1434            deleted_parameters: msg
1435                .deleted_parameters
1436                .into_iter()
1437                .map(crate::vendor::rcl_interfaces::msg::ParameterDescriptor::from_rmw_message)
1438                .collect(),
1439        }
1440    }
1441}
1442
1443#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1444#[derive(Clone, Debug, PartialEq, PartialOrd)]
1445pub struct ParameterEvent {
1446    pub stamp: crate::vendor::builtin_interfaces::msg::Time,
1447    pub node: std::string::String,
1448    pub new_parameters: Vec<crate::vendor::rcl_interfaces::msg::Parameter>,
1449    pub changed_parameters: Vec<crate::vendor::rcl_interfaces::msg::Parameter>,
1450    pub deleted_parameters: Vec<crate::vendor::rcl_interfaces::msg::Parameter>,
1451}
1452
1453impl Default for ParameterEvent {
1454    fn default() -> Self {
1455        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1456            crate::vendor::rcl_interfaces::msg::rmw::ParameterEvent::default(),
1457        )
1458    }
1459}
1460
1461impl rosidl_runtime_rs::Message for ParameterEvent {
1462    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::ParameterEvent;
1463
1464    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1465        match msg_cow {
1466            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1467                stamp: crate::vendor::builtin_interfaces::msg::Time::into_rmw_message(
1468                    std::borrow::Cow::Owned(msg.stamp),
1469                )
1470                .into_owned(),
1471                node: msg.node.as_str().into(),
1472                new_parameters: msg
1473                    .new_parameters
1474                    .into_iter()
1475                    .map(|elem| {
1476                        crate::vendor::rcl_interfaces::msg::Parameter::into_rmw_message(
1477                            std::borrow::Cow::Owned(elem),
1478                        )
1479                        .into_owned()
1480                    })
1481                    .collect(),
1482                changed_parameters: msg
1483                    .changed_parameters
1484                    .into_iter()
1485                    .map(|elem| {
1486                        crate::vendor::rcl_interfaces::msg::Parameter::into_rmw_message(
1487                            std::borrow::Cow::Owned(elem),
1488                        )
1489                        .into_owned()
1490                    })
1491                    .collect(),
1492                deleted_parameters: msg
1493                    .deleted_parameters
1494                    .into_iter()
1495                    .map(|elem| {
1496                        crate::vendor::rcl_interfaces::msg::Parameter::into_rmw_message(
1497                            std::borrow::Cow::Owned(elem),
1498                        )
1499                        .into_owned()
1500                    })
1501                    .collect(),
1502            }),
1503            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1504                stamp: crate::vendor::builtin_interfaces::msg::Time::into_rmw_message(
1505                    std::borrow::Cow::Borrowed(&msg.stamp),
1506                )
1507                .into_owned(),
1508                node: msg.node.as_str().into(),
1509                new_parameters: msg
1510                    .new_parameters
1511                    .iter()
1512                    .map(|elem| {
1513                        crate::vendor::rcl_interfaces::msg::Parameter::into_rmw_message(
1514                            std::borrow::Cow::Borrowed(elem),
1515                        )
1516                        .into_owned()
1517                    })
1518                    .collect(),
1519                changed_parameters: msg
1520                    .changed_parameters
1521                    .iter()
1522                    .map(|elem| {
1523                        crate::vendor::rcl_interfaces::msg::Parameter::into_rmw_message(
1524                            std::borrow::Cow::Borrowed(elem),
1525                        )
1526                        .into_owned()
1527                    })
1528                    .collect(),
1529                deleted_parameters: msg
1530                    .deleted_parameters
1531                    .iter()
1532                    .map(|elem| {
1533                        crate::vendor::rcl_interfaces::msg::Parameter::into_rmw_message(
1534                            std::borrow::Cow::Borrowed(elem),
1535                        )
1536                        .into_owned()
1537                    })
1538                    .collect(),
1539            }),
1540        }
1541    }
1542
1543    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1544        Self {
1545            stamp: crate::vendor::builtin_interfaces::msg::Time::from_rmw_message(msg.stamp),
1546            node: msg.node.to_string(),
1547            new_parameters: msg
1548                .new_parameters
1549                .into_iter()
1550                .map(crate::vendor::rcl_interfaces::msg::Parameter::from_rmw_message)
1551                .collect(),
1552            changed_parameters: msg
1553                .changed_parameters
1554                .into_iter()
1555                .map(crate::vendor::rcl_interfaces::msg::Parameter::from_rmw_message)
1556                .collect(),
1557            deleted_parameters: msg
1558                .deleted_parameters
1559                .into_iter()
1560                .map(crate::vendor::rcl_interfaces::msg::Parameter::from_rmw_message)
1561                .collect(),
1562        }
1563    }
1564}
1565
1566#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1567#[derive(Clone, Debug, PartialEq, PartialOrd)]
1568pub struct Parameter {
1569    pub name: std::string::String,
1570    pub value: crate::vendor::rcl_interfaces::msg::ParameterValue,
1571}
1572
1573impl Default for Parameter {
1574    fn default() -> Self {
1575        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1576            crate::vendor::rcl_interfaces::msg::rmw::Parameter::default(),
1577        )
1578    }
1579}
1580
1581impl rosidl_runtime_rs::Message for Parameter {
1582    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::Parameter;
1583
1584    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1585        match msg_cow {
1586            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1587                name: msg.name.as_str().into(),
1588                value: crate::vendor::rcl_interfaces::msg::ParameterValue::into_rmw_message(
1589                    std::borrow::Cow::Owned(msg.value),
1590                )
1591                .into_owned(),
1592            }),
1593            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1594                name: msg.name.as_str().into(),
1595                value: crate::vendor::rcl_interfaces::msg::ParameterValue::into_rmw_message(
1596                    std::borrow::Cow::Borrowed(&msg.value),
1597                )
1598                .into_owned(),
1599            }),
1600        }
1601    }
1602
1603    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1604        Self {
1605            name: msg.name.to_string(),
1606            value: crate::vendor::rcl_interfaces::msg::ParameterValue::from_rmw_message(msg.value),
1607        }
1608    }
1609}
1610
1611#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1612#[derive(Clone, Debug, PartialEq, PartialOrd)]
1613pub struct ParameterType {
1614    pub structure_needs_at_least_one_member: u8,
1615}
1616
1617impl ParameterType {
1618    /// Default value, which implies this is not a valid parameter.
1619    pub const PARAMETER_NOT_SET: u8 = 0;
1620    pub const PARAMETER_BOOL: u8 = 1;
1621    pub const PARAMETER_INTEGER: u8 = 2;
1622    pub const PARAMETER_DOUBLE: u8 = 3;
1623    pub const PARAMETER_STRING: u8 = 4;
1624    pub const PARAMETER_BYTE_ARRAY: u8 = 5;
1625    pub const PARAMETER_BOOL_ARRAY: u8 = 6;
1626    pub const PARAMETER_INTEGER_ARRAY: u8 = 7;
1627    pub const PARAMETER_DOUBLE_ARRAY: u8 = 8;
1628    pub const PARAMETER_STRING_ARRAY: u8 = 9;
1629}
1630
1631impl Default for ParameterType {
1632    fn default() -> Self {
1633        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1634            crate::vendor::rcl_interfaces::msg::rmw::ParameterType::default(),
1635        )
1636    }
1637}
1638
1639impl rosidl_runtime_rs::Message for ParameterType {
1640    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::ParameterType;
1641
1642    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1643        match msg_cow {
1644            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1645                structure_needs_at_least_one_member: msg.structure_needs_at_least_one_member,
1646            }),
1647            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1648                structure_needs_at_least_one_member: msg.structure_needs_at_least_one_member,
1649            }),
1650        }
1651    }
1652
1653    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1654        Self {
1655            structure_needs_at_least_one_member: msg.structure_needs_at_least_one_member,
1656        }
1657    }
1658}
1659
1660#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1661#[derive(Clone, Debug, PartialEq, PartialOrd)]
1662pub struct ParameterValue {
1663    pub type_: u8,
1664    pub bool_value: bool,
1665    pub integer_value: i64,
1666    pub double_value: f64,
1667    pub string_value: std::string::String,
1668    pub byte_array_value: Vec<u8>,
1669    pub bool_array_value: Vec<bool>,
1670    pub integer_array_value: Vec<i64>,
1671    pub double_array_value: Vec<f64>,
1672    pub string_array_value: Vec<std::string::String>,
1673}
1674
1675impl Default for ParameterValue {
1676    fn default() -> Self {
1677        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1678            crate::vendor::rcl_interfaces::msg::rmw::ParameterValue::default(),
1679        )
1680    }
1681}
1682
1683impl rosidl_runtime_rs::Message for ParameterValue {
1684    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::ParameterValue;
1685
1686    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1687        match msg_cow {
1688            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1689                type_: msg.type_,
1690                bool_value: msg.bool_value,
1691                integer_value: msg.integer_value,
1692                double_value: msg.double_value,
1693                string_value: msg.string_value.as_str().into(),
1694                byte_array_value: msg.byte_array_value.into(),
1695                bool_array_value: msg.bool_array_value.into(),
1696                integer_array_value: msg.integer_array_value.into(),
1697                double_array_value: msg.double_array_value.into(),
1698                string_array_value: msg
1699                    .string_array_value
1700                    .into_iter()
1701                    .map(|elem| elem.as_str().into())
1702                    .collect(),
1703            }),
1704            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1705                type_: msg.type_,
1706                bool_value: msg.bool_value,
1707                integer_value: msg.integer_value,
1708                double_value: msg.double_value,
1709                string_value: msg.string_value.as_str().into(),
1710                byte_array_value: msg.byte_array_value.as_slice().into(),
1711                bool_array_value: msg.bool_array_value.as_slice().into(),
1712                integer_array_value: msg.integer_array_value.as_slice().into(),
1713                double_array_value: msg.double_array_value.as_slice().into(),
1714                string_array_value: msg
1715                    .string_array_value
1716                    .iter()
1717                    .map(|elem| elem.as_str().into())
1718                    .collect(),
1719            }),
1720        }
1721    }
1722
1723    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1724        Self {
1725            type_: msg.type_,
1726            bool_value: msg.bool_value,
1727            integer_value: msg.integer_value,
1728            double_value: msg.double_value,
1729            string_value: msg.string_value.to_string(),
1730            byte_array_value: msg.byte_array_value.into_iter().collect(),
1731            bool_array_value: msg.bool_array_value.into_iter().collect(),
1732            integer_array_value: msg.integer_array_value.into_iter().collect(),
1733            double_array_value: msg.double_array_value.into_iter().collect(),
1734            string_array_value: msg
1735                .string_array_value
1736                .into_iter()
1737                .map(|elem| elem.to_string())
1738                .collect(),
1739        }
1740    }
1741}
1742
1743#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
1744#[derive(Clone, Debug, PartialEq, PartialOrd)]
1745pub struct SetParametersResult {
1746    pub successful: bool,
1747    pub reason: std::string::String,
1748}
1749
1750impl Default for SetParametersResult {
1751    fn default() -> Self {
1752        <Self as rosidl_runtime_rs::Message>::from_rmw_message(
1753            crate::vendor::rcl_interfaces::msg::rmw::SetParametersResult::default(),
1754        )
1755    }
1756}
1757
1758impl rosidl_runtime_rs::Message for SetParametersResult {
1759    type RmwMsg = crate::vendor::rcl_interfaces::msg::rmw::SetParametersResult;
1760
1761    fn into_rmw_message(msg_cow: std::borrow::Cow<'_, Self>) -> std::borrow::Cow<'_, Self::RmwMsg> {
1762        match msg_cow {
1763            std::borrow::Cow::Owned(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1764                successful: msg.successful,
1765                reason: msg.reason.as_str().into(),
1766            }),
1767            std::borrow::Cow::Borrowed(msg) => std::borrow::Cow::Owned(Self::RmwMsg {
1768                successful: msg.successful,
1769                reason: msg.reason.as_str().into(),
1770            }),
1771        }
1772    }
1773
1774    fn from_rmw_message(msg: Self::RmwMsg) -> Self {
1775        Self {
1776            successful: msg.successful,
1777            reason: msg.reason.to_string(),
1778        }
1779    }
1780}
do_not_use_testing_rclrs/vendor/rcl_interfaces/msg.rs

do_not_use_testing_rclrs/vendor/rcl_interfaces/
msg.rs
