Skip to main content

nros_diagnostic_msgs/srv/
self_test.rs

1// nros service type - pure Rust, no_std compatible
2// Package: diagnostic_msgs
3// Service: SelfTest
4
5use nros_core::{Deserialize, RosMessage, RosService, Serialize};
6use nros_serdes::{CdrReader, CdrWriter, DeserError, SerError};
7
8/// SelfTest request message
9#[derive(Debug, Clone, Default, PartialEq)]
10pub struct SelfTestRequest {}
11
12impl Serialize for SelfTestRequest {
13    // Empty request - no fields to serialize
14    fn serialize(&self, writer: &mut CdrWriter) -> Result<(), SerError> {
15        let __dh = writer.begin_dheader()?;
16        // Issue 1293 — rosidl's `structure_needs_at_least_one_member`: every
17        // stock typesupport writes it and refuses a payload without it.
18        writer.write_u8(0)?;
19        writer.end_dheader(__dh)?;
20        Ok(())
21    }
22}
23
24impl Deserialize for SelfTestRequest {
25    // Empty request - no fields to deserialize
26    fn deserialize(reader: &mut CdrReader) -> Result<Self, DeserError> {
27        let __dh = reader.begin_dheader()?;
28        // Issue 1293 — the padding byte every stock peer sends.
29        let _ = reader.read_u8()?;
30        reader.end_dheader(__dh)?;
31        Ok(Self {})
32    }
33}
34
35impl RosMessage for SelfTestRequest {
36    const TYPE_NAME: &'static str = "diagnostic_msgs::srv::dds_::SelfTest_Request_";
37    const TYPE_HASH: &'static str = "TypeHashNotSupported";
38    // Issue 1179 -- see the message template: the bound, computed from the
39    // schema, on the one trait every backend's registration can read.
40    const MAX_SERIALIZED_BOUND: Option<usize> = ::nros_serdes::size::max_serialized_bound::<Self>();
41}
42
43// ── nros_serdes::Message — runtime field schema (Request) ───────────────────
44// Consumed by RMW backends that build wire-type descriptors at runtime
45// (Cyclone DDS dynamic types, …) without per-RMW codegen at compile time.
46
47impl ::nros_serdes::Message for SelfTestRequest {
48    const TYPE_NAME: &'static str = "diagnostic_msgs/srv/SelfTest_Request";
49    const FIELDS: &'static [::nros_serdes::Field] = &[::nros_serdes::Field {
50        name: ::nros_serdes::schema::EMPTY_STRUCT_MEMBER,
51        ty: ::nros_serdes::FieldType::Uint8,
52        offset: 0,
53    }];
54}
55
56/// SelfTest response message
57#[derive(Debug, Clone, Default, PartialEq)]
58pub struct SelfTestResponse {
59    pub id: heapless::String<256>,
60    pub passed: u8,
61    pub status: heapless::Vec<crate::msg::DiagnosticStatus, 64>,
62}
63
64impl Serialize for SelfTestResponse {
65    fn serialize(&self, writer: &mut CdrWriter) -> Result<(), SerError> {
66        // phase-303 W4 (#0267) — DHEADER wrap (no-op under XCDR1).
67        let __dh = writer.begin_dheader()?;
68        writer.write_string(self.id.as_str())?;
69        writer.write_u8(self.passed)?;
70        writer.write_u32(self.status.len() as u32)?;
71        for item in &self.status {
72            item.serialize(writer)?;
73        }
74        writer.end_dheader(__dh)?;
75        Ok(())
76    }
77}
78
79impl Deserialize for SelfTestResponse {
80    fn deserialize(reader: &mut CdrReader) -> Result<Self, DeserError> {
81        let __dh = reader.begin_dheader()?;
82        let __value = Self {
83            id: {
84                let s = reader.read_string()?;
85                heapless::String::try_from(s).map_err(|_| DeserError::CapacityExceeded)?
86            },
87            passed: reader.read_u8()?,
88            status: {
89                let len = reader.read_u32()? as usize;
90                let mut vec = heapless::Vec::new();
91                for _ in 0..len {
92                    vec.push(Deserialize::deserialize(reader)?)
93                        .map_err(|_| DeserError::CapacityExceeded)?;
94                }
95                vec
96            },
97        };
98        reader.end_dheader(__dh)?;
99        Ok(__value)
100    }
101}
102
103impl RosMessage for SelfTestResponse {
104    const TYPE_NAME: &'static str = "diagnostic_msgs::srv::dds_::SelfTest_Response_";
105    const TYPE_HASH: &'static str = "TypeHashNotSupported";
106    // Issue 1179 -- see the message template: the bound, computed from the
107    // schema, on the one trait every backend's registration can read.
108    const MAX_SERIALIZED_BOUND: Option<usize> = ::nros_serdes::size::max_serialized_bound::<Self>();
109}
110
111// ── nros_serdes::Message — runtime field schema (Response) ──────────────────
112
113#[allow(non_upper_case_globals)]
114pub const RESP_NESTED_STATUS: ::nros_serdes::NestedType = ::nros_serdes::NestedType {
115    type_name: <crate::msg::DiagnosticStatus as ::nros_serdes::Message>::TYPE_NAME,
116    fields: <crate::msg::DiagnosticStatus as ::nros_serdes::Message>::FIELDS,
117};
118#[allow(non_upper_case_globals)]
119pub const RESP_FT_STATUS_ELEM: ::nros_serdes::FieldType =
120    ::nros_serdes::FieldType::Nested(&RESP_NESTED_STATUS);
121impl ::nros_serdes::Message for SelfTestResponse {
122    const TYPE_NAME: &'static str = "diagnostic_msgs/srv/SelfTest_Response";
123    const FIELDS: &'static [::nros_serdes::Field] = &[
124        ::nros_serdes::Field {
125            name: "id",
126            ty: ::nros_serdes::FieldType::String,
127            offset: ::core::mem::offset_of!(SelfTestResponse, id),
128        },
129        ::nros_serdes::Field {
130            name: "passed",
131            ty: ::nros_serdes::FieldType::Uint8,
132            offset: ::core::mem::offset_of!(SelfTestResponse, passed),
133        },
134        ::nros_serdes::Field {
135            name: "status",
136            ty: ::nros_serdes::FieldType::Sequence(&RESP_FT_STATUS_ELEM),
137            offset: ::core::mem::offset_of!(SelfTestResponse, status),
138        },
139    ];
140}
141
142/// SelfTest service definition
143pub struct SelfTest;
144
145impl RosService for SelfTest {
146    type Request = SelfTestRequest;
147    type Reply = SelfTestResponse;
148
149    const SERVICE_NAME: &'static str = "diagnostic_msgs::srv::dds_::SelfTest_";
150    const SERVICE_HASH: &'static str = "TypeHashNotSupported";
151}