1use fidl::unpersist;
2use fidl_cf_sc_internal_receiverconfig::Config as FidlConfig;
3use fuchsia_component_config::{Config as ComponentConfig, Error};
4use fuchsia_inspect::{ArithmeticArrayProperty, ArrayProperty, Node};
5use std::convert::TryInto;
6const EXPECTED_CHECKSUM: &[u8] = &[
7 0xcd, 0x57, 0xb2, 0xa2, 0x89, 0xbb, 0xb6, 0x11, 0xcf, 0x81, 0x50, 0xec, 0x06, 0xc5, 0x06, 0x4c,
8 0x7c, 0xae, 0x79, 0x0f, 0xaa, 0x73, 0x0b, 0x6f, 0xa1, 0x02, 0xc3, 0x53, 0x7b, 0x94, 0xee, 0x1a,
9];
10const EXPECTED_CHECKSUM_LENGTH: [u8; 2] = (EXPECTED_CHECKSUM.len() as u16).to_le_bytes();
11#[derive(Debug)]
12pub struct Config {
13 pub my_flag: bool,
14 pub my_int16: i16,
15 pub my_int32: i32,
16 pub my_int64: i64,
17 pub my_int8: i8,
18 pub my_string: String,
19 pub my_uint16: u16,
20 pub my_uint32: u32,
21 pub my_uint64: u64,
22 pub my_uint8: u8,
23 pub my_vector_of_flag: Vec<bool>,
24 pub my_vector_of_int16: Vec<i16>,
25 pub my_vector_of_int32: Vec<i32>,
26 pub my_vector_of_int64: Vec<i64>,
27 pub my_vector_of_int8: Vec<i8>,
28 pub my_vector_of_string: Vec<String>,
29 pub my_vector_of_uint16: Vec<u16>,
30 pub my_vector_of_uint32: Vec<u32>,
31 pub my_vector_of_uint64: Vec<u64>,
32 pub my_vector_of_uint8: Vec<u8>,
33}
34impl Config {
35 #[doc = r" Take the config startup handle and parse its contents."]
36 #[doc = r""]
37 #[doc = r" # Panics"]
38 #[doc = r""]
39 #[doc = r" If the config startup handle was already taken or if it is not valid."]
40 pub fn take_from_startup_handle() -> Self {
41 <Self as ComponentConfig>::take_from_startup_handle()
42 }
43 #[doc = r" Parse `Self` from `vmo`."]
44 pub fn from_vmo(vmo: &zx::Vmo) -> Result<Self, Error> {
45 <Self as ComponentConfig>::from_vmo(vmo)
46 }
47 #[doc = r" Parse `Self` from `bytes`."]
48 pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
49 <Self as ComponentConfig>::from_bytes(bytes)
50 }
51 pub fn record_inspect(&self, inspector_node: &Node) {
52 <Self as ComponentConfig>::record_inspect(self, inspector_node)
53 }
54}
55impl ComponentConfig for Config {
56 #[doc = r" Parse `Self` from `bytes`."]
57 fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
58 let (checksum_len_bytes, bytes) = bytes.split_at_checked(2).ok_or(Error::TooFewBytes)?;
59 let checksum_len_bytes: [u8; 2] =
60 checksum_len_bytes.try_into().expect("previous call guaranteed 2 element slice");
61 let checksum_length = u16::from_le_bytes(checksum_len_bytes) as usize;
62 let (observed_checksum, bytes) =
63 bytes.split_at_checked(checksum_length).ok_or(Error::TooFewBytes)?;
64 if observed_checksum != EXPECTED_CHECKSUM {
65 return Err(Error::ChecksumMismatch {
66 expected_checksum: EXPECTED_CHECKSUM.to_vec(),
67 observed_checksum: observed_checksum.to_vec(),
68 });
69 }
70 let fidl_config: FidlConfig = unpersist(bytes).map_err(Error::Unpersist)?;
71 Ok(Self {
72 my_flag: fidl_config.my_flag,
73 my_int16: fidl_config.my_int16,
74 my_int32: fidl_config.my_int32,
75 my_int64: fidl_config.my_int64,
76 my_int8: fidl_config.my_int8,
77 my_string: fidl_config.my_string,
78 my_uint16: fidl_config.my_uint16,
79 my_uint32: fidl_config.my_uint32,
80 my_uint64: fidl_config.my_uint64,
81 my_uint8: fidl_config.my_uint8,
82 my_vector_of_flag: fidl_config.my_vector_of_flag,
83 my_vector_of_int16: fidl_config.my_vector_of_int16,
84 my_vector_of_int32: fidl_config.my_vector_of_int32,
85 my_vector_of_int64: fidl_config.my_vector_of_int64,
86 my_vector_of_int8: fidl_config.my_vector_of_int8,
87 my_vector_of_string: fidl_config.my_vector_of_string,
88 my_vector_of_uint16: fidl_config.my_vector_of_uint16,
89 my_vector_of_uint32: fidl_config.my_vector_of_uint32,
90 my_vector_of_uint64: fidl_config.my_vector_of_uint64,
91 my_vector_of_uint8: fidl_config.my_vector_of_uint8,
92 })
93 }
94 fn to_bytes(&self) -> Result<Vec<u8>, Error> {
95 let fidl_config = FidlConfig {
96 my_flag: self.my_flag.clone(),
97 my_int16: self.my_int16.clone(),
98 my_int32: self.my_int32.clone(),
99 my_int64: self.my_int64.clone(),
100 my_int8: self.my_int8.clone(),
101 my_string: self.my_string.clone(),
102 my_uint16: self.my_uint16.clone(),
103 my_uint32: self.my_uint32.clone(),
104 my_uint64: self.my_uint64.clone(),
105 my_uint8: self.my_uint8.clone(),
106 my_vector_of_flag: self.my_vector_of_flag.clone(),
107 my_vector_of_int16: self.my_vector_of_int16.clone(),
108 my_vector_of_int32: self.my_vector_of_int32.clone(),
109 my_vector_of_int64: self.my_vector_of_int64.clone(),
110 my_vector_of_int8: self.my_vector_of_int8.clone(),
111 my_vector_of_string: self.my_vector_of_string.clone(),
112 my_vector_of_uint16: self.my_vector_of_uint16.clone(),
113 my_vector_of_uint32: self.my_vector_of_uint32.clone(),
114 my_vector_of_uint64: self.my_vector_of_uint64.clone(),
115 my_vector_of_uint8: self.my_vector_of_uint8.clone(),
116 };
117 let mut fidl_bytes = fidl::persist(&fidl_config).map_err(Error::Persist)?;
118 let mut bytes = Vec::with_capacity(
119 EXPECTED_CHECKSUM_LENGTH.len() + EXPECTED_CHECKSUM.len() + fidl_bytes.len(),
120 );
121 bytes.extend_from_slice(&EXPECTED_CHECKSUM_LENGTH);
122 bytes.extend_from_slice(EXPECTED_CHECKSUM);
123 bytes.append(&mut fidl_bytes);
124 Ok(bytes)
125 }
126 fn record_inspect(&self, inspector_node: &Node) {
127 inspector_node.record_bool("my_flag", self.my_flag);
128 inspector_node.record_int("my_int16", self.my_int16 as i64);
129 inspector_node.record_int("my_int32", self.my_int32 as i64);
130 inspector_node.record_int("my_int64", self.my_int64);
131 inspector_node.record_int("my_int8", self.my_int8 as i64);
132 inspector_node.record_string("my_string", &self.my_string);
133 inspector_node.record_uint("my_uint16", self.my_uint16 as u64);
134 inspector_node.record_uint("my_uint32", self.my_uint32 as u64);
135 inspector_node.record_uint("my_uint64", self.my_uint64);
136 inspector_node.record_uint("my_uint8", self.my_uint8 as u64);
137 let arr =
138 inspector_node.create_uint_array("my_vector_of_flag", self.my_vector_of_flag.len());
139 for i in 0..self.my_vector_of_flag.len() {
140 arr.add(i, self.my_vector_of_flag[i] as u64);
141 }
142 inspector_node.record(arr);
143 let arr =
144 inspector_node.create_int_array("my_vector_of_int16", self.my_vector_of_int16.len());
145 for i in 0..self.my_vector_of_int16.len() {
146 arr.add(i, self.my_vector_of_int16[i] as i64);
147 }
148 inspector_node.record(arr);
149 let arr =
150 inspector_node.create_int_array("my_vector_of_int32", self.my_vector_of_int32.len());
151 for i in 0..self.my_vector_of_int32.len() {
152 arr.add(i, self.my_vector_of_int32[i] as i64);
153 }
154 inspector_node.record(arr);
155 let arr =
156 inspector_node.create_int_array("my_vector_of_int64", self.my_vector_of_int64.len());
157 for i in 0..self.my_vector_of_int64.len() {
158 arr.add(i, self.my_vector_of_int64[i]);
159 }
160 inspector_node.record(arr);
161 let arr =
162 inspector_node.create_int_array("my_vector_of_int8", self.my_vector_of_int8.len());
163 for i in 0..self.my_vector_of_int8.len() {
164 arr.add(i, self.my_vector_of_int8[i] as i64);
165 }
166 inspector_node.record(arr);
167 let arr = inspector_node
168 .create_string_array("my_vector_of_string", self.my_vector_of_string.len());
169 for i in 0..self.my_vector_of_string.len() {
170 arr.set(i, &self.my_vector_of_string[i]);
171 }
172 inspector_node.record(arr);
173 let arr =
174 inspector_node.create_uint_array("my_vector_of_uint16", self.my_vector_of_uint16.len());
175 for i in 0..self.my_vector_of_uint16.len() {
176 arr.add(i, self.my_vector_of_uint16[i] as u64);
177 }
178 inspector_node.record(arr);
179 let arr =
180 inspector_node.create_uint_array("my_vector_of_uint32", self.my_vector_of_uint32.len());
181 for i in 0..self.my_vector_of_uint32.len() {
182 arr.add(i, self.my_vector_of_uint32[i] as u64);
183 }
184 inspector_node.record(arr);
185 let arr =
186 inspector_node.create_uint_array("my_vector_of_uint64", self.my_vector_of_uint64.len());
187 for i in 0..self.my_vector_of_uint64.len() {
188 arr.add(i, self.my_vector_of_uint64[i]);
189 }
190 inspector_node.record(arr);
191 let arr =
192 inspector_node.create_uint_array("my_vector_of_uint8", self.my_vector_of_uint8.len());
193 for i in 0..self.my_vector_of_uint8.len() {
194 arr.add(i, self.my_vector_of_uint8[i] as u64);
195 }
196 inspector_node.record(arr);
197 }
198}