1use crate::lowlevel;
9use crate::highlevel;
10use crate::serde::DeserializeErrorCause;
11use crate::translate_util::*;
12use num_traits::FromPrimitive;
13
14pub fn raise_command(lowlevel: &lowlevel::Command) -> Result<highlevel::Command, DeserializeErrorCause> {
15 match lowlevel {
16 lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
17 name == "TESTEX"
18 && delimiter == &None
19 => {
20 Ok(highlevel::Command::Testex {
21 })
22 },
23 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
24 name == "TESTEXEXT"
25 && delimiter == &None
26 => {
27 Ok(highlevel::Command::Testexext {
28 })
29 },
30 lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
31 name == "TESTNEX"
32 && delimiter == &None
33 => {
34 Ok(highlevel::Command::TestCommand {
35 })
36 },
37 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
38 name == "TESTEXEXTFI"
39 && delimiter == &Some(String::from("="))
40 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
41 => {
42 let arg_vec = extract_vec_from_args(&arguments)?;
43 let field_option = arg_vec.get(0);
44 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
45 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
46 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
47 Ok(highlevel::Command::Testexextfi {
48 field,
49 })
50 },
51 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
52 name == "TESTEXEXTFIC"
53 && delimiter == &Some(String::from("="))
54 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
55 => {
56 let arg_vec = extract_vec_from_args(&arguments)?;
57 let field_option = arg_vec.get(0);
58 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
59 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
60 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
61 Ok(highlevel::Command::Testexextfic {
62 field,
63 })
64 },
65 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
66 name == "TESTNSD"
67 && delimiter == &Some(String::from(">"))
68 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
69 => {
70 let arg_vec = extract_vec_from_args(&arguments)?;
71 let field_option = arg_vec.get(0);
72 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
73 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
74 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
75 Ok(highlevel::Command::Testnsd {
76 field,
77 })
78 },
79 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
80 name == "TESTNST"
81 && delimiter == &Some(String::from("="))
82 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
83 => {
84 let arg_vec = extract_vec_from_args(&arguments)?;
85 let field_option = arg_vec.get(0);
86 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
87 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
88 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
89 Ok(highlevel::Command::Testnst {
90 field,
91 })
92 },
93 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
94 name == "TESTNSDNST"
95 && delimiter == &Some(String::from(">"))
96 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
97 => {
98 let arg_vec = extract_vec_from_args(&arguments)?;
99 let field_option = arg_vec.get(0);
100 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
101 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
102 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
103 Ok(highlevel::Command::Testnsdnst {
104 field,
105 })
106 },
107 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
108 name == "TESTNOD"
109 && delimiter == &None
110 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
111 => {
112 let arg_vec = extract_vec_from_args(&arguments)?;
113 let field_option = arg_vec.get(0);
114 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
115 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
116 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
117 Ok(highlevel::Command::Testnod {
118 field,
119 })
120 },
121 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
122 name == "TESTEXEXTFS"
123 && delimiter == &Some(String::from("="))
124 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
125 => {
126 let arg_vec = extract_vec_from_args(&arguments)?;
127 let field_option = arg_vec.get(0);
128 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
129 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
130 let field = field_option_unwrapped_primitive.clone();
131 Ok(highlevel::Command::Testexextfs {
132 field,
133 })
134 },
135 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
136 name == "TESTEXEXTFSI"
137 && delimiter == &Some(String::from("="))
138 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
139 => {
140 let arg_vec = extract_vec_from_args(&arguments)?;
141 let field1_option = arg_vec.get(0);
142 let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
143 let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
144 let field1 = field1_option_unwrapped_primitive.clone();
145 let field2_option = arg_vec.get(1);
146 let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
147 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
148 let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
149 Ok(highlevel::Command::Testexextfsi {
150 field1,
151 field2,
152 })
153 },
154 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
155 name == "TESTEXEXTFSIC"
156 && delimiter == &Some(String::from("="))
157 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
158 => {
159 let arg_vec = extract_vec_from_args(&arguments)?;
160 let field1_option = arg_vec.get(0);
161 let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
162 let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
163 let field1 = field1_option_unwrapped_primitive.clone();
164 let field2_option = arg_vec.get(1);
165 let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
166 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
167 let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
168 Ok(highlevel::Command::Testexextfsic {
169 field1,
170 field2,
171 })
172 },
173 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
174 name == "TESTIO"
175 && delimiter == &Some(String::from("="))
176 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
177 => {
178 let arg_vec = extract_vec_from_args(&arguments)?;
179 let field1_option = arg_vec.get(0);
180 let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
181 let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
182 let field1 = extract_int_from_primitive(field1_option_unwrapped_primitive, &arguments)?;
183 let field2_option = arg_vec.get(1);
184 let field2 = match field2_option {
185 Some(field2_option_unwrapped) if !field2_option_unwrapped.is_empty() => {
186 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
187 let field2_unwrapped = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
188 Some(field2_unwrapped)
189 }
190 _ => None,
191 };
192 Ok(highlevel::Command::Testio {
193 field1,
194 field2,
195 })
196 },
197 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
198 name == "TESTL"
199 && delimiter == &Some(String::from("="))
200 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
201 => {
202 let arg_vec = extract_vec_from_args(&arguments)?;
203 let mut field = Vec::new();
204 for field_element_raw in arg_vec[0..].into_iter() {
205 let field_element_option = if field_element_raw.is_empty() { None } else { Some(field_element_raw) };
206 let field_element_option_unwrapped = field_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
207 let field_element_option_unwrapped_primitive = extract_primitive_from_field(field_element_option_unwrapped, &arguments)?;
208 let field_element = extract_int_from_primitive(field_element_option_unwrapped_primitive, &arguments)?;
209 field.push(field_element);
210 }
211 Ok(highlevel::Command::Testl {
212 field,
213 })
214 },
215 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
216 name == "TESTOL"
217 && delimiter == &Some(String::from("="))
218 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
219 => {
220 let arg_vec = extract_vec_from_args(&arguments)?;
221 let mut field = Vec::new();
222 for field_element_raw in arg_vec[0..].into_iter() {
223 let field_element_option = if field_element_raw.is_empty() { None } else { Some(field_element_raw) };
224 let field_element = match field_element_option {
225 Some(field_element_option_unwrapped) if !field_element_option_unwrapped.is_empty() => {
226 let field_element_option_unwrapped_primitive = extract_primitive_from_field(field_element_option_unwrapped, &arguments)?;
227 let field_element_unwrapped = extract_int_from_primitive(field_element_option_unwrapped_primitive, &arguments)?;
228 Some(field_element_unwrapped)
229 }
230 _ => None,
231 };
232 field.push(field_element);
233 }
234 Ok(highlevel::Command::Testol {
235 field,
236 })
237 },
238 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
239 name == "TESTM"
240 && delimiter == &Some(String::from("="))
241 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
242 => {
243 let arg_vec = extract_vec_from_args(&arguments)?;
244 let mut field = std::collections::HashMap::new();
245 for field_element in arg_vec[0..].into_iter() {
246 let field_element_primitive = extract_key_from_field(field_element, &arguments)?;
247 let field_key = extract_int_from_primitive(field_element_primitive, &arguments)?;
248 let field_element_primitive = extract_value_from_field(field_element, &arguments)?;
249 let field_value = field_element_primitive.clone();
250 let _ = field.insert(field_key, field_value);
251 }
252 Ok(highlevel::Command::Testm {
253 field,
254 })
255 },
256 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
257 name == "TESTP"
258 && delimiter == &Some(String::from("="))
259 && matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
260 => {
261 let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
262 let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
263 let field_option = arg_vec.get(0);
264 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
265 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
266 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
267 Ok(highlevel::Command::Testp {
268 field,
269 })
270 },
271 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
272 name == "TESTPP"
273 && delimiter == &Some(String::from("="))
274 && matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
275 => {
276 let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
277 let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
278 let field1_option = arg_vec.get(0);
279 let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
280 let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
281 let field1 = extract_int_from_primitive(field1_option_unwrapped_primitive, &arguments)?;
282 let arg_vec = arg_vec_vec.get(1).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
283 let field2_option = arg_vec.get(0);
284 let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
285 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
286 let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
287 let field3_option = arg_vec.get(1);
288 let field3_option_unwrapped = field3_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
289 let field3_option_unwrapped_primitive = extract_primitive_from_field(field3_option_unwrapped, &arguments)?;
290 let field3 = field3_option_unwrapped_primitive.clone();
291 Ok(highlevel::Command::Testpp {
292 field1,
293 field2,
294 field3,
295 })
296 },
297 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
298 name == "TESTPMPIL"
299 && delimiter == &Some(String::from("="))
300 && matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
301 => {
302 let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
303 let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
304 let mut field1 = std::collections::HashMap::new();
305 for field1_element in arg_vec[0..].into_iter() {
306 let field1_element_primitive = extract_key_from_field(field1_element, &arguments)?;
307 let field1_key = extract_int_from_primitive(field1_element_primitive, &arguments)?;
308 let field1_element_primitive = extract_value_from_field(field1_element, &arguments)?;
309 let field1_value = field1_element_primitive.clone();
310 let _ = field1.insert(field1_key, field1_value);
311 }
312 let arg_vec = arg_vec_vec.get(1).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
313 let field2_option = arg_vec.get(0);
314 let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
315 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
316 let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
317 let mut field3 = Vec::new();
318 for field3_element_raw in arg_vec[1..].into_iter() {
319 let field3_element_option = if field3_element_raw.is_empty() { None } else { Some(field3_element_raw) };
320 let field3_element_option_unwrapped = field3_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
321 let field3_element_option_unwrapped_primitive = extract_primitive_from_field(field3_element_option_unwrapped, &arguments)?;
322 let field3_element = extract_int_from_primitive(field3_element_option_unwrapped_primitive, &arguments)?;
323 field3.push(field3_element);
324 }
325 Ok(highlevel::Command::Testpmpil {
326 field1,
327 field2,
328 field3,
329 })
330 },
331 lowlevel::Command::Read { name, is_extension: false, ..} if
332 name == "TESTR"
333 => {
334 Ok(highlevel::Command::TestrRead {})
335 },
336 lowlevel::Command::Read { name, is_extension: true, ..} if
337 name == "TESTREX"
338 => {
339 Ok(highlevel::Command::TestrexRead {})
340 },
341 lowlevel::Command::Test { name, is_extension: false, ..} if
342 name == "TESTT"
343 => {
344 Ok(highlevel::Command::TesttTest {})
345 },
346 lowlevel::Command::Test { name, is_extension: true, ..} if
347 name == "TESTTEX"
348 => {
349 Ok(highlevel::Command::TesttexTest {})
350 },
351 lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
352 name == "TESTENUM"
353 && delimiter == &Some(String::from("="))
354 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
355 => {
356 let arg_vec = extract_vec_from_args(&arguments)?;
357 let field_option = arg_vec.get(0);
358 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
359 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
360 let field_option_unwrapped_int = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
361 let field = super::types::TestOneVariantComma::from_i64(field_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
362 Ok(highlevel::Command::Testenum {
363 field,
364 })
365 },
366 lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
367 name == "TESTBOOL"
368 && delimiter == &Some(String::from("="))
369 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
370 => {
371 let arg_vec = extract_vec_from_args(&arguments)?;
372 let field_option = arg_vec.get(0);
373 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
374 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
375 let field_option_unwrapped_int = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
376 let field = field_option_unwrapped_int != 0;
377 Ok(highlevel::Command::Testbool {
378 field,
379 })
380 },
381 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
382 name == "TESTOTHERFILE"
383 && delimiter == &None
384 => {
385 Ok(highlevel::Command::Testotherfile {
386 })
387 },
388 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
389 name == "BRSF"
390 && delimiter == &Some(String::from("="))
391 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
392 => {
393 let arg_vec = extract_vec_from_args(&arguments)?;
394 let features_option = arg_vec.get(0);
395 let features_option_unwrapped = features_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
396 let features_option_unwrapped_primitive = extract_primitive_from_field(features_option_unwrapped, &arguments)?;
397 let features = extract_int_from_primitive(features_option_unwrapped_primitive, &arguments)?;
398 Ok(highlevel::Command::Brsf {
399 features,
400 })
401 },
402 lowlevel::Command::Test { name, is_extension: true, ..} if
403 name == "CIND"
404 => {
405 Ok(highlevel::Command::CindTest {})
406 },
407 lowlevel::Command::Read { name, is_extension: true, ..} if
408 name == "CIND"
409 => {
410 Ok(highlevel::Command::CindRead {})
411 },
412 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
413 name == "CLCC"
414 && delimiter == &None
415 => {
416 Ok(highlevel::Command::Clcc {
417 })
418 },
419 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
420 name == "BCC"
421 && delimiter == &None
422 => {
423 Ok(highlevel::Command::Bcc {
424 })
425 },
426 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
427 name == "BCS"
428 && delimiter == &Some(String::from("="))
429 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
430 => {
431 let arg_vec = extract_vec_from_args(&arguments)?;
432 let codec_option = arg_vec.get(0);
433 let codec_option_unwrapped = codec_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
434 let codec_option_unwrapped_primitive = extract_primitive_from_field(codec_option_unwrapped, &arguments)?;
435 let codec = extract_int_from_primitive(codec_option_unwrapped_primitive, &arguments)?;
436 Ok(highlevel::Command::Bcs {
437 codec,
438 })
439 },
440 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
441 name == "BAC"
442 && delimiter == &Some(String::from("="))
443 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
444 => {
445 let arg_vec = extract_vec_from_args(&arguments)?;
446 let mut codecs = Vec::new();
447 for codecs_element_raw in arg_vec[0..].into_iter() {
448 let codecs_element_option = if codecs_element_raw.is_empty() { None } else { Some(codecs_element_raw) };
449 let codecs_element_option_unwrapped = codecs_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
450 let codecs_element_option_unwrapped_primitive = extract_primitive_from_field(codecs_element_option_unwrapped, &arguments)?;
451 let codecs_element = extract_int_from_primitive(codecs_element_option_unwrapped_primitive, &arguments)?;
452 codecs.push(codecs_element);
453 }
454 Ok(highlevel::Command::Bac {
455 codecs,
456 })
457 },
458 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
459 name == "BIND"
460 && delimiter == &Some(String::from("="))
461 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
462 => {
463 let arg_vec = extract_vec_from_args(&arguments)?;
464 let mut indicators = Vec::new();
465 for indicators_element_raw in arg_vec[0..].into_iter() {
466 let indicators_element_option = if indicators_element_raw.is_empty() { None } else { Some(indicators_element_raw) };
467 let indicators_element_option_unwrapped = indicators_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
468 let indicators_element_option_unwrapped_primitive = extract_primitive_from_field(indicators_element_option_unwrapped, &arguments)?;
469 let indicators_element = extract_int_from_primitive(indicators_element_option_unwrapped_primitive, &arguments)?;
470 indicators.push(indicators_element);
471 }
472 Ok(highlevel::Command::Bind {
473 indicators,
474 })
475 },
476 lowlevel::Command::Test { name, is_extension: true, ..} if
477 name == "BIND"
478 => {
479 Ok(highlevel::Command::BindTest {})
480 },
481 lowlevel::Command::Read { name, is_extension: true, ..} if
482 name == "BIND"
483 => {
484 Ok(highlevel::Command::BindRead {})
485 },
486 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
487 name == "BIEV"
488 && delimiter == &Some(String::from("="))
489 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
490 => {
491 let arg_vec = extract_vec_from_args(&arguments)?;
492 let anum_option = arg_vec.get(0);
493 let anum_option_unwrapped = anum_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
494 let anum_option_unwrapped_primitive = extract_primitive_from_field(anum_option_unwrapped, &arguments)?;
495 let anum_option_unwrapped_int = extract_int_from_primitive(anum_option_unwrapped_primitive, &arguments)?;
496 let anum = super::types::BluetoothHFIndicator::from_i64(anum_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
497 let value_option = arg_vec.get(1);
498 let value_option_unwrapped = value_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
499 let value_option_unwrapped_primitive = extract_primitive_from_field(value_option_unwrapped, &arguments)?;
500 let value = extract_int_from_primitive(value_option_unwrapped_primitive, &arguments)?;
501 Ok(highlevel::Command::Biev {
502 anum,
503 value,
504 })
505 },
506 lowlevel::Command::Test { name, is_extension: true, ..} if
507 name == "CHLD"
508 => {
509 Ok(highlevel::Command::ChldTest {})
510 },
511 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
512 name == "CMER"
513 && delimiter == &Some(String::from("="))
514 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
515 => {
516 let arg_vec = extract_vec_from_args(&arguments)?;
517 let mode_option = arg_vec.get(0);
518 let mode_option_unwrapped = mode_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
519 let mode_option_unwrapped_primitive = extract_primitive_from_field(mode_option_unwrapped, &arguments)?;
520 let mode = extract_int_from_primitive(mode_option_unwrapped_primitive, &arguments)?;
521 let keyp_option = arg_vec.get(1);
522 let keyp_option_unwrapped = keyp_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
523 let keyp_option_unwrapped_primitive = extract_primitive_from_field(keyp_option_unwrapped, &arguments)?;
524 let keyp = extract_int_from_primitive(keyp_option_unwrapped_primitive, &arguments)?;
525 let disp_option = arg_vec.get(2);
526 let disp_option_unwrapped = disp_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
527 let disp_option_unwrapped_primitive = extract_primitive_from_field(disp_option_unwrapped, &arguments)?;
528 let disp = extract_int_from_primitive(disp_option_unwrapped_primitive, &arguments)?;
529 let ind_option = arg_vec.get(3);
530 let ind_option_unwrapped = ind_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
531 let ind_option_unwrapped_primitive = extract_primitive_from_field(ind_option_unwrapped, &arguments)?;
532 let ind = extract_int_from_primitive(ind_option_unwrapped_primitive, &arguments)?;
533 Ok(highlevel::Command::Cmer {
534 mode,
535 keyp,
536 disp,
537 ind,
538 })
539 },
540 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
541 name == "NREC"
542 && delimiter == &Some(String::from("="))
543 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
544 => {
545 let arg_vec = extract_vec_from_args(&arguments)?;
546 let nrec_option = arg_vec.get(0);
547 let nrec_option_unwrapped = nrec_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
548 let nrec_option_unwrapped_primitive = extract_primitive_from_field(nrec_option_unwrapped, &arguments)?;
549 let nrec_option_unwrapped_int = extract_int_from_primitive(nrec_option_unwrapped_primitive, &arguments)?;
550 let nrec = nrec_option_unwrapped_int != 0;
551 Ok(highlevel::Command::Nrec {
552 nrec,
553 })
554 },
555 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
556 name == "COPS"
557 && delimiter == &Some(String::from("="))
558 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
559 => {
560 let arg_vec = extract_vec_from_args(&arguments)?;
561 let three_option = arg_vec.get(0);
562 let three_option_unwrapped = three_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
563 let three_option_unwrapped_primitive = extract_primitive_from_field(three_option_unwrapped, &arguments)?;
564 let three = extract_int_from_primitive(three_option_unwrapped_primitive, &arguments)?;
565 let format_option = arg_vec.get(1);
566 let format_option_unwrapped = format_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
567 let format_option_unwrapped_primitive = extract_primitive_from_field(format_option_unwrapped, &arguments)?;
568 let format_option_unwrapped_int = extract_int_from_primitive(format_option_unwrapped_primitive, &arguments)?;
569 let format = super::types::NetworkOperatorNameFormat::from_i64(format_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
570 Ok(highlevel::Command::Cops {
571 three,
572 format,
573 })
574 },
575 lowlevel::Command::Read { name, is_extension: true, ..} if
576 name == "COPS"
577 => {
578 Ok(highlevel::Command::CopsRead {})
579 },
580 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
581 name == "CMEE"
582 && delimiter == &Some(String::from("="))
583 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
584 => {
585 let arg_vec = extract_vec_from_args(&arguments)?;
586 let enable_option = arg_vec.get(0);
587 let enable_option_unwrapped = enable_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
588 let enable_option_unwrapped_primitive = extract_primitive_from_field(enable_option_unwrapped, &arguments)?;
589 let enable_option_unwrapped_int = extract_int_from_primitive(enable_option_unwrapped_primitive, &arguments)?;
590 let enable = enable_option_unwrapped_int != 0;
591 Ok(highlevel::Command::Cmee {
592 enable,
593 })
594 },
595 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
596 name == "CCWA"
597 && delimiter == &Some(String::from("="))
598 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
599 => {
600 let arg_vec = extract_vec_from_args(&arguments)?;
601 let enable_option = arg_vec.get(0);
602 let enable_option_unwrapped = enable_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
603 let enable_option_unwrapped_primitive = extract_primitive_from_field(enable_option_unwrapped, &arguments)?;
604 let enable_option_unwrapped_int = extract_int_from_primitive(enable_option_unwrapped_primitive, &arguments)?;
605 let enable = enable_option_unwrapped_int != 0;
606 Ok(highlevel::Command::Ccwa {
607 enable,
608 })
609 },
610 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
611 name == "CLIP"
612 && delimiter == &Some(String::from("="))
613 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
614 => {
615 let arg_vec = extract_vec_from_args(&arguments)?;
616 let enable_option = arg_vec.get(0);
617 let enable_option_unwrapped = enable_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
618 let enable_option_unwrapped_primitive = extract_primitive_from_field(enable_option_unwrapped, &arguments)?;
619 let enable_option_unwrapped_int = extract_int_from_primitive(enable_option_unwrapped_primitive, &arguments)?;
620 let enable = enable_option_unwrapped_int != 0;
621 Ok(highlevel::Command::Clip {
622 enable,
623 })
624 },
625 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
626 name == "CNUM"
627 && delimiter == &None
628 => {
629 Ok(highlevel::Command::Cnum {
630 })
631 },
632 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
633 name == "VTS"
634 && delimiter == &Some(String::from("="))
635 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
636 => {
637 let arg_vec = extract_vec_from_args(&arguments)?;
638 let code_option = arg_vec.get(0);
639 let code_option_unwrapped = code_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
640 let code_option_unwrapped_primitive = extract_primitive_from_field(code_option_unwrapped, &arguments)?;
641 let code = code_option_unwrapped_primitive.clone();
642 Ok(highlevel::Command::Vts {
643 code,
644 })
645 },
646 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
647 name == "VGS"
648 && delimiter == &Some(String::from("="))
649 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
650 => {
651 let arg_vec = extract_vec_from_args(&arguments)?;
652 let level_option = arg_vec.get(0);
653 let level_option_unwrapped = level_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
654 let level_option_unwrapped_primitive = extract_primitive_from_field(level_option_unwrapped, &arguments)?;
655 let level = extract_int_from_primitive(level_option_unwrapped_primitive, &arguments)?;
656 Ok(highlevel::Command::Vgs {
657 level,
658 })
659 },
660 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
661 name == "VGM"
662 && delimiter == &Some(String::from("="))
663 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
664 => {
665 let arg_vec = extract_vec_from_args(&arguments)?;
666 let level_option = arg_vec.get(0);
667 let level_option_unwrapped = level_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
668 let level_option_unwrapped_primitive = extract_primitive_from_field(level_option_unwrapped, &arguments)?;
669 let level = extract_int_from_primitive(level_option_unwrapped_primitive, &arguments)?;
670 Ok(highlevel::Command::Vgm {
671 level,
672 })
673 },
674 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
675 name == "BIA"
676 && delimiter == &Some(String::from("="))
677 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
678 => {
679 let arg_vec = extract_vec_from_args(&arguments)?;
680 let mut indrep = Vec::new();
681 for indrep_element_raw in arg_vec[0..].into_iter() {
682 let indrep_element_option = if indrep_element_raw.is_empty() { None } else { Some(indrep_element_raw) };
683 let indrep_element = match indrep_element_option {
684 Some(indrep_element_option_unwrapped) if !indrep_element_option_unwrapped.is_empty() => {
685 let indrep_element_option_unwrapped_primitive = extract_primitive_from_field(indrep_element_option_unwrapped, &arguments)?;
686 let indrep_element_option_unwrapped_int = extract_int_from_primitive(indrep_element_option_unwrapped_primitive, &arguments)?;
687 let indrep_element_unwrapped = indrep_element_option_unwrapped_int != 0;
688 Some(indrep_element_unwrapped)
689 }
690 _ => None,
691 };
692 indrep.push(indrep_element);
693 }
694 Ok(highlevel::Command::Bia {
695 indrep,
696 })
697 },
698 lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
699 name == "A"
700 && delimiter == &None
701 => {
702 Ok(highlevel::Command::Answer {
703 })
704 },
705 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
706 name == "CHUP"
707 && delimiter == &None
708 => {
709 Ok(highlevel::Command::Chup {
710 })
711 },
712 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
713 name == "CHLD"
714 && delimiter == &Some(String::from("="))
715 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
716 => {
717 let arg_vec = extract_vec_from_args(&arguments)?;
718 let command_option = arg_vec.get(0);
719 let command_option_unwrapped = command_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
720 let command_option_unwrapped_primitive = extract_primitive_from_field(command_option_unwrapped, &arguments)?;
721 let command = command_option_unwrapped_primitive.clone();
722 Ok(highlevel::Command::Chld {
723 command,
724 })
725 },
726 lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
727 name == "D"
728 && delimiter == &None
729 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
730 => {
731 let arg_vec = extract_vec_from_args(&arguments)?;
732 let number_option = arg_vec.get(0);
733 let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
734 let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
735 let number = number_option_unwrapped_primitive.clone();
736 Ok(highlevel::Command::AtdNumber {
737 number,
738 })
739 },
740 lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
741 name == "D"
742 && delimiter == &Some(String::from(">"))
743 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
744 => {
745 let arg_vec = extract_vec_from_args(&arguments)?;
746 let location_option = arg_vec.get(0);
747 let location_option_unwrapped = location_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
748 let location_option_unwrapped_primitive = extract_primitive_from_field(location_option_unwrapped, &arguments)?;
749 let location = location_option_unwrapped_primitive.clone();
750 Ok(highlevel::Command::AtdMemory {
751 location,
752 })
753 },
754 lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
755 name == "BLDN"
756 && delimiter == &None
757 => {
758 Ok(highlevel::Command::Bldn {
759 })
760 },
761 _ => Err(DeserializeErrorCause::UnknownCommand(lowlevel.clone())),
762 }
763}
764
765pub fn raise_success(lowlevel: &lowlevel::Response) -> Result<highlevel::Success, DeserializeErrorCause> {
767 match lowlevel {
768 lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
769 name == "TEST"
770 && delimiter == &Some(String::from(":"))
771 => {
772 Ok(highlevel::Success::Test {
773 })
774 },
775 lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
776 name == "TESTNOD"
777 && delimiter == &None
778 => {
779 Ok(highlevel::Success::Testnod {
780 })
781 },
782 lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
783 name == "TESTN"
784 && delimiter == &Some(String::from(":"))
785 => {
786 Ok(highlevel::Success::TestResponse {
787 })
788 },
789 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
790 name == "TESTEXT"
791 && delimiter == &Some(String::from(":"))
792 => {
793 Ok(highlevel::Success::Testext {
794 })
795 },
796 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
797 name == "TESTEXTNOD"
798 && delimiter == &None
799 => {
800 Ok(highlevel::Success::Testextnod {
801 })
802 },
803 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
804 name == "TESTI"
805 && delimiter == &Some(String::from(":"))
806 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
807 => {
808 let arg_vec = extract_vec_from_args(&arguments)?;
809 let field_option = arg_vec.get(0);
810 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
811 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
812 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
813 Ok(highlevel::Success::Testi {
814 field,
815 })
816 },
817 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
818 name == "TESTINOD"
819 && delimiter == &None
820 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
821 => {
822 let arg_vec = extract_vec_from_args(&arguments)?;
823 let field_option = arg_vec.get(0);
824 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
825 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
826 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
827 Ok(highlevel::Success::Testinod {
828 field,
829 })
830 },
831 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
832 name == "TESTIC"
833 && delimiter == &Some(String::from(":"))
834 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
835 => {
836 let arg_vec = extract_vec_from_args(&arguments)?;
837 let field_option = arg_vec.get(0);
838 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
839 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
840 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
841 Ok(highlevel::Success::Testic {
842 field,
843 })
844 },
845 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
846 name == "TESTS"
847 && delimiter == &Some(String::from(":"))
848 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
849 => {
850 let arg_vec = extract_vec_from_args(&arguments)?;
851 let field_option = arg_vec.get(0);
852 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
853 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
854 let field = field_option_unwrapped_primitive.clone();
855 Ok(highlevel::Success::Tests {
856 field,
857 })
858 },
859 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
860 name == "TESTSI"
861 && delimiter == &Some(String::from(":"))
862 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
863 => {
864 let arg_vec = extract_vec_from_args(&arguments)?;
865 let field1_option = arg_vec.get(0);
866 let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
867 let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
868 let field1 = field1_option_unwrapped_primitive.clone();
869 let field2_option = arg_vec.get(1);
870 let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
871 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
872 let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
873 Ok(highlevel::Success::Testsi {
874 field1,
875 field2,
876 })
877 },
878 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
879 name == "TESTSIC"
880 && delimiter == &Some(String::from(":"))
881 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
882 => {
883 let arg_vec = extract_vec_from_args(&arguments)?;
884 let field1_option = arg_vec.get(0);
885 let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
886 let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
887 let field1 = field1_option_unwrapped_primitive.clone();
888 let field2_option = arg_vec.get(1);
889 let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
890 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
891 let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
892 Ok(highlevel::Success::Testsic {
893 field1,
894 field2,
895 })
896 },
897 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
898 name == "TESTIO"
899 && delimiter == &Some(String::from(":"))
900 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
901 => {
902 let arg_vec = extract_vec_from_args(&arguments)?;
903 let field1_option = arg_vec.get(0);
904 let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
905 let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
906 let field1 = extract_int_from_primitive(field1_option_unwrapped_primitive, &arguments)?;
907 let field2_option = arg_vec.get(1);
908 let field2 = match field2_option {
909 Some(field2_option_unwrapped) if !field2_option_unwrapped.is_empty() => {
910 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
911 let field2_unwrapped = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
912 Some(field2_unwrapped)
913 }
914 _ => None,
915 };
916 Ok(highlevel::Success::Testio {
917 field1,
918 field2,
919 })
920 },
921 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
922 name == "TESTL"
923 && delimiter == &Some(String::from(":"))
924 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
925 => {
926 let arg_vec = extract_vec_from_args(&arguments)?;
927 let mut field = Vec::new();
928 for field_element_raw in arg_vec[0..].into_iter() {
929 let field_element_option = if field_element_raw.is_empty() { None } else { Some(field_element_raw) };
930 let field_element_option_unwrapped = field_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
931 let field_element_option_unwrapped_primitive = extract_primitive_from_field(field_element_option_unwrapped, &arguments)?;
932 let field_element = extract_int_from_primitive(field_element_option_unwrapped_primitive, &arguments)?;
933 field.push(field_element);
934 }
935 Ok(highlevel::Success::Testl {
936 field,
937 })
938 },
939 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
940 name == "TESTOL"
941 && delimiter == &Some(String::from(":"))
942 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
943 => {
944 let arg_vec = extract_vec_from_args(&arguments)?;
945 let mut field = Vec::new();
946 for field_element_raw in arg_vec[0..].into_iter() {
947 let field_element_option = if field_element_raw.is_empty() { None } else { Some(field_element_raw) };
948 let field_element = match field_element_option {
949 Some(field_element_option_unwrapped) if !field_element_option_unwrapped.is_empty() => {
950 let field_element_option_unwrapped_primitive = extract_primitive_from_field(field_element_option_unwrapped, &arguments)?;
951 let field_element_unwrapped = extract_int_from_primitive(field_element_option_unwrapped_primitive, &arguments)?;
952 Some(field_element_unwrapped)
953 }
954 _ => None,
955 };
956 field.push(field_element);
957 }
958 Ok(highlevel::Success::Testol {
959 field,
960 })
961 },
962 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
963 name == "TESTM"
964 && delimiter == &Some(String::from(":"))
965 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
966 => {
967 let arg_vec = extract_vec_from_args(&arguments)?;
968 let mut field = std::collections::HashMap::new();
969 for field_element in arg_vec[0..].into_iter() {
970 let field_element_primitive = extract_key_from_field(field_element, &arguments)?;
971 let field_key = extract_int_from_primitive(field_element_primitive, &arguments)?;
972 let field_element_primitive = extract_value_from_field(field_element, &arguments)?;
973 let field_value = field_element_primitive.clone();
974 let _ = field.insert(field_key, field_value);
975 }
976 Ok(highlevel::Success::Testm {
977 field,
978 })
979 },
980 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
981 name == "TESTP"
982 && delimiter == &Some(String::from(":"))
983 && matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
984 => {
985 let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
986 let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
987 let field_option = arg_vec.get(0);
988 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
989 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
990 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
991 Ok(highlevel::Success::Testp {
992 field,
993 })
994 },
995 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
996 name == "TESTPP"
997 && delimiter == &Some(String::from(":"))
998 && matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
999 => {
1000 let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1001 let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1002 let field1_option = arg_vec.get(0);
1003 let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1004 let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
1005 let field1 = extract_int_from_primitive(field1_option_unwrapped_primitive, &arguments)?;
1006 let arg_vec = arg_vec_vec.get(1).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1007 let field2_option = arg_vec.get(0);
1008 let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1009 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
1010 let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
1011 let field3_option = arg_vec.get(1);
1012 let field3_option_unwrapped = field3_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1013 let field3_option_unwrapped_primitive = extract_primitive_from_field(field3_option_unwrapped, &arguments)?;
1014 let field3 = field3_option_unwrapped_primitive.clone();
1015 Ok(highlevel::Success::Testpp {
1016 field1,
1017 field2,
1018 field3,
1019 })
1020 },
1021 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1022 name == "TESTPMPIL"
1023 && delimiter == &Some(String::from(":"))
1024 && matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
1025 => {
1026 let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1027 let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1028 let mut field1 = std::collections::HashMap::new();
1029 for field1_element in arg_vec[0..].into_iter() {
1030 let field1_element_primitive = extract_key_from_field(field1_element, &arguments)?;
1031 let field1_key = extract_int_from_primitive(field1_element_primitive, &arguments)?;
1032 let field1_element_primitive = extract_value_from_field(field1_element, &arguments)?;
1033 let field1_value = field1_element_primitive.clone();
1034 let _ = field1.insert(field1_key, field1_value);
1035 }
1036 let arg_vec = arg_vec_vec.get(1).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1037 let field2_option = arg_vec.get(0);
1038 let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1039 let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
1040 let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
1041 let mut field3 = Vec::new();
1042 for field3_element_raw in arg_vec[1..].into_iter() {
1043 let field3_element_option = if field3_element_raw.is_empty() { None } else { Some(field3_element_raw) };
1044 let field3_element_option_unwrapped = field3_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1045 let field3_element_option_unwrapped_primitive = extract_primitive_from_field(field3_element_option_unwrapped, &arguments)?;
1046 let field3_element = extract_int_from_primitive(field3_element_option_unwrapped_primitive, &arguments)?;
1047 field3.push(field3_element);
1048 }
1049 Ok(highlevel::Success::Testpmpil {
1050 field1,
1051 field2,
1052 field3,
1053 })
1054 },
1055 lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1056 name == "SAME"
1057 && delimiter == &Some(String::from(":"))
1058 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1059 => {
1060 let arg_vec = extract_vec_from_args(&arguments)?;
1061 let field_option = arg_vec.get(0);
1062 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1063 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
1064 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
1065 Ok(highlevel::Success::SameOne {
1066 field,
1067 })
1068 },
1069 lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1070 name == "SAME"
1071 && delimiter == &Some(String::from(":"))
1072 && matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
1073 => {
1074 let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1075 let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1076 let field_option = arg_vec.get(0);
1077 let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1078 let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
1079 let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
1080 Ok(highlevel::Success::SameTwo {
1081 field,
1082 })
1083 },
1084 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1085 name == "BRSF"
1086 && delimiter == &Some(String::from(":"))
1087 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1088 => {
1089 let arg_vec = extract_vec_from_args(&arguments)?;
1090 let features_option = arg_vec.get(0);
1091 let features_option_unwrapped = features_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1092 let features_option_unwrapped_primitive = extract_primitive_from_field(features_option_unwrapped, &arguments)?;
1093 let features = extract_int_from_primitive(features_option_unwrapped_primitive, &arguments)?;
1094 Ok(highlevel::Success::Brsf {
1095 features,
1096 })
1097 },
1098 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1099 name == "CIND"
1100 && delimiter == &Some(String::from(":"))
1101 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1102 => {
1103 let arg_vec = extract_vec_from_args(&arguments)?;
1104 let mut ordered_values = Vec::new();
1105 for ordered_values_element_raw in arg_vec[0..].into_iter() {
1106 let ordered_values_element_option = if ordered_values_element_raw.is_empty() { None } else { Some(ordered_values_element_raw) };
1107 let ordered_values_element_option_unwrapped = ordered_values_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1108 let ordered_values_element_option_unwrapped_primitive = extract_primitive_from_field(ordered_values_element_option_unwrapped, &arguments)?;
1109 let ordered_values_element = extract_int_from_primitive(ordered_values_element_option_unwrapped_primitive, &arguments)?;
1110 ordered_values.push(ordered_values_element);
1111 }
1112 Ok(highlevel::Success::CindRead {
1113 ordered_values,
1114 })
1115 },
1116 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1117 name == "CLCC"
1118 && delimiter == &Some(String::from(":"))
1119 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1120 => {
1121 let arg_vec = extract_vec_from_args(&arguments)?;
1122 let index_option = arg_vec.get(0);
1123 let index_option_unwrapped = index_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1124 let index_option_unwrapped_primitive = extract_primitive_from_field(index_option_unwrapped, &arguments)?;
1125 let index = extract_int_from_primitive(index_option_unwrapped_primitive, &arguments)?;
1126 let dir_option = arg_vec.get(1);
1127 let dir_option_unwrapped = dir_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1128 let dir_option_unwrapped_primitive = extract_primitive_from_field(dir_option_unwrapped, &arguments)?;
1129 let dir = extract_int_from_primitive(dir_option_unwrapped_primitive, &arguments)?;
1130 let status_option = arg_vec.get(2);
1131 let status_option_unwrapped = status_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1132 let status_option_unwrapped_primitive = extract_primitive_from_field(status_option_unwrapped, &arguments)?;
1133 let status = extract_int_from_primitive(status_option_unwrapped_primitive, &arguments)?;
1134 let mode_option = arg_vec.get(3);
1135 let mode_option_unwrapped = mode_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1136 let mode_option_unwrapped_primitive = extract_primitive_from_field(mode_option_unwrapped, &arguments)?;
1137 let mode = extract_int_from_primitive(mode_option_unwrapped_primitive, &arguments)?;
1138 let mpty_option = arg_vec.get(4);
1139 let mpty_option_unwrapped = mpty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1140 let mpty_option_unwrapped_primitive = extract_primitive_from_field(mpty_option_unwrapped, &arguments)?;
1141 let mpty = extract_int_from_primitive(mpty_option_unwrapped_primitive, &arguments)?;
1142 let number_option = arg_vec.get(5);
1143 let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1144 let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
1145 let number = number_option_unwrapped_primitive.clone();
1146 let ty_option = arg_vec.get(6);
1147 let ty_option_unwrapped = ty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1148 let ty_option_unwrapped_primitive = extract_primitive_from_field(ty_option_unwrapped, &arguments)?;
1149 let ty = extract_int_from_primitive(ty_option_unwrapped_primitive, &arguments)?;
1150 Ok(highlevel::Success::Clcc {
1151 index,
1152 dir,
1153 status,
1154 mode,
1155 mpty,
1156 number,
1157 ty,
1158 })
1159 },
1160 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1161 name == "BCS"
1162 && delimiter == &Some(String::from(":"))
1163 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1164 => {
1165 let arg_vec = extract_vec_from_args(&arguments)?;
1166 let codec_option = arg_vec.get(0);
1167 let codec_option_unwrapped = codec_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1168 let codec_option_unwrapped_primitive = extract_primitive_from_field(codec_option_unwrapped, &arguments)?;
1169 let codec = extract_int_from_primitive(codec_option_unwrapped_primitive, &arguments)?;
1170 Ok(highlevel::Success::Bcs {
1171 codec,
1172 })
1173 },
1174 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1175 name == "BIND"
1176 && delimiter == &Some(String::from(":"))
1177 && matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
1178 => {
1179 let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1180 let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1181 let mut indicators = Vec::new();
1182 for indicators_element_raw in arg_vec[0..].into_iter() {
1183 let indicators_element_option = if indicators_element_raw.is_empty() { None } else { Some(indicators_element_raw) };
1184 let indicators_element_option_unwrapped = indicators_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1185 let indicators_element_option_unwrapped_primitive = extract_primitive_from_field(indicators_element_option_unwrapped, &arguments)?;
1186 let indicators_element_option_unwrapped_int = extract_int_from_primitive(indicators_element_option_unwrapped_primitive, &arguments)?;
1187 let indicators_element = super::types::BluetoothHFIndicator::from_i64(indicators_element_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1188 indicators.push(indicators_element);
1189 }
1190 Ok(highlevel::Success::BindList {
1191 indicators,
1192 })
1193 },
1194 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1195 name == "BIND"
1196 && delimiter == &Some(String::from(":"))
1197 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1198 => {
1199 let arg_vec = extract_vec_from_args(&arguments)?;
1200 let anum_option = arg_vec.get(0);
1201 let anum_option_unwrapped = anum_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1202 let anum_option_unwrapped_primitive = extract_primitive_from_field(anum_option_unwrapped, &arguments)?;
1203 let anum_option_unwrapped_int = extract_int_from_primitive(anum_option_unwrapped_primitive, &arguments)?;
1204 let anum = super::types::BluetoothHFIndicator::from_i64(anum_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1205 let state_option = arg_vec.get(1);
1206 let state_option_unwrapped = state_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1207 let state_option_unwrapped_primitive = extract_primitive_from_field(state_option_unwrapped, &arguments)?;
1208 let state_option_unwrapped_int = extract_int_from_primitive(state_option_unwrapped_primitive, &arguments)?;
1209 let state = state_option_unwrapped_int != 0;
1210 Ok(highlevel::Success::BindStatus {
1211 anum,
1212 state,
1213 })
1214 },
1215 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1216 name == "CHLD"
1217 && delimiter == &Some(String::from(":"))
1218 && matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
1219 => {
1220 let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1221 let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1222 let mut commands = Vec::new();
1223 for commands_element_raw in arg_vec[0..].into_iter() {
1224 let commands_element_option = if commands_element_raw.is_empty() { None } else { Some(commands_element_raw) };
1225 let commands_element_option_unwrapped = commands_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1226 let commands_element_option_unwrapped_primitive = extract_primitive_from_field(commands_element_option_unwrapped, &arguments)?;
1227 let commands_element = commands_element_option_unwrapped_primitive.clone();
1228 commands.push(commands_element);
1229 }
1230 Ok(highlevel::Success::Chld {
1231 commands,
1232 })
1233 },
1234 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1235 name == "COPS"
1236 && delimiter == &Some(String::from(":"))
1237 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1238 => {
1239 let arg_vec = extract_vec_from_args(&arguments)?;
1240 let format_option = arg_vec.get(0);
1241 let format_option_unwrapped = format_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1242 let format_option_unwrapped_primitive = extract_primitive_from_field(format_option_unwrapped, &arguments)?;
1243 let format_option_unwrapped_int = extract_int_from_primitive(format_option_unwrapped_primitive, &arguments)?;
1244 let format = super::types::NetworkOperatorNameFormat::from_i64(format_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1245 let zero_option = arg_vec.get(1);
1246 let zero_option_unwrapped = zero_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1247 let zero_option_unwrapped_primitive = extract_primitive_from_field(zero_option_unwrapped, &arguments)?;
1248 let zero = extract_int_from_primitive(zero_option_unwrapped_primitive, &arguments)?;
1249 let operator_option = arg_vec.get(2);
1250 let operator_option_unwrapped = operator_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1251 let operator_option_unwrapped_primitive = extract_primitive_from_field(operator_option_unwrapped, &arguments)?;
1252 let operator = operator_option_unwrapped_primitive.clone();
1253 Ok(highlevel::Success::Cops {
1254 format,
1255 zero,
1256 operator,
1257 })
1258 },
1259 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1260 name == "CLIP"
1261 && delimiter == &Some(String::from(":"))
1262 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1263 => {
1264 let arg_vec = extract_vec_from_args(&arguments)?;
1265 let number_option = arg_vec.get(0);
1266 let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1267 let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
1268 let number = number_option_unwrapped_primitive.clone();
1269 let ty_option = arg_vec.get(1);
1270 let ty_option_unwrapped = ty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1271 let ty_option_unwrapped_primitive = extract_primitive_from_field(ty_option_unwrapped, &arguments)?;
1272 let ty = extract_int_from_primitive(ty_option_unwrapped_primitive, &arguments)?;
1273 Ok(highlevel::Success::Clip {
1274 number,
1275 ty,
1276 })
1277 },
1278 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1279 name == "CNUM"
1280 && delimiter == &Some(String::from(":"))
1281 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1282 => {
1283 let arg_vec = extract_vec_from_args(&arguments)?;
1284 let alpha_option = arg_vec.get(0);
1285 let alpha_option_unwrapped = alpha_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1286 let alpha_option_unwrapped_primitive = extract_primitive_from_field(alpha_option_unwrapped, &arguments)?;
1287 let alpha = alpha_option_unwrapped_primitive.clone();
1288 let number_option = arg_vec.get(1);
1289 let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1290 let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
1291 let number = number_option_unwrapped_primitive.clone();
1292 let ty_option = arg_vec.get(2);
1293 let ty_option_unwrapped = ty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1294 let ty_option_unwrapped_primitive = extract_primitive_from_field(ty_option_unwrapped, &arguments)?;
1295 let ty = extract_int_from_primitive(ty_option_unwrapped_primitive, &arguments)?;
1296 let speed_option = arg_vec.get(3);
1297 let speed_option_unwrapped = speed_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1298 let speed_option_unwrapped_primitive = extract_primitive_from_field(speed_option_unwrapped, &arguments)?;
1299 let speed = speed_option_unwrapped_primitive.clone();
1300 let service_option = arg_vec.get(4);
1301 let service_option_unwrapped = service_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1302 let service_option_unwrapped_primitive = extract_primitive_from_field(service_option_unwrapped, &arguments)?;
1303 let service = extract_int_from_primitive(service_option_unwrapped_primitive, &arguments)?;
1304 Ok(highlevel::Success::Cnum {
1305 alpha,
1306 number,
1307 ty,
1308 speed,
1309 service,
1310 })
1311 },
1312 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1313 name == "VGS"
1314 && delimiter == &Some(String::from(":"))
1315 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1316 => {
1317 let arg_vec = extract_vec_from_args(&arguments)?;
1318 let level_option = arg_vec.get(0);
1319 let level_option_unwrapped = level_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1320 let level_option_unwrapped_primitive = extract_primitive_from_field(level_option_unwrapped, &arguments)?;
1321 let level = extract_int_from_primitive(level_option_unwrapped_primitive, &arguments)?;
1322 Ok(highlevel::Success::Vgs {
1323 level,
1324 })
1325 },
1326 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1327 name == "VGM"
1328 && delimiter == &Some(String::from(":"))
1329 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1330 => {
1331 let arg_vec = extract_vec_from_args(&arguments)?;
1332 let level_option = arg_vec.get(0);
1333 let level_option_unwrapped = level_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1334 let level_option_unwrapped_primitive = extract_primitive_from_field(level_option_unwrapped, &arguments)?;
1335 let level = extract_int_from_primitive(level_option_unwrapped_primitive, &arguments)?;
1336 Ok(highlevel::Success::Vgm {
1337 level,
1338 })
1339 },
1340 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1341 name == "CIEV"
1342 && delimiter == &Some(String::from(":"))
1343 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1344 => {
1345 let arg_vec = extract_vec_from_args(&arguments)?;
1346 let ind_option = arg_vec.get(0);
1347 let ind_option_unwrapped = ind_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1348 let ind_option_unwrapped_primitive = extract_primitive_from_field(ind_option_unwrapped, &arguments)?;
1349 let ind = extract_int_from_primitive(ind_option_unwrapped_primitive, &arguments)?;
1350 let value_option = arg_vec.get(1);
1351 let value_option_unwrapped = value_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1352 let value_option_unwrapped_primitive = extract_primitive_from_field(value_option_unwrapped, &arguments)?;
1353 let value = extract_int_from_primitive(value_option_unwrapped_primitive, &arguments)?;
1354 Ok(highlevel::Success::Ciev {
1355 ind,
1356 value,
1357 })
1358 },
1359 lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1360 name == "CCWA"
1361 && delimiter == &Some(String::from(":"))
1362 && matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1363 => {
1364 let arg_vec = extract_vec_from_args(&arguments)?;
1365 let number_option = arg_vec.get(0);
1366 let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1367 let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
1368 let number = number_option_unwrapped_primitive.clone();
1369 let ty_option = arg_vec.get(1);
1370 let ty_option_unwrapped = ty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1371 let ty_option_unwrapped_primitive = extract_primitive_from_field(ty_option_unwrapped, &arguments)?;
1372 let ty = extract_int_from_primitive(ty_option_unwrapped_primitive, &arguments)?;
1373 Ok(highlevel::Success::Ccwa {
1374 number,
1375 ty,
1376 })
1377 },
1378 lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
1379 name == "RING"
1380 && delimiter == &None
1381 => {
1382 Ok(highlevel::Success::Ring {
1383 })
1384 },
1385 _ => Err(DeserializeErrorCause::UnknownResponse(lowlevel.clone())),
1386 }
1387}
1388
1389pub fn lower_command(highlevel: &highlevel::Command) -> lowlevel::Command {
1390 match highlevel {
1391 highlevel::Command::Testex { } => {
1392 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1393 lowlevel::Command::Execute { name: String::from("TESTEX"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1394 },
1395 highlevel::Command::Testexext { } => {
1396 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1397 lowlevel::Command::Execute { name: String::from("TESTEXEXT"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1398 },
1399 highlevel::Command::TestCommand { } => {
1400 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1401 lowlevel::Command::Execute { name: String::from("TESTNEX"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1402 },
1403 highlevel::Command::Testexextfi {
1404 field,
1405 } => {
1406 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1407 let field_string = i64::to_string(&field);
1408 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1409 raw_arguments.push(field_primitive);
1410 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1411 lowlevel::Command::Execute { name: String::from("TESTEXEXTFI"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1412 },
1413 highlevel::Command::Testexextfic {
1414 field,
1415 } => {
1416 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1417 let field_string = i64::to_string(&field);
1418 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1419 raw_arguments.push(field_primitive);
1420 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1421 lowlevel::Command::Execute { name: String::from("TESTEXEXTFIC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1422 },
1423 highlevel::Command::Testnsd {
1424 field,
1425 } => {
1426 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1427 let field_string = i64::to_string(&field);
1428 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1429 raw_arguments.push(field_primitive);
1430 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1431 lowlevel::Command::Execute { name: String::from("TESTNSD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(">")), arguments, terminator: None } }
1432 },
1433 highlevel::Command::Testnst {
1434 field,
1435 } => {
1436 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1437 let field_string = i64::to_string(&field);
1438 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1439 raw_arguments.push(field_primitive);
1440 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1441 lowlevel::Command::Execute { name: String::from("TESTNST"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: Some(String::from(";")) } }
1442 },
1443 highlevel::Command::Testnsdnst {
1444 field,
1445 } => {
1446 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1447 let field_string = i64::to_string(&field);
1448 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1449 raw_arguments.push(field_primitive);
1450 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1451 lowlevel::Command::Execute { name: String::from("TESTNSDNST"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(">")), arguments, terminator: Some(String::from(";")) } }
1452 },
1453 highlevel::Command::Testnod {
1454 field,
1455 } => {
1456 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1457 let field_string = i64::to_string(&field);
1458 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1459 raw_arguments.push(field_primitive);
1460 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1461 lowlevel::Command::Execute { name: String::from("TESTNOD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1462 },
1463 highlevel::Command::Testexextfs {
1464 field,
1465 } => {
1466 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1467 let field_string = field.clone();
1468 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1469 raw_arguments.push(field_primitive);
1470 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1471 lowlevel::Command::Execute { name: String::from("TESTEXEXTFS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1472 },
1473 highlevel::Command::Testexextfsi {
1474 field1,
1475 field2,
1476 } => {
1477 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1478 let field1_string = field1.clone();
1479 let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1480 raw_arguments.push(field1_primitive);
1481 let field2_string = i64::to_string(&field2);
1482 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
1483 raw_arguments.push(field2_primitive);
1484 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1485 lowlevel::Command::Execute { name: String::from("TESTEXEXTFSI"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1486 },
1487 highlevel::Command::Testexextfsic {
1488 field1,
1489 field2,
1490 } => {
1491 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1492 let field1_string = field1.clone();
1493 let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1494 raw_arguments.push(field1_primitive);
1495 let field2_string = i64::to_string(&field2);
1496 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
1497 raw_arguments.push(field2_primitive);
1498 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1499 lowlevel::Command::Execute { name: String::from("TESTEXEXTFSIC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1500 },
1501 highlevel::Command::Testio {
1502 field1,
1503 field2,
1504 } => {
1505 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1506 let field1_string = i64::to_string(&field1);
1507 let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1508 raw_arguments.push(field1_primitive);
1509 match field2 {
1510 None => {
1511 raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
1512 }
1513 Some(field2_unwrapped) => {
1514 let field2_unwrapped_string = i64::to_string(&field2_unwrapped);
1515 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_unwrapped_string);
1516 raw_arguments.push(field2_primitive);
1517 }
1518 }
1519 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1520 lowlevel::Command::Execute { name: String::from("TESTIO"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1521 },
1522 highlevel::Command::Testl {
1523 field,
1524 } => {
1525 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1526 for field_element in field.into_iter() {
1527 let field_element_string = i64::to_string(&field_element);
1528 let field_element_primitive = lowlevel::Argument::PrimitiveArgument(field_element_string);
1529 raw_arguments.push(field_element_primitive);
1530 }
1531 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1532 lowlevel::Command::Execute { name: String::from("TESTL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1533 },
1534 highlevel::Command::Testol {
1535 field,
1536 } => {
1537 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1538 for field_element in field.into_iter() {
1539 match field_element {
1540 None => {
1541 raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
1542 }
1543 Some(field_element_unwrapped) => {
1544 let field_element_unwrapped_string = i64::to_string(&field_element_unwrapped);
1545 let field_element_primitive = lowlevel::Argument::PrimitiveArgument(field_element_unwrapped_string);
1546 raw_arguments.push(field_element_primitive);
1547 }
1548 }
1549 }
1550 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1551 lowlevel::Command::Execute { name: String::from("TESTOL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1552 },
1553 highlevel::Command::Testm {
1554 field,
1555 } => {
1556 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1557 for (field_typed_key, field_typed_value) in field {
1558 let field_primitive_key = i64::to_string(&field_typed_key);
1559 let field_primitive_value = field_typed_value.clone();
1560 let field_untyped_pair = lowlevel::Argument::KeyValueArgument { key: field_primitive_key, value: field_primitive_value };
1561 raw_arguments.push(field_untyped_pair);
1562 }
1563 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1564 lowlevel::Command::Execute { name: String::from("TESTM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1565 },
1566 highlevel::Command::Testp {
1567 field,
1568 } => {
1569 let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
1570 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1571 let field_string = i64::to_string(&field);
1572 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1573 raw_arguments_inner.push(field_primitive);
1574 raw_arguments_outer.push(raw_arguments_inner);
1575 let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
1576 lowlevel::Command::Execute { name: String::from("TESTP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1577 },
1578 highlevel::Command::Testpp {
1579 field1,
1580 field2,
1581 field3,
1582 } => {
1583 let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
1584 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1585 let field1_string = i64::to_string(&field1);
1586 let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1587 raw_arguments_inner.push(field1_primitive);
1588 raw_arguments_outer.push(raw_arguments_inner);
1589 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1590 let field2_string = i64::to_string(&field2);
1591 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
1592 raw_arguments_inner.push(field2_primitive);
1593 let field3_string = field3.clone();
1594 let field3_primitive = lowlevel::Argument::PrimitiveArgument(field3_string);
1595 raw_arguments_inner.push(field3_primitive);
1596 raw_arguments_outer.push(raw_arguments_inner);
1597 let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
1598 lowlevel::Command::Execute { name: String::from("TESTPP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1599 },
1600 highlevel::Command::Testpmpil {
1601 field1,
1602 field2,
1603 field3,
1604 } => {
1605 let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
1606 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1607 for (field1_typed_key, field1_typed_value) in field1 {
1608 let field1_primitive_key = i64::to_string(&field1_typed_key);
1609 let field1_primitive_value = field1_typed_value.clone();
1610 let field1_untyped_pair = lowlevel::Argument::KeyValueArgument { key: field1_primitive_key, value: field1_primitive_value };
1611 raw_arguments_inner.push(field1_untyped_pair);
1612 }
1613 raw_arguments_outer.push(raw_arguments_inner);
1614 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1615 let field2_string = i64::to_string(&field2);
1616 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
1617 raw_arguments_inner.push(field2_primitive);
1618 for field3_element in field3.into_iter() {
1619 let field3_element_string = i64::to_string(&field3_element);
1620 let field3_element_primitive = lowlevel::Argument::PrimitiveArgument(field3_element_string);
1621 raw_arguments_inner.push(field3_element_primitive);
1622 }
1623 raw_arguments_outer.push(raw_arguments_inner);
1624 let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
1625 lowlevel::Command::Execute { name: String::from("TESTPMPIL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1626 },
1627 highlevel::Command::TestrRead {} => {
1628 lowlevel::Command::Read { name: String::from("TESTR"), is_extension: false }
1629 },
1630 highlevel::Command::TestrexRead {} => {
1631 lowlevel::Command::Read { name: String::from("TESTREX"), is_extension: true }
1632 },
1633 highlevel::Command::TesttTest {} => {
1634 lowlevel::Command::Test { name: String::from("TESTT"), is_extension: false }
1635 },
1636 highlevel::Command::TesttexTest {} => {
1637 lowlevel::Command::Test { name: String::from("TESTTEX"), is_extension: true }
1638 },
1639 highlevel::Command::Testenum {
1640 field,
1641 } => {
1642 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1643 let field_string_int = *field as i64;
1644 let field_string = i64::to_string(&field_string_int);
1645 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1646 raw_arguments.push(field_primitive);
1647 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1648 lowlevel::Command::Execute { name: String::from("TESTENUM"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1649 },
1650 highlevel::Command::Testbool {
1651 field,
1652 } => {
1653 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1654 let field_string_int = if *field { 1 } else { 0 };
1655 let field_string = i64::to_string(&field_string_int);
1656 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1657 raw_arguments.push(field_primitive);
1658 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1659 lowlevel::Command::Execute { name: String::from("TESTBOOL"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1660 },
1661 highlevel::Command::Testotherfile { } => {
1662 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1663 lowlevel::Command::Execute { name: String::from("TESTOTHERFILE"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1664 },
1665 highlevel::Command::Brsf {
1666 features,
1667 } => {
1668 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1669 let features_string = i64::to_string(&features);
1670 let features_primitive = lowlevel::Argument::PrimitiveArgument(features_string);
1671 raw_arguments.push(features_primitive);
1672 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1673 lowlevel::Command::Execute { name: String::from("BRSF"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1674 },
1675 highlevel::Command::CindTest {} => {
1676 lowlevel::Command::Test { name: String::from("CIND"), is_extension: true }
1677 },
1678 highlevel::Command::CindRead {} => {
1679 lowlevel::Command::Read { name: String::from("CIND"), is_extension: true }
1680 },
1681 highlevel::Command::Clcc { } => {
1682 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1683 lowlevel::Command::Execute { name: String::from("CLCC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1684 },
1685 highlevel::Command::Bcc { } => {
1686 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1687 lowlevel::Command::Execute { name: String::from("BCC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1688 },
1689 highlevel::Command::Bcs {
1690 codec,
1691 } => {
1692 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1693 let codec_string = i64::to_string(&codec);
1694 let codec_primitive = lowlevel::Argument::PrimitiveArgument(codec_string);
1695 raw_arguments.push(codec_primitive);
1696 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1697 lowlevel::Command::Execute { name: String::from("BCS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1698 },
1699 highlevel::Command::Bac {
1700 codecs,
1701 } => {
1702 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1703 for codecs_element in codecs.into_iter() {
1704 let codecs_element_string = i64::to_string(&codecs_element);
1705 let codecs_element_primitive = lowlevel::Argument::PrimitiveArgument(codecs_element_string);
1706 raw_arguments.push(codecs_element_primitive);
1707 }
1708 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1709 lowlevel::Command::Execute { name: String::from("BAC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1710 },
1711 highlevel::Command::Bind {
1712 indicators,
1713 } => {
1714 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1715 for indicators_element in indicators.into_iter() {
1716 let indicators_element_string = i64::to_string(&indicators_element);
1717 let indicators_element_primitive = lowlevel::Argument::PrimitiveArgument(indicators_element_string);
1718 raw_arguments.push(indicators_element_primitive);
1719 }
1720 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1721 lowlevel::Command::Execute { name: String::from("BIND"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1722 },
1723 highlevel::Command::BindTest {} => {
1724 lowlevel::Command::Test { name: String::from("BIND"), is_extension: true }
1725 },
1726 highlevel::Command::BindRead {} => {
1727 lowlevel::Command::Read { name: String::from("BIND"), is_extension: true }
1728 },
1729 highlevel::Command::Biev {
1730 anum,
1731 value,
1732 } => {
1733 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1734 let anum_string_int = *anum as i64;
1735 let anum_string = i64::to_string(&anum_string_int);
1736 let anum_primitive = lowlevel::Argument::PrimitiveArgument(anum_string);
1737 raw_arguments.push(anum_primitive);
1738 let value_string = i64::to_string(&value);
1739 let value_primitive = lowlevel::Argument::PrimitiveArgument(value_string);
1740 raw_arguments.push(value_primitive);
1741 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1742 lowlevel::Command::Execute { name: String::from("BIEV"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1743 },
1744 highlevel::Command::ChldTest {} => {
1745 lowlevel::Command::Test { name: String::from("CHLD"), is_extension: true }
1746 },
1747 highlevel::Command::Cmer {
1748 mode,
1749 keyp,
1750 disp,
1751 ind,
1752 } => {
1753 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1754 let mode_string = i64::to_string(&mode);
1755 let mode_primitive = lowlevel::Argument::PrimitiveArgument(mode_string);
1756 raw_arguments.push(mode_primitive);
1757 let keyp_string = i64::to_string(&keyp);
1758 let keyp_primitive = lowlevel::Argument::PrimitiveArgument(keyp_string);
1759 raw_arguments.push(keyp_primitive);
1760 let disp_string = i64::to_string(&disp);
1761 let disp_primitive = lowlevel::Argument::PrimitiveArgument(disp_string);
1762 raw_arguments.push(disp_primitive);
1763 let ind_string = i64::to_string(&ind);
1764 let ind_primitive = lowlevel::Argument::PrimitiveArgument(ind_string);
1765 raw_arguments.push(ind_primitive);
1766 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1767 lowlevel::Command::Execute { name: String::from("CMER"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1768 },
1769 highlevel::Command::Nrec {
1770 nrec,
1771 } => {
1772 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1773 let nrec_string_int = if *nrec { 1 } else { 0 };
1774 let nrec_string = i64::to_string(&nrec_string_int);
1775 let nrec_primitive = lowlevel::Argument::PrimitiveArgument(nrec_string);
1776 raw_arguments.push(nrec_primitive);
1777 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1778 lowlevel::Command::Execute { name: String::from("NREC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1779 },
1780 highlevel::Command::Cops {
1781 three,
1782 format,
1783 } => {
1784 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1785 let three_string = i64::to_string(&three);
1786 let three_primitive = lowlevel::Argument::PrimitiveArgument(three_string);
1787 raw_arguments.push(three_primitive);
1788 let format_string_int = *format as i64;
1789 let format_string = i64::to_string(&format_string_int);
1790 let format_primitive = lowlevel::Argument::PrimitiveArgument(format_string);
1791 raw_arguments.push(format_primitive);
1792 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1793 lowlevel::Command::Execute { name: String::from("COPS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1794 },
1795 highlevel::Command::CopsRead {} => {
1796 lowlevel::Command::Read { name: String::from("COPS"), is_extension: true }
1797 },
1798 highlevel::Command::Cmee {
1799 enable,
1800 } => {
1801 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1802 let enable_string_int = if *enable { 1 } else { 0 };
1803 let enable_string = i64::to_string(&enable_string_int);
1804 let enable_primitive = lowlevel::Argument::PrimitiveArgument(enable_string);
1805 raw_arguments.push(enable_primitive);
1806 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1807 lowlevel::Command::Execute { name: String::from("CMEE"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1808 },
1809 highlevel::Command::Ccwa {
1810 enable,
1811 } => {
1812 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1813 let enable_string_int = if *enable { 1 } else { 0 };
1814 let enable_string = i64::to_string(&enable_string_int);
1815 let enable_primitive = lowlevel::Argument::PrimitiveArgument(enable_string);
1816 raw_arguments.push(enable_primitive);
1817 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1818 lowlevel::Command::Execute { name: String::from("CCWA"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1819 },
1820 highlevel::Command::Clip {
1821 enable,
1822 } => {
1823 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1824 let enable_string_int = if *enable { 1 } else { 0 };
1825 let enable_string = i64::to_string(&enable_string_int);
1826 let enable_primitive = lowlevel::Argument::PrimitiveArgument(enable_string);
1827 raw_arguments.push(enable_primitive);
1828 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1829 lowlevel::Command::Execute { name: String::from("CLIP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1830 },
1831 highlevel::Command::Cnum { } => {
1832 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1833 lowlevel::Command::Execute { name: String::from("CNUM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1834 },
1835 highlevel::Command::Vts {
1836 code,
1837 } => {
1838 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1839 let code_string = code.clone();
1840 let code_primitive = lowlevel::Argument::PrimitiveArgument(code_string);
1841 raw_arguments.push(code_primitive);
1842 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1843 lowlevel::Command::Execute { name: String::from("VTS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1844 },
1845 highlevel::Command::Vgs {
1846 level,
1847 } => {
1848 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1849 let level_string = i64::to_string(&level);
1850 let level_primitive = lowlevel::Argument::PrimitiveArgument(level_string);
1851 raw_arguments.push(level_primitive);
1852 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1853 lowlevel::Command::Execute { name: String::from("VGS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1854 },
1855 highlevel::Command::Vgm {
1856 level,
1857 } => {
1858 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1859 let level_string = i64::to_string(&level);
1860 let level_primitive = lowlevel::Argument::PrimitiveArgument(level_string);
1861 raw_arguments.push(level_primitive);
1862 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1863 lowlevel::Command::Execute { name: String::from("VGM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1864 },
1865 highlevel::Command::Bia {
1866 indrep,
1867 } => {
1868 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1869 for indrep_element in indrep.into_iter() {
1870 match indrep_element {
1871 None => {
1872 raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
1873 }
1874 Some(indrep_element_unwrapped) => {
1875 let indrep_element_unwrapped_string_int = if *indrep_element_unwrapped { 1 } else { 0 };
1876 let indrep_element_unwrapped_string = i64::to_string(&indrep_element_unwrapped_string_int);
1877 let indrep_element_primitive = lowlevel::Argument::PrimitiveArgument(indrep_element_unwrapped_string);
1878 raw_arguments.push(indrep_element_primitive);
1879 }
1880 }
1881 }
1882 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1883 lowlevel::Command::Execute { name: String::from("BIA"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1884 },
1885 highlevel::Command::Answer { } => {
1886 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1887 lowlevel::Command::Execute { name: String::from("A"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1888 },
1889 highlevel::Command::Chup { } => {
1890 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1891 lowlevel::Command::Execute { name: String::from("CHUP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1892 },
1893 highlevel::Command::Chld {
1894 command,
1895 } => {
1896 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1897 let command_string = command.clone();
1898 let command_primitive = lowlevel::Argument::PrimitiveArgument(command_string);
1899 raw_arguments.push(command_primitive);
1900 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1901 lowlevel::Command::Execute { name: String::from("CHLD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1902 },
1903 highlevel::Command::AtdNumber {
1904 number,
1905 } => {
1906 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1907 let number_string = number.clone();
1908 let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
1909 raw_arguments.push(number_primitive);
1910 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1911 lowlevel::Command::Execute { name: String::from("D"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: Some(String::from(";")) } }
1912 },
1913 highlevel::Command::AtdMemory {
1914 location,
1915 } => {
1916 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1917 let location_string = location.clone();
1918 let location_primitive = lowlevel::Argument::PrimitiveArgument(location_string);
1919 raw_arguments.push(location_primitive);
1920 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1921 lowlevel::Command::Execute { name: String::from("D"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(">")), arguments, terminator: Some(String::from(";")) } }
1922 },
1923 highlevel::Command::Bldn { } => {
1924 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1925 lowlevel::Command::Execute { name: String::from("BLDN"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1926 },
1927 }
1928}
1929
1930pub fn lower_success(highlevel: &highlevel::Success) -> lowlevel::Response {
1931 match highlevel {
1932 highlevel::Success::Test { } => {
1933 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1934 lowlevel::Response::Success { name: String::from("TEST"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1935 },
1936 highlevel::Success::Testnod { } => {
1937 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1938 lowlevel::Response::Success { name: String::from("TESTNOD"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1939 },
1940 highlevel::Success::TestResponse { } => {
1941 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1942 lowlevel::Response::Success { name: String::from("TESTN"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1943 },
1944 highlevel::Success::Testext { } => {
1945 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1946 lowlevel::Response::Success { name: String::from("TESTEXT"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1947 },
1948 highlevel::Success::Testextnod { } => {
1949 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1950 lowlevel::Response::Success { name: String::from("TESTEXTNOD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1951 },
1952 highlevel::Success::Testi {
1953 field,
1954 } => {
1955 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1956 let field_string = i64::to_string(&field);
1957 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1958 raw_arguments.push(field_primitive);
1959 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1960 lowlevel::Response::Success { name: String::from("TESTI"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1961 },
1962 highlevel::Success::Testinod {
1963 field,
1964 } => {
1965 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1966 let field_string = i64::to_string(&field);
1967 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1968 raw_arguments.push(field_primitive);
1969 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1970 lowlevel::Response::Success { name: String::from("TESTINOD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1971 },
1972 highlevel::Success::Testic {
1973 field,
1974 } => {
1975 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1976 let field_string = i64::to_string(&field);
1977 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1978 raw_arguments.push(field_primitive);
1979 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1980 lowlevel::Response::Success { name: String::from("TESTIC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1981 },
1982 highlevel::Success::Tests {
1983 field,
1984 } => {
1985 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1986 let field_string = field.clone();
1987 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1988 raw_arguments.push(field_primitive);
1989 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1990 lowlevel::Response::Success { name: String::from("TESTS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1991 },
1992 highlevel::Success::Testsi {
1993 field1,
1994 field2,
1995 } => {
1996 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1997 let field1_string = field1.clone();
1998 let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1999 raw_arguments.push(field1_primitive);
2000 let field2_string = i64::to_string(&field2);
2001 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
2002 raw_arguments.push(field2_primitive);
2003 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2004 lowlevel::Response::Success { name: String::from("TESTSI"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2005 },
2006 highlevel::Success::Testsic {
2007 field1,
2008 field2,
2009 } => {
2010 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2011 let field1_string = field1.clone();
2012 let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
2013 raw_arguments.push(field1_primitive);
2014 let field2_string = i64::to_string(&field2);
2015 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
2016 raw_arguments.push(field2_primitive);
2017 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2018 lowlevel::Response::Success { name: String::from("TESTSIC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2019 },
2020 highlevel::Success::Testio {
2021 field1,
2022 field2,
2023 } => {
2024 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2025 let field1_string = i64::to_string(&field1);
2026 let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
2027 raw_arguments.push(field1_primitive);
2028 match field2 {
2029 None => {
2030 raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
2031 }
2032 Some(field2_unwrapped) => {
2033 let field2_unwrapped_string = i64::to_string(&field2_unwrapped);
2034 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_unwrapped_string);
2035 raw_arguments.push(field2_primitive);
2036 }
2037 }
2038 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2039 lowlevel::Response::Success { name: String::from("TESTIO"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2040 },
2041 highlevel::Success::Testl {
2042 field,
2043 } => {
2044 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2045 for field_element in field.into_iter() {
2046 let field_element_string = i64::to_string(&field_element);
2047 let field_element_primitive = lowlevel::Argument::PrimitiveArgument(field_element_string);
2048 raw_arguments.push(field_element_primitive);
2049 }
2050 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2051 lowlevel::Response::Success { name: String::from("TESTL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2052 },
2053 highlevel::Success::Testol {
2054 field,
2055 } => {
2056 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2057 for field_element in field.into_iter() {
2058 match field_element {
2059 None => {
2060 raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
2061 }
2062 Some(field_element_unwrapped) => {
2063 let field_element_unwrapped_string = i64::to_string(&field_element_unwrapped);
2064 let field_element_primitive = lowlevel::Argument::PrimitiveArgument(field_element_unwrapped_string);
2065 raw_arguments.push(field_element_primitive);
2066 }
2067 }
2068 }
2069 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2070 lowlevel::Response::Success { name: String::from("TESTOL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2071 },
2072 highlevel::Success::Testm {
2073 field,
2074 } => {
2075 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2076 for (field_typed_key, field_typed_value) in field {
2077 let field_primitive_key = i64::to_string(&field_typed_key);
2078 let field_primitive_value = field_typed_value.clone();
2079 let field_untyped_pair = lowlevel::Argument::KeyValueArgument { key: field_primitive_key, value: field_primitive_value };
2080 raw_arguments.push(field_untyped_pair);
2081 }
2082 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2083 lowlevel::Response::Success { name: String::from("TESTM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2084 },
2085 highlevel::Success::Testp {
2086 field,
2087 } => {
2088 let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2089 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2090 let field_string = i64::to_string(&field);
2091 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
2092 raw_arguments_inner.push(field_primitive);
2093 raw_arguments_outer.push(raw_arguments_inner);
2094 let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2095 lowlevel::Response::Success { name: String::from("TESTP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2096 },
2097 highlevel::Success::Testpp {
2098 field1,
2099 field2,
2100 field3,
2101 } => {
2102 let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2103 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2104 let field1_string = i64::to_string(&field1);
2105 let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
2106 raw_arguments_inner.push(field1_primitive);
2107 raw_arguments_outer.push(raw_arguments_inner);
2108 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2109 let field2_string = i64::to_string(&field2);
2110 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
2111 raw_arguments_inner.push(field2_primitive);
2112 let field3_string = field3.clone();
2113 let field3_primitive = lowlevel::Argument::PrimitiveArgument(field3_string);
2114 raw_arguments_inner.push(field3_primitive);
2115 raw_arguments_outer.push(raw_arguments_inner);
2116 let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2117 lowlevel::Response::Success { name: String::from("TESTPP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2118 },
2119 highlevel::Success::Testpmpil {
2120 field1,
2121 field2,
2122 field3,
2123 } => {
2124 let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2125 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2126 for (field1_typed_key, field1_typed_value) in field1 {
2127 let field1_primitive_key = i64::to_string(&field1_typed_key);
2128 let field1_primitive_value = field1_typed_value.clone();
2129 let field1_untyped_pair = lowlevel::Argument::KeyValueArgument { key: field1_primitive_key, value: field1_primitive_value };
2130 raw_arguments_inner.push(field1_untyped_pair);
2131 }
2132 raw_arguments_outer.push(raw_arguments_inner);
2133 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2134 let field2_string = i64::to_string(&field2);
2135 let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
2136 raw_arguments_inner.push(field2_primitive);
2137 for field3_element in field3.into_iter() {
2138 let field3_element_string = i64::to_string(&field3_element);
2139 let field3_element_primitive = lowlevel::Argument::PrimitiveArgument(field3_element_string);
2140 raw_arguments_inner.push(field3_element_primitive);
2141 }
2142 raw_arguments_outer.push(raw_arguments_inner);
2143 let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2144 lowlevel::Response::Success { name: String::from("TESTPMPIL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2145 },
2146 highlevel::Success::SameOne {
2147 field,
2148 } => {
2149 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2150 let field_string = i64::to_string(&field);
2151 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
2152 raw_arguments.push(field_primitive);
2153 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2154 lowlevel::Response::Success { name: String::from("SAME"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2155 },
2156 highlevel::Success::SameTwo {
2157 field,
2158 } => {
2159 let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2160 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2161 let field_string = i64::to_string(&field);
2162 let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
2163 raw_arguments_inner.push(field_primitive);
2164 raw_arguments_outer.push(raw_arguments_inner);
2165 let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2166 lowlevel::Response::Success { name: String::from("SAME"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2167 },
2168 highlevel::Success::Brsf {
2169 features,
2170 } => {
2171 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2172 let features_string = i64::to_string(&features);
2173 let features_primitive = lowlevel::Argument::PrimitiveArgument(features_string);
2174 raw_arguments.push(features_primitive);
2175 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2176 lowlevel::Response::Success { name: String::from("BRSF"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2177 },
2178 highlevel::Success::CindRead {
2179 ordered_values,
2180 } => {
2181 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2182 for ordered_values_element in ordered_values.into_iter() {
2183 let ordered_values_element_string = i64::to_string(&ordered_values_element);
2184 let ordered_values_element_primitive = lowlevel::Argument::PrimitiveArgument(ordered_values_element_string);
2185 raw_arguments.push(ordered_values_element_primitive);
2186 }
2187 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2188 lowlevel::Response::Success { name: String::from("CIND"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2189 },
2190 highlevel::Success::Clcc {
2191 index,
2192 dir,
2193 status,
2194 mode,
2195 mpty,
2196 number,
2197 ty,
2198 } => {
2199 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2200 let index_string = i64::to_string(&index);
2201 let index_primitive = lowlevel::Argument::PrimitiveArgument(index_string);
2202 raw_arguments.push(index_primitive);
2203 let dir_string = i64::to_string(&dir);
2204 let dir_primitive = lowlevel::Argument::PrimitiveArgument(dir_string);
2205 raw_arguments.push(dir_primitive);
2206 let status_string = i64::to_string(&status);
2207 let status_primitive = lowlevel::Argument::PrimitiveArgument(status_string);
2208 raw_arguments.push(status_primitive);
2209 let mode_string = i64::to_string(&mode);
2210 let mode_primitive = lowlevel::Argument::PrimitiveArgument(mode_string);
2211 raw_arguments.push(mode_primitive);
2212 let mpty_string = i64::to_string(&mpty);
2213 let mpty_primitive = lowlevel::Argument::PrimitiveArgument(mpty_string);
2214 raw_arguments.push(mpty_primitive);
2215 let number_string = number.clone();
2216 let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
2217 raw_arguments.push(number_primitive);
2218 let ty_string = i64::to_string(&ty);
2219 let ty_primitive = lowlevel::Argument::PrimitiveArgument(ty_string);
2220 raw_arguments.push(ty_primitive);
2221 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2222 lowlevel::Response::Success { name: String::from("CLCC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2223 },
2224 highlevel::Success::Bcs {
2225 codec,
2226 } => {
2227 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2228 let codec_string = i64::to_string(&codec);
2229 let codec_primitive = lowlevel::Argument::PrimitiveArgument(codec_string);
2230 raw_arguments.push(codec_primitive);
2231 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2232 lowlevel::Response::Success { name: String::from("BCS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2233 },
2234 highlevel::Success::BindList {
2235 indicators,
2236 } => {
2237 let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2238 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2239 for indicators_element in indicators.into_iter() {
2240 let indicators_element_string_int = *indicators_element as i64;
2241 let indicators_element_string = i64::to_string(&indicators_element_string_int);
2242 let indicators_element_primitive = lowlevel::Argument::PrimitiveArgument(indicators_element_string);
2243 raw_arguments_inner.push(indicators_element_primitive);
2244 }
2245 raw_arguments_outer.push(raw_arguments_inner);
2246 let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2247 lowlevel::Response::Success { name: String::from("BIND"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2248 },
2249 highlevel::Success::BindStatus {
2250 anum,
2251 state,
2252 } => {
2253 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2254 let anum_string_int = *anum as i64;
2255 let anum_string = i64::to_string(&anum_string_int);
2256 let anum_primitive = lowlevel::Argument::PrimitiveArgument(anum_string);
2257 raw_arguments.push(anum_primitive);
2258 let state_string_int = if *state { 1 } else { 0 };
2259 let state_string = i64::to_string(&state_string_int);
2260 let state_primitive = lowlevel::Argument::PrimitiveArgument(state_string);
2261 raw_arguments.push(state_primitive);
2262 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2263 lowlevel::Response::Success { name: String::from("BIND"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2264 },
2265 highlevel::Success::Chld {
2266 commands,
2267 } => {
2268 let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2269 let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2270 for commands_element in commands.into_iter() {
2271 let commands_element_string = commands_element.clone();
2272 let commands_element_primitive = lowlevel::Argument::PrimitiveArgument(commands_element_string);
2273 raw_arguments_inner.push(commands_element_primitive);
2274 }
2275 raw_arguments_outer.push(raw_arguments_inner);
2276 let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2277 lowlevel::Response::Success { name: String::from("CHLD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2278 },
2279 highlevel::Success::Cops {
2280 format,
2281 zero,
2282 operator,
2283 } => {
2284 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2285 let format_string_int = *format as i64;
2286 let format_string = i64::to_string(&format_string_int);
2287 let format_primitive = lowlevel::Argument::PrimitiveArgument(format_string);
2288 raw_arguments.push(format_primitive);
2289 let zero_string = i64::to_string(&zero);
2290 let zero_primitive = lowlevel::Argument::PrimitiveArgument(zero_string);
2291 raw_arguments.push(zero_primitive);
2292 let operator_string = operator.clone();
2293 let operator_primitive = lowlevel::Argument::PrimitiveArgument(operator_string);
2294 raw_arguments.push(operator_primitive);
2295 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2296 lowlevel::Response::Success { name: String::from("COPS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2297 },
2298 highlevel::Success::Clip {
2299 number,
2300 ty,
2301 } => {
2302 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2303 let number_string = number.clone();
2304 let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
2305 raw_arguments.push(number_primitive);
2306 let ty_string = i64::to_string(&ty);
2307 let ty_primitive = lowlevel::Argument::PrimitiveArgument(ty_string);
2308 raw_arguments.push(ty_primitive);
2309 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2310 lowlevel::Response::Success { name: String::from("CLIP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2311 },
2312 highlevel::Success::Cnum {
2313 alpha,
2314 number,
2315 ty,
2316 speed,
2317 service,
2318 } => {
2319 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2320 let alpha_string = alpha.clone();
2321 let alpha_primitive = lowlevel::Argument::PrimitiveArgument(alpha_string);
2322 raw_arguments.push(alpha_primitive);
2323 let number_string = number.clone();
2324 let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
2325 raw_arguments.push(number_primitive);
2326 let ty_string = i64::to_string(&ty);
2327 let ty_primitive = lowlevel::Argument::PrimitiveArgument(ty_string);
2328 raw_arguments.push(ty_primitive);
2329 let speed_string = speed.clone();
2330 let speed_primitive = lowlevel::Argument::PrimitiveArgument(speed_string);
2331 raw_arguments.push(speed_primitive);
2332 let service_string = i64::to_string(&service);
2333 let service_primitive = lowlevel::Argument::PrimitiveArgument(service_string);
2334 raw_arguments.push(service_primitive);
2335 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2336 lowlevel::Response::Success { name: String::from("CNUM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2337 },
2338 highlevel::Success::Vgs {
2339 level,
2340 } => {
2341 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2342 let level_string = i64::to_string(&level);
2343 let level_primitive = lowlevel::Argument::PrimitiveArgument(level_string);
2344 raw_arguments.push(level_primitive);
2345 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2346 lowlevel::Response::Success { name: String::from("VGS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2347 },
2348 highlevel::Success::Vgm {
2349 level,
2350 } => {
2351 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2352 let level_string = i64::to_string(&level);
2353 let level_primitive = lowlevel::Argument::PrimitiveArgument(level_string);
2354 raw_arguments.push(level_primitive);
2355 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2356 lowlevel::Response::Success { name: String::from("VGM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2357 },
2358 highlevel::Success::Ciev {
2359 ind,
2360 value,
2361 } => {
2362 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2363 let ind_string = i64::to_string(&ind);
2364 let ind_primitive = lowlevel::Argument::PrimitiveArgument(ind_string);
2365 raw_arguments.push(ind_primitive);
2366 let value_string = i64::to_string(&value);
2367 let value_primitive = lowlevel::Argument::PrimitiveArgument(value_string);
2368 raw_arguments.push(value_primitive);
2369 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2370 lowlevel::Response::Success { name: String::from("CIEV"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2371 },
2372 highlevel::Success::Ccwa {
2373 number,
2374 ty,
2375 } => {
2376 let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2377 let number_string = number.clone();
2378 let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
2379 raw_arguments.push(number_primitive);
2380 let ty_string = i64::to_string(&ty);
2381 let ty_primitive = lowlevel::Argument::PrimitiveArgument(ty_string);
2382 raw_arguments.push(ty_primitive);
2383 let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2384 lowlevel::Response::Success { name: String::from("CCWA"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2385 },
2386 highlevel::Success::Ring { } => {
2387 let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
2388 lowlevel::Response::Success { name: String::from("RING"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
2389 },
2390 }
2391}
2392