melodium_common/executive/
transmission.rs

1use super::{GetData, Value};
2use std::collections::VecDeque;
3use std::convert::TryInto;
4
5#[derive(Debug, Clone)]
6pub enum TransmissionError {
7    NoReceiver,
8    EverythingClosed,
9    NoData,
10}
11
12pub type SendResult = Result<(), TransmissionError>;
13pub type RecvResult<T> = Result<T, TransmissionError>;
14
15#[derive(Clone, Debug)]
16pub enum TransmissionValue {
17    Void(VecDeque<()>),
18
19    I8(VecDeque<i8>),
20    I16(VecDeque<i16>),
21    I32(VecDeque<i32>),
22    I64(VecDeque<i64>),
23    I128(VecDeque<i128>),
24
25    U8(VecDeque<u8>),
26    U16(VecDeque<u16>),
27    U32(VecDeque<u32>),
28    U64(VecDeque<u64>),
29    U128(VecDeque<u128>),
30
31    F32(VecDeque<f32>),
32    F64(VecDeque<f64>),
33
34    Bool(VecDeque<bool>),
35    Byte(VecDeque<u8>),
36    Char(VecDeque<char>),
37    String(VecDeque<String>),
38
39    /// This variant handle all non-optimized cases.
40    ///
41    /// Optimized (and non-optimized) cases are at the implementation discretion.
42    Other(VecDeque<Value>),
43}
44
45impl TransmissionValue {
46    pub fn new(value: Value) -> Self {
47        match value {
48            Value::Void(value) => TransmissionValue::Void({
49                let mut vec = VecDeque::new();
50                vec.push_back(value);
51                vec
52            }),
53            Value::I8(value) => TransmissionValue::I8({
54                let mut vec = VecDeque::new();
55                vec.push_back(value);
56                vec
57            }),
58            Value::I16(value) => TransmissionValue::I16({
59                let mut vec = VecDeque::new();
60                vec.push_back(value);
61                vec
62            }),
63            Value::I32(value) => TransmissionValue::I32({
64                let mut vec = VecDeque::new();
65                vec.push_back(value);
66                vec
67            }),
68            Value::I64(value) => TransmissionValue::I64({
69                let mut vec = VecDeque::new();
70                vec.push_back(value);
71                vec
72            }),
73            Value::I128(value) => TransmissionValue::I128({
74                let mut vec = VecDeque::new();
75                vec.push_back(value);
76                vec
77            }),
78
79            Value::U8(value) => TransmissionValue::U8({
80                let mut vec = VecDeque::new();
81                vec.push_back(value);
82                vec
83            }),
84            Value::U16(value) => TransmissionValue::U16({
85                let mut vec = VecDeque::new();
86                vec.push_back(value);
87                vec
88            }),
89            Value::U32(value) => TransmissionValue::U32({
90                let mut vec = VecDeque::new();
91                vec.push_back(value);
92                vec
93            }),
94            Value::U64(value) => TransmissionValue::U64({
95                let mut vec = VecDeque::new();
96                vec.push_back(value);
97                vec
98            }),
99            Value::U128(value) => TransmissionValue::U128({
100                let mut vec = VecDeque::new();
101                vec.push_back(value);
102                vec
103            }),
104
105            Value::F32(value) => TransmissionValue::F32({
106                let mut vec = VecDeque::new();
107                vec.push_back(value);
108                vec
109            }),
110            Value::F64(value) => TransmissionValue::F64({
111                let mut vec = VecDeque::new();
112                vec.push_back(value);
113                vec
114            }),
115
116            Value::Bool(value) => TransmissionValue::Bool({
117                let mut vec = VecDeque::new();
118                vec.push_back(value);
119                vec
120            }),
121            Value::Byte(value) => TransmissionValue::Byte({
122                let mut vec = VecDeque::new();
123                vec.push_back(value);
124                vec
125            }),
126            Value::Char(value) => TransmissionValue::Char({
127                let mut vec = VecDeque::new();
128                vec.push_back(value);
129                vec
130            }),
131            Value::String(value) => TransmissionValue::String({
132                let mut vec = VecDeque::new();
133                vec.push_back(value);
134                vec
135            }),
136            _ => TransmissionValue::Other({
137                let mut vec = VecDeque::new();
138                vec.push_back(value);
139                vec
140            }),
141        }
142    }
143
144    pub fn append(&mut self, values: TransmissionValue) {
145        match (self, values) {
146            (TransmissionValue::Void(data), TransmissionValue::Void(mut values)) => {
147                data.append(&mut values)
148            }
149            (TransmissionValue::I8(data), TransmissionValue::I8(mut values)) => {
150                data.append(&mut values)
151            }
152            (TransmissionValue::I16(data), TransmissionValue::I16(mut values)) => {
153                data.append(&mut values)
154            }
155            (TransmissionValue::I32(data), TransmissionValue::I32(mut values)) => {
156                data.append(&mut values)
157            }
158            (TransmissionValue::I64(data), TransmissionValue::I64(mut values)) => {
159                data.append(&mut values)
160            }
161            (TransmissionValue::I128(data), TransmissionValue::I128(mut values)) => {
162                data.append(&mut values)
163            }
164
165            (TransmissionValue::U8(data), TransmissionValue::U8(mut values)) => {
166                data.append(&mut values)
167            }
168            (TransmissionValue::U16(data), TransmissionValue::U16(mut values)) => {
169                data.append(&mut values)
170            }
171            (TransmissionValue::U32(data), TransmissionValue::U32(mut values)) => {
172                data.append(&mut values)
173            }
174            (TransmissionValue::U64(data), TransmissionValue::U64(mut values)) => {
175                data.append(&mut values)
176            }
177            (TransmissionValue::U128(data), TransmissionValue::U128(mut values)) => {
178                data.append(&mut values)
179            }
180
181            (TransmissionValue::F32(data), TransmissionValue::F32(mut values)) => {
182                data.append(&mut values)
183            }
184            (TransmissionValue::F64(data), TransmissionValue::F64(mut values)) => {
185                data.append(&mut values)
186            }
187
188            (TransmissionValue::Bool(data), TransmissionValue::Bool(mut values)) => {
189                data.append(&mut values)
190            }
191            (TransmissionValue::Byte(data), TransmissionValue::Byte(mut values)) => {
192                data.append(&mut values)
193            }
194            (TransmissionValue::Char(data), TransmissionValue::Char(mut values)) => {
195                data.append(&mut values)
196            }
197            (TransmissionValue::String(data), TransmissionValue::String(mut values)) => {
198                data.append(&mut values)
199            }
200            (TransmissionValue::Other(data), TransmissionValue::Other(mut values)) => {
201                data.append(&mut values)
202            }
203            _ => panic!("Adding nonmatching values type in transmitter, aborting."),
204        }
205    }
206
207    pub fn len(&self) -> usize {
208        match self {
209            TransmissionValue::Void(data) => data.len(),
210            TransmissionValue::I8(data) => data.len(),
211            TransmissionValue::I16(data) => data.len(),
212            TransmissionValue::I32(data) => data.len(),
213            TransmissionValue::I64(data) => data.len(),
214            TransmissionValue::I128(data) => data.len(),
215            TransmissionValue::U8(data) => data.len(),
216            TransmissionValue::U16(data) => data.len(),
217            TransmissionValue::U32(data) => data.len(),
218            TransmissionValue::U64(data) => data.len(),
219            TransmissionValue::U128(data) => data.len(),
220            TransmissionValue::F32(data) => data.len(),
221            TransmissionValue::F64(data) => data.len(),
222            TransmissionValue::Bool(data) => data.len(),
223            TransmissionValue::Byte(data) => data.len(),
224            TransmissionValue::Char(data) => data.len(),
225            TransmissionValue::String(data) => data.len(),
226            TransmissionValue::Other(data) => data.len(),
227        }
228    }
229
230    pub fn pop_front(&mut self) -> Option<Value> {
231        match self {
232            TransmissionValue::Void(data) => data.pop_front().map(|data| data.into()),
233            TransmissionValue::I8(data) => data.pop_front().map(|data| data.into()),
234            TransmissionValue::I16(data) => data.pop_front().map(|data| data.into()),
235            TransmissionValue::I32(data) => data.pop_front().map(|data| data.into()),
236            TransmissionValue::I64(data) => data.pop_front().map(|data| data.into()),
237            TransmissionValue::I128(data) => data.pop_front().map(|data| data.into()),
238            TransmissionValue::U8(data) => data.pop_front().map(|data| data.into()),
239            TransmissionValue::U16(data) => data.pop_front().map(|data| data.into()),
240            TransmissionValue::U32(data) => data.pop_front().map(|data| data.into()),
241            TransmissionValue::U64(data) => data.pop_front().map(|data| data.into()),
242            TransmissionValue::U128(data) => data.pop_front().map(|data| data.into()),
243            TransmissionValue::F32(data) => data.pop_front().map(|data| data.into()),
244            TransmissionValue::F64(data) => data.pop_front().map(|data| data.into()),
245            TransmissionValue::Bool(data) => data.pop_front().map(|data| data.into()),
246            TransmissionValue::Byte(data) => data.pop_front().map(|data| Value::Byte(data)),
247            TransmissionValue::Char(data) => data.pop_front().map(|data| data.into()),
248            TransmissionValue::String(data) => data.pop_front().map(|data| data.into()),
249            TransmissionValue::Other(data) => data.pop_front(),
250        }
251    }
252
253    pub fn push(&mut self, value: Value) {
254        match (self, value) {
255            (TransmissionValue::Void(data), Value::Void(value)) => data.push_back(value),
256            (TransmissionValue::I8(data), Value::I8(value)) => data.push_back(value),
257            (TransmissionValue::I16(data), Value::I16(value)) => data.push_back(value),
258            (TransmissionValue::I32(data), Value::I32(value)) => data.push_back(value),
259            (TransmissionValue::I64(data), Value::I64(value)) => data.push_back(value),
260            (TransmissionValue::I128(data), Value::I128(value)) => data.push_back(value),
261
262            (TransmissionValue::U8(data), Value::U8(value)) => data.push_back(value),
263            (TransmissionValue::U16(data), Value::U16(value)) => data.push_back(value),
264            (TransmissionValue::U32(data), Value::U32(value)) => data.push_back(value),
265            (TransmissionValue::U64(data), Value::U64(value)) => data.push_back(value),
266            (TransmissionValue::U128(data), Value::U128(value)) => data.push_back(value),
267
268            (TransmissionValue::F32(data), Value::F32(value)) => data.push_back(value),
269            (TransmissionValue::F64(data), Value::F64(value)) => data.push_back(value),
270
271            (TransmissionValue::Bool(data), Value::Bool(value)) => data.push_back(value),
272            (TransmissionValue::Byte(data), Value::Byte(value)) => data.push_back(value),
273            (TransmissionValue::Char(data), Value::Char(value)) => data.push_back(value),
274            (TransmissionValue::String(data), Value::String(value)) => data.push_back(value),
275            (TransmissionValue::Other(data), value) => data.push_back(value),
276
277            _ => panic!("Adding nonmatching value type in transmitter, aborting."),
278        }
279    }
280}
281
282impl Into<VecDeque<Value>> for TransmissionValue {
283    fn into(self) -> VecDeque<Value> {
284        match self {
285            TransmissionValue::Void(data) => data.into_iter().map(|data| data.into()).collect(),
286            TransmissionValue::I8(data) => data.into_iter().map(|data| data.into()).collect(),
287            TransmissionValue::I16(data) => data.into_iter().map(|data| data.into()).collect(),
288            TransmissionValue::I32(data) => data.into_iter().map(|data| data.into()).collect(),
289            TransmissionValue::I64(data) => data.into_iter().map(|data| data.into()).collect(),
290            TransmissionValue::I128(data) => data.into_iter().map(|data| data.into()).collect(),
291            TransmissionValue::U8(data) => data.into_iter().map(|data| data.into()).collect(),
292            TransmissionValue::U16(data) => data.into_iter().map(|data| data.into()).collect(),
293            TransmissionValue::U32(data) => data.into_iter().map(|data| data.into()).collect(),
294            TransmissionValue::U64(data) => data.into_iter().map(|data| data.into()).collect(),
295            TransmissionValue::U128(data) => data.into_iter().map(|data| data.into()).collect(),
296            TransmissionValue::F32(data) => data.into_iter().map(|data| data.into()).collect(),
297            TransmissionValue::F64(data) => data.into_iter().map(|data| data.into()).collect(),
298            TransmissionValue::Bool(data) => data.into_iter().map(|data| data.into()).collect(),
299            TransmissionValue::Byte(data) => {
300                data.into_iter().map(|data| Value::Byte(data)).collect()
301            }
302            TransmissionValue::Char(data) => data.into_iter().map(|data| data.into()).collect(),
303            TransmissionValue::String(data) => data.into_iter().map(|data| data.into()).collect(),
304            TransmissionValue::Other(data) => data,
305        }
306    }
307}
308impl Into<Vec<Value>> for TransmissionValue {
309    fn into(self) -> Vec<Value> {
310        match self {
311            TransmissionValue::Void(data) => data.into_iter().map(|data| data.into()).collect(),
312            TransmissionValue::I8(data) => data.into_iter().map(|data| data.into()).collect(),
313            TransmissionValue::I16(data) => data.into_iter().map(|data| data.into()).collect(),
314            TransmissionValue::I32(data) => data.into_iter().map(|data| data.into()).collect(),
315            TransmissionValue::I64(data) => data.into_iter().map(|data| data.into()).collect(),
316            TransmissionValue::I128(data) => data.into_iter().map(|data| data.into()).collect(),
317            TransmissionValue::U8(data) => data.into_iter().map(|data| data.into()).collect(),
318            TransmissionValue::U16(data) => data.into_iter().map(|data| data.into()).collect(),
319            TransmissionValue::U32(data) => data.into_iter().map(|data| data.into()).collect(),
320            TransmissionValue::U64(data) => data.into_iter().map(|data| data.into()).collect(),
321            TransmissionValue::U128(data) => data.into_iter().map(|data| data.into()).collect(),
322            TransmissionValue::F32(data) => data.into_iter().map(|data| data.into()).collect(),
323            TransmissionValue::F64(data) => data.into_iter().map(|data| data.into()).collect(),
324            TransmissionValue::Bool(data) => data.into_iter().map(|data| data.into()).collect(),
325            TransmissionValue::Byte(data) => {
326                data.into_iter().map(|data| Value::Byte(data)).collect()
327            }
328            TransmissionValue::Char(data) => data.into_iter().map(|data| data.into()).collect(),
329            TransmissionValue::String(data) => data.into_iter().map(|data| data.into()).collect(),
330            TransmissionValue::Other(data) => data.into(),
331        }
332    }
333}
334
335impl From<VecDeque<()>> for TransmissionValue {
336    fn from(value: VecDeque<()>) -> Self {
337        TransmissionValue::Void(value)
338    }
339}
340
341impl From<Vec<()>> for TransmissionValue {
342    fn from(value: Vec<()>) -> Self {
343        TransmissionValue::Void(value.into())
344    }
345}
346
347impl TryInto<VecDeque<()>> for TransmissionValue {
348    type Error = ();
349
350    fn try_into(self) -> Result<VecDeque<()>, Self::Error> {
351        match self {
352            TransmissionValue::Void(data) => Ok(data),
353            TransmissionValue::Other(data) => {
354                let mut vec = VecDeque::with_capacity(data.len());
355                for val in data {
356                    if let Ok(val) = val.try_data() {
357                        vec.push_back(val);
358                    } else {
359                        return Err(());
360                    }
361                }
362                Ok(vec)
363            }
364            _ => Err(()),
365        }
366    }
367}
368
369impl TryInto<Vec<()>> for TransmissionValue {
370    type Error = ();
371
372    fn try_into(self) -> Result<Vec<()>, Self::Error> {
373        match self {
374            TransmissionValue::Void(data) => Ok(data.into()),
375            TransmissionValue::Other(data) => {
376                let mut vec = Vec::with_capacity(data.len());
377                for val in data {
378                    if let Ok(val) = val.try_data() {
379                        vec.push(val);
380                    } else {
381                        return Err(());
382                    }
383                }
384                Ok(vec)
385            }
386            _ => Err(()),
387        }
388    }
389}
390
391impl From<VecDeque<i8>> for TransmissionValue {
392    fn from(value: VecDeque<i8>) -> Self {
393        TransmissionValue::I8(value)
394    }
395}
396
397impl From<Vec<i8>> for TransmissionValue {
398    fn from(value: Vec<i8>) -> Self {
399        TransmissionValue::I8(value.into())
400    }
401}
402
403impl TryInto<VecDeque<i8>> for TransmissionValue {
404    type Error = ();
405
406    fn try_into(self) -> Result<VecDeque<i8>, Self::Error> {
407        match self {
408            TransmissionValue::I8(data) => Ok(data),
409            TransmissionValue::Other(data) => {
410                let mut vec = VecDeque::with_capacity(data.len());
411                for val in data {
412                    if let Ok(val) = val.try_data() {
413                        vec.push_back(val);
414                    } else {
415                        return Err(());
416                    }
417                }
418                Ok(vec)
419            }
420            _ => Err(()),
421        }
422    }
423}
424
425impl TryInto<Vec<i8>> for TransmissionValue {
426    type Error = ();
427
428    fn try_into(self) -> Result<Vec<i8>, Self::Error> {
429        match self {
430            TransmissionValue::I8(data) => Ok(data.into()),
431            TransmissionValue::Other(data) => {
432                let mut vec = Vec::with_capacity(data.len());
433                for val in data {
434                    if let Ok(val) = val.try_data() {
435                        vec.push(val);
436                    } else {
437                        return Err(());
438                    }
439                }
440                Ok(vec)
441            }
442            _ => Err(()),
443        }
444    }
445}
446
447impl From<VecDeque<i16>> for TransmissionValue {
448    fn from(value: VecDeque<i16>) -> Self {
449        TransmissionValue::I16(value)
450    }
451}
452
453impl From<Vec<i16>> for TransmissionValue {
454    fn from(value: Vec<i16>) -> Self {
455        TransmissionValue::I16(value.into())
456    }
457}
458
459impl TryInto<VecDeque<i16>> for TransmissionValue {
460    type Error = ();
461
462    fn try_into(self) -> Result<VecDeque<i16>, Self::Error> {
463        match self {
464            TransmissionValue::I16(data) => Ok(data),
465            TransmissionValue::Other(data) => {
466                let mut vec = VecDeque::with_capacity(data.len());
467                for val in data {
468                    if let Ok(val) = val.try_data() {
469                        vec.push_back(val);
470                    } else {
471                        return Err(());
472                    }
473                }
474                Ok(vec)
475            }
476            _ => Err(()),
477        }
478    }
479}
480
481impl TryInto<Vec<i16>> for TransmissionValue {
482    type Error = ();
483
484    fn try_into(self) -> Result<Vec<i16>, Self::Error> {
485        match self {
486            TransmissionValue::I16(data) => Ok(data.into()),
487            TransmissionValue::Other(data) => {
488                let mut vec = Vec::with_capacity(data.len());
489                for val in data {
490                    if let Ok(val) = val.try_data() {
491                        vec.push(val);
492                    } else {
493                        return Err(());
494                    }
495                }
496                Ok(vec)
497            }
498            _ => Err(()),
499        }
500    }
501}
502
503impl From<VecDeque<i32>> for TransmissionValue {
504    fn from(value: VecDeque<i32>) -> Self {
505        TransmissionValue::I32(value)
506    }
507}
508
509impl From<Vec<i32>> for TransmissionValue {
510    fn from(value: Vec<i32>) -> Self {
511        TransmissionValue::I32(value.into())
512    }
513}
514
515impl TryInto<VecDeque<i32>> for TransmissionValue {
516    type Error = ();
517
518    fn try_into(self) -> Result<VecDeque<i32>, Self::Error> {
519        match self {
520            TransmissionValue::I32(data) => Ok(data),
521            TransmissionValue::Other(data) => {
522                let mut vec = VecDeque::with_capacity(data.len());
523                for val in data {
524                    if let Ok(val) = val.try_data() {
525                        vec.push_back(val);
526                    } else {
527                        return Err(());
528                    }
529                }
530                Ok(vec)
531            }
532            _ => Err(()),
533        }
534    }
535}
536
537impl TryInto<Vec<i32>> for TransmissionValue {
538    type Error = ();
539
540    fn try_into(self) -> Result<Vec<i32>, Self::Error> {
541        match self {
542            TransmissionValue::I32(data) => Ok(data.into()),
543            TransmissionValue::Other(data) => {
544                let mut vec = Vec::with_capacity(data.len());
545                for val in data {
546                    if let Ok(val) = val.try_data() {
547                        vec.push(val);
548                    } else {
549                        return Err(());
550                    }
551                }
552                Ok(vec)
553            }
554            _ => Err(()),
555        }
556    }
557}
558
559impl From<VecDeque<i64>> for TransmissionValue {
560    fn from(value: VecDeque<i64>) -> Self {
561        TransmissionValue::I64(value)
562    }
563}
564
565impl From<Vec<i64>> for TransmissionValue {
566    fn from(value: Vec<i64>) -> Self {
567        TransmissionValue::I64(value.into())
568    }
569}
570
571impl TryInto<VecDeque<i64>> for TransmissionValue {
572    type Error = ();
573
574    fn try_into(self) -> Result<VecDeque<i64>, Self::Error> {
575        match self {
576            TransmissionValue::I64(data) => Ok(data),
577            TransmissionValue::Other(data) => {
578                let mut vec = VecDeque::with_capacity(data.len());
579                for val in data {
580                    if let Ok(val) = val.try_data() {
581                        vec.push_back(val);
582                    } else {
583                        return Err(());
584                    }
585                }
586                Ok(vec)
587            }
588            _ => Err(()),
589        }
590    }
591}
592
593impl TryInto<Vec<i64>> for TransmissionValue {
594    type Error = ();
595
596    fn try_into(self) -> Result<Vec<i64>, Self::Error> {
597        match self {
598            TransmissionValue::I64(data) => Ok(data.into()),
599            TransmissionValue::Other(data) => {
600                let mut vec = Vec::with_capacity(data.len());
601                for val in data {
602                    if let Ok(val) = val.try_data() {
603                        vec.push(val);
604                    } else {
605                        return Err(());
606                    }
607                }
608                Ok(vec)
609            }
610            _ => Err(()),
611        }
612    }
613}
614
615impl From<VecDeque<i128>> for TransmissionValue {
616    fn from(value: VecDeque<i128>) -> Self {
617        TransmissionValue::I128(value)
618    }
619}
620
621impl From<Vec<i128>> for TransmissionValue {
622    fn from(value: Vec<i128>) -> Self {
623        TransmissionValue::I128(value.into())
624    }
625}
626
627impl TryInto<VecDeque<i128>> for TransmissionValue {
628    type Error = ();
629
630    fn try_into(self) -> Result<VecDeque<i128>, Self::Error> {
631        match self {
632            TransmissionValue::I128(data) => Ok(data),
633            TransmissionValue::Other(data) => {
634                let mut vec = VecDeque::with_capacity(data.len());
635                for val in data {
636                    if let Ok(val) = val.try_data() {
637                        vec.push_back(val);
638                    } else {
639                        return Err(());
640                    }
641                }
642                Ok(vec)
643            }
644            _ => Err(()),
645        }
646    }
647}
648
649impl TryInto<Vec<i128>> for TransmissionValue {
650    type Error = ();
651
652    fn try_into(self) -> Result<Vec<i128>, Self::Error> {
653        match self {
654            TransmissionValue::I128(data) => Ok(data.into()),
655            TransmissionValue::Other(data) => {
656                let mut vec = Vec::with_capacity(data.len());
657                for val in data {
658                    if let Ok(val) = val.try_data() {
659                        vec.push(val);
660                    } else {
661                        return Err(());
662                    }
663                }
664                Ok(vec)
665            }
666            _ => Err(()),
667        }
668    }
669}
670
671impl From<VecDeque<u8>> for TransmissionValue {
672    fn from(value: VecDeque<u8>) -> Self {
673        TransmissionValue::U8(value)
674    }
675}
676
677impl From<Vec<u8>> for TransmissionValue {
678    fn from(value: Vec<u8>) -> Self {
679        TransmissionValue::U8(value.into())
680    }
681}
682
683impl TryInto<VecDeque<u8>> for TransmissionValue {
684    type Error = ();
685
686    fn try_into(self) -> Result<VecDeque<u8>, Self::Error> {
687        match self {
688            TransmissionValue::U8(data) => Ok(data),
689            TransmissionValue::Byte(data) => Ok(data),
690            TransmissionValue::Other(data) => {
691                let mut vec = VecDeque::with_capacity(data.len());
692                for val in data {
693                    if let Ok(val) = val.try_data() {
694                        vec.push_back(val);
695                    } else {
696                        return Err(());
697                    }
698                }
699                Ok(vec)
700            }
701            _ => Err(()),
702        }
703    }
704}
705
706impl TryInto<Vec<u8>> for TransmissionValue {
707    type Error = ();
708
709    fn try_into(self) -> Result<Vec<u8>, Self::Error> {
710        match self {
711            TransmissionValue::U8(data) => Ok(data.into()),
712            TransmissionValue::Byte(data) => Ok(data.into()),
713            TransmissionValue::Other(data) => {
714                let mut vec = Vec::with_capacity(data.len());
715                for val in data {
716                    if let Ok(val) = val.try_data() {
717                        vec.push(val);
718                    } else {
719                        return Err(());
720                    }
721                }
722                Ok(vec)
723            }
724            _ => Err(()),
725        }
726    }
727}
728
729impl From<VecDeque<u16>> for TransmissionValue {
730    fn from(value: VecDeque<u16>) -> Self {
731        TransmissionValue::U16(value)
732    }
733}
734
735impl From<Vec<u16>> for TransmissionValue {
736    fn from(value: Vec<u16>) -> Self {
737        TransmissionValue::U16(value.into())
738    }
739}
740
741impl TryInto<VecDeque<u16>> for TransmissionValue {
742    type Error = ();
743
744    fn try_into(self) -> Result<VecDeque<u16>, Self::Error> {
745        match self {
746            TransmissionValue::U16(data) => Ok(data),
747            TransmissionValue::Other(data) => {
748                let mut vec = VecDeque::with_capacity(data.len());
749                for val in data {
750                    if let Ok(val) = val.try_data() {
751                        vec.push_back(val);
752                    } else {
753                        return Err(());
754                    }
755                }
756                Ok(vec)
757            }
758            _ => Err(()),
759        }
760    }
761}
762
763impl TryInto<Vec<u16>> for TransmissionValue {
764    type Error = ();
765
766    fn try_into(self) -> Result<Vec<u16>, Self::Error> {
767        match self {
768            TransmissionValue::U16(data) => Ok(data.into()),
769            TransmissionValue::Other(data) => {
770                let mut vec = Vec::with_capacity(data.len());
771                for val in data {
772                    if let Ok(val) = val.try_data() {
773                        vec.push(val);
774                    } else {
775                        return Err(());
776                    }
777                }
778                Ok(vec)
779            }
780            _ => Err(()),
781        }
782    }
783}
784
785impl From<VecDeque<u32>> for TransmissionValue {
786    fn from(value: VecDeque<u32>) -> Self {
787        TransmissionValue::U32(value)
788    }
789}
790
791impl From<Vec<u32>> for TransmissionValue {
792    fn from(value: Vec<u32>) -> Self {
793        TransmissionValue::U32(value.into())
794    }
795}
796
797impl TryInto<VecDeque<u32>> for TransmissionValue {
798    type Error = ();
799
800    fn try_into(self) -> Result<VecDeque<u32>, Self::Error> {
801        match self {
802            TransmissionValue::U32(data) => Ok(data),
803            TransmissionValue::Other(data) => {
804                let mut vec = VecDeque::with_capacity(data.len());
805                for val in data {
806                    if let Ok(val) = val.try_data() {
807                        vec.push_back(val);
808                    } else {
809                        return Err(());
810                    }
811                }
812                Ok(vec)
813            }
814            _ => Err(()),
815        }
816    }
817}
818
819impl TryInto<Vec<u32>> for TransmissionValue {
820    type Error = ();
821
822    fn try_into(self) -> Result<Vec<u32>, Self::Error> {
823        match self {
824            TransmissionValue::U32(data) => Ok(data.into()),
825            TransmissionValue::Other(data) => {
826                let mut vec = Vec::with_capacity(data.len());
827                for val in data {
828                    if let Ok(val) = val.try_data() {
829                        vec.push(val);
830                    } else {
831                        return Err(());
832                    }
833                }
834                Ok(vec)
835            }
836            _ => Err(()),
837        }
838    }
839}
840
841impl From<VecDeque<u64>> for TransmissionValue {
842    fn from(value: VecDeque<u64>) -> Self {
843        TransmissionValue::U64(value)
844    }
845}
846
847impl From<Vec<u64>> for TransmissionValue {
848    fn from(value: Vec<u64>) -> Self {
849        TransmissionValue::U64(value.into())
850    }
851}
852
853impl TryInto<VecDeque<u64>> for TransmissionValue {
854    type Error = ();
855
856    fn try_into(self) -> Result<VecDeque<u64>, Self::Error> {
857        match self {
858            TransmissionValue::U64(data) => Ok(data),
859            TransmissionValue::Other(data) => {
860                let mut vec = VecDeque::with_capacity(data.len());
861                for val in data {
862                    if let Ok(val) = val.try_data() {
863                        vec.push_back(val);
864                    } else {
865                        return Err(());
866                    }
867                }
868                Ok(vec)
869            }
870            _ => Err(()),
871        }
872    }
873}
874
875impl TryInto<Vec<u64>> for TransmissionValue {
876    type Error = ();
877
878    fn try_into(self) -> Result<Vec<u64>, Self::Error> {
879        match self {
880            TransmissionValue::U64(data) => Ok(data.into()),
881            TransmissionValue::Other(data) => {
882                let mut vec = Vec::with_capacity(data.len());
883                for val in data {
884                    if let Ok(val) = val.try_data() {
885                        vec.push(val);
886                    } else {
887                        return Err(());
888                    }
889                }
890                Ok(vec)
891            }
892            _ => Err(()),
893        }
894    }
895}
896
897impl From<VecDeque<u128>> for TransmissionValue {
898    fn from(value: VecDeque<u128>) -> Self {
899        TransmissionValue::U128(value)
900    }
901}
902
903impl From<Vec<u128>> for TransmissionValue {
904    fn from(value: Vec<u128>) -> Self {
905        TransmissionValue::U128(value.into())
906    }
907}
908
909impl TryInto<VecDeque<u128>> for TransmissionValue {
910    type Error = ();
911
912    fn try_into(self) -> Result<VecDeque<u128>, Self::Error> {
913        match self {
914            TransmissionValue::U128(data) => Ok(data),
915            TransmissionValue::Other(data) => {
916                let mut vec = VecDeque::with_capacity(data.len());
917                for val in data {
918                    if let Ok(val) = val.try_data() {
919                        vec.push_back(val);
920                    } else {
921                        return Err(());
922                    }
923                }
924                Ok(vec)
925            }
926            _ => Err(()),
927        }
928    }
929}
930
931impl TryInto<Vec<u128>> for TransmissionValue {
932    type Error = ();
933
934    fn try_into(self) -> Result<Vec<u128>, Self::Error> {
935        match self {
936            TransmissionValue::U128(data) => Ok(data.into()),
937            TransmissionValue::Other(data) => {
938                let mut vec = Vec::with_capacity(data.len());
939                for val in data {
940                    if let Ok(val) = val.try_data() {
941                        vec.push(val);
942                    } else {
943                        return Err(());
944                    }
945                }
946                Ok(vec)
947            }
948            _ => Err(()),
949        }
950    }
951}
952
953impl From<VecDeque<f32>> for TransmissionValue {
954    fn from(value: VecDeque<f32>) -> Self {
955        TransmissionValue::F32(value)
956    }
957}
958
959impl From<Vec<f32>> for TransmissionValue {
960    fn from(value: Vec<f32>) -> Self {
961        TransmissionValue::F32(value.into())
962    }
963}
964
965impl TryInto<VecDeque<f32>> for TransmissionValue {
966    type Error = ();
967
968    fn try_into(self) -> Result<VecDeque<f32>, Self::Error> {
969        match self {
970            TransmissionValue::F32(data) => Ok(data),
971            TransmissionValue::Other(data) => {
972                let mut vec = VecDeque::with_capacity(data.len());
973                for val in data {
974                    if let Ok(val) = val.try_data() {
975                        vec.push_back(val);
976                    } else {
977                        return Err(());
978                    }
979                }
980                Ok(vec)
981            }
982            _ => Err(()),
983        }
984    }
985}
986
987impl TryInto<Vec<f32>> for TransmissionValue {
988    type Error = ();
989
990    fn try_into(self) -> Result<Vec<f32>, Self::Error> {
991        match self {
992            TransmissionValue::F32(data) => Ok(data.into()),
993            TransmissionValue::Other(data) => {
994                let mut vec = Vec::with_capacity(data.len());
995                for val in data {
996                    if let Ok(val) = val.try_data() {
997                        vec.push(val);
998                    } else {
999                        return Err(());
1000                    }
1001                }
1002                Ok(vec)
1003            }
1004            _ => Err(()),
1005        }
1006    }
1007}
1008
1009impl From<VecDeque<f64>> for TransmissionValue {
1010    fn from(value: VecDeque<f64>) -> Self {
1011        TransmissionValue::F64(value)
1012    }
1013}
1014
1015impl From<Vec<f64>> for TransmissionValue {
1016    fn from(value: Vec<f64>) -> Self {
1017        TransmissionValue::F64(value.into())
1018    }
1019}
1020
1021impl TryInto<VecDeque<f64>> for TransmissionValue {
1022    type Error = ();
1023
1024    fn try_into(self) -> Result<VecDeque<f64>, Self::Error> {
1025        match self {
1026            TransmissionValue::F64(data) => Ok(data),
1027            TransmissionValue::Other(data) => {
1028                let mut vec = VecDeque::with_capacity(data.len());
1029                for val in data {
1030                    if let Ok(val) = val.try_data() {
1031                        vec.push_back(val);
1032                    } else {
1033                        return Err(());
1034                    }
1035                }
1036                Ok(vec)
1037            }
1038            _ => Err(()),
1039        }
1040    }
1041}
1042
1043impl TryInto<Vec<f64>> for TransmissionValue {
1044    type Error = ();
1045
1046    fn try_into(self) -> Result<Vec<f64>, Self::Error> {
1047        match self {
1048            TransmissionValue::F64(data) => Ok(data.into()),
1049            TransmissionValue::Other(data) => {
1050                let mut vec = Vec::with_capacity(data.len());
1051                for val in data {
1052                    if let Ok(val) = val.try_data() {
1053                        vec.push(val);
1054                    } else {
1055                        return Err(());
1056                    }
1057                }
1058                Ok(vec)
1059            }
1060            _ => Err(()),
1061        }
1062    }
1063}
1064
1065impl From<VecDeque<bool>> for TransmissionValue {
1066    fn from(value: VecDeque<bool>) -> Self {
1067        TransmissionValue::Bool(value)
1068    }
1069}
1070
1071impl From<Vec<bool>> for TransmissionValue {
1072    fn from(value: Vec<bool>) -> Self {
1073        TransmissionValue::Bool(value.into())
1074    }
1075}
1076
1077impl TryInto<VecDeque<bool>> for TransmissionValue {
1078    type Error = ();
1079
1080    fn try_into(self) -> Result<VecDeque<bool>, Self::Error> {
1081        match self {
1082            TransmissionValue::Bool(data) => Ok(data),
1083            TransmissionValue::Other(data) => {
1084                let mut vec = VecDeque::with_capacity(data.len());
1085                for val in data {
1086                    if let Ok(val) = val.try_data() {
1087                        vec.push_back(val);
1088                    } else {
1089                        return Err(());
1090                    }
1091                }
1092                Ok(vec)
1093            }
1094            _ => Err(()),
1095        }
1096    }
1097}
1098
1099impl TryInto<Vec<bool>> for TransmissionValue {
1100    type Error = ();
1101
1102    fn try_into(self) -> Result<Vec<bool>, Self::Error> {
1103        match self {
1104            TransmissionValue::Bool(data) => Ok(data.into()),
1105            TransmissionValue::Other(data) => {
1106                let mut vec = Vec::with_capacity(data.len());
1107                for val in data {
1108                    if let Ok(val) = val.try_data() {
1109                        vec.push(val);
1110                    } else {
1111                        return Err(());
1112                    }
1113                }
1114                Ok(vec)
1115            }
1116            _ => Err(()),
1117        }
1118    }
1119}
1120
1121impl From<VecDeque<char>> for TransmissionValue {
1122    fn from(value: VecDeque<char>) -> Self {
1123        TransmissionValue::Char(value)
1124    }
1125}
1126
1127impl From<Vec<char>> for TransmissionValue {
1128    fn from(value: Vec<char>) -> Self {
1129        TransmissionValue::Char(value.into())
1130    }
1131}
1132
1133impl TryInto<VecDeque<char>> for TransmissionValue {
1134    type Error = ();
1135
1136    fn try_into(self) -> Result<VecDeque<char>, Self::Error> {
1137        match self {
1138            TransmissionValue::Char(data) => Ok(data),
1139            TransmissionValue::Other(data) => {
1140                let mut vec = VecDeque::with_capacity(data.len());
1141                for val in data {
1142                    if let Ok(val) = val.try_data() {
1143                        vec.push_back(val);
1144                    } else {
1145                        return Err(());
1146                    }
1147                }
1148                Ok(vec)
1149            }
1150            _ => Err(()),
1151        }
1152    }
1153}
1154
1155impl TryInto<Vec<char>> for TransmissionValue {
1156    type Error = ();
1157
1158    fn try_into(self) -> Result<Vec<char>, Self::Error> {
1159        match self {
1160            TransmissionValue::Char(data) => Ok(data.into()),
1161            TransmissionValue::Other(data) => {
1162                let mut vec = Vec::with_capacity(data.len());
1163                for val in data {
1164                    if let Ok(val) = val.try_data() {
1165                        vec.push(val);
1166                    } else {
1167                        return Err(());
1168                    }
1169                }
1170                Ok(vec)
1171            }
1172            _ => Err(()),
1173        }
1174    }
1175}
1176
1177impl From<VecDeque<String>> for TransmissionValue {
1178    fn from(value: VecDeque<String>) -> Self {
1179        TransmissionValue::String(value)
1180    }
1181}
1182
1183impl From<Vec<String>> for TransmissionValue {
1184    fn from(value: Vec<String>) -> Self {
1185        TransmissionValue::String(value.into())
1186    }
1187}
1188
1189impl TryInto<VecDeque<String>> for TransmissionValue {
1190    type Error = ();
1191
1192    fn try_into(self) -> Result<VecDeque<String>, Self::Error> {
1193        match self {
1194            TransmissionValue::String(data) => Ok(data),
1195            TransmissionValue::Other(data) => {
1196                let mut vec = VecDeque::with_capacity(data.len());
1197                for val in data {
1198                    if let Ok(val) = val.try_data() {
1199                        vec.push_back(val);
1200                    } else {
1201                        return Err(());
1202                    }
1203                }
1204                Ok(vec)
1205            }
1206            _ => Err(()),
1207        }
1208    }
1209}
1210
1211impl TryInto<Vec<String>> for TransmissionValue {
1212    type Error = ();
1213
1214    fn try_into(self) -> Result<Vec<String>, Self::Error> {
1215        match self {
1216            TransmissionValue::String(data) => Ok(data.into()),
1217            TransmissionValue::Other(data) => {
1218                let mut vec = Vec::with_capacity(data.len());
1219                for val in data {
1220                    if let Ok(val) = val.try_data() {
1221                        vec.push(val);
1222                    } else {
1223                        return Err(());
1224                    }
1225                }
1226                Ok(vec)
1227            }
1228            _ => Err(()),
1229        }
1230    }
1231}
melodium_common/executive/transmission.rs

melodium_common/executive/
transmission.rs
