1use crate::{traits::IntoFrcValue, FrcTimestampedValue, FrcValue, error::{CastErrorReason, FrcValueError}};
2
3impl From<f64> for FrcValue {
4 fn from(v: f64) -> Self {
5 FrcValue::Double(v)
6 }
7}
8impl From<f32> for FrcValue {
9 fn from(v: f32) -> Self {
10 FrcValue::Float(v)
11 }
12}
13impl From<i64> for FrcValue {
14 fn from(v: i64) -> Self {
15 FrcValue::Int(v)
16 }
17}
18impl From<i32> for FrcValue {
19 fn from(v: i32) -> Self {
20 FrcValue::Int(v as i64)
21 }
22}
23impl From<i16> for FrcValue {
24 fn from(v: i16) -> Self {
25 FrcValue::Int(v as i64)
26 }
27}
28impl From<i8> for FrcValue {
29 fn from(v: i8) -> Self {
30 FrcValue::Int(v as i64)
31 }
32}
33impl From<u64> for FrcValue {
34 fn from(v: u64) -> Self {
35 FrcValue::Int(v as i64)
36 }
37}
38impl From<u32> for FrcValue {
39 fn from(v: u32) -> Self {
40 FrcValue::Int(v as i64)
41 }
42}
43impl From<u16> for FrcValue {
44 fn from(v: u16) -> Self {
45 FrcValue::Int(v as i64)
46 }
47}
48impl From<u8> for FrcValue {
49 fn from(v: u8) -> Self {
50 FrcValue::Int(v as i64)
51 }
52}
53impl From<bool> for FrcValue {
54 fn from(v: bool) -> Self {
55 FrcValue::Boolean(v)
56 }
57}
58impl From<String> for FrcValue {
59 fn from(v: String) -> Self {
60 FrcValue::String(v)
61 }
62}
63impl From<&str> for FrcValue {
64 fn from(v: &str) -> Self {
65 FrcValue::String(v.to_string())
66 }
67}
68impl From<Vec<bool>> for FrcValue {
69 fn from(v: Vec<bool>) -> Self {
70 FrcValue::BooleanArray(v)
71 }
72}
73impl From<Vec<i64>> for FrcValue {
74 fn from(v: Vec<i64>) -> Self {
75 FrcValue::IntArray(v)
76 }
77}
78impl From<Vec<i32>> for FrcValue {
79 fn from(v: Vec<i32>) -> Self {
80 FrcValue::IntArray(v.iter().map(|v| *v as i64).collect())
81 }
82}
83impl From<Vec<u64>> for FrcValue {
84 fn from(v: Vec<u64>) -> Self {
85 FrcValue::IntArray(v.iter().map(|v| *v as i64).collect())
86 }
87}
88impl From<Vec<u32>> for FrcValue {
89 fn from(v: Vec<u32>) -> Self {
90 FrcValue::IntArray(v.iter().map(|v| *v as i64).collect())
91 }
92}
93impl From<Vec<f32>> for FrcValue {
94 fn from(v: Vec<f32>) -> Self {
95 FrcValue::FloatArray(v)
96 }
97}
98impl From<Vec<f64>> for FrcValue {
99 fn from(v: Vec<f64>) -> Self {
100 FrcValue::DoubleArray(v)
101 }
102}
103impl From<Vec<String>> for FrcValue {
104 fn from(v: Vec<String>) -> Self {
105 FrcValue::StringArray(v)
106 }
107}
108impl From<Vec<&str>> for FrcValue {
109 fn from(v: Vec<&str>) -> Self {
110 FrcValue::StringArray(v.iter().map(|s| s.to_string()).collect())
111 }
112}
113
114impl Into<FrcValue> for FrcTimestampedValue {
115 fn into(self) -> FrcValue {
116 self.value
117 }
118}
119
120impl<T: Into<FrcValue>> IntoFrcValue for T {
121 fn into_frc_value(self) -> FrcValue {
122 self.into()
123 }
124}
125
126impl TryFrom<FrcValue> for f64 {
127 type Error = crate::FrcValueError;
128 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
129 match value {
130 FrcValue::Double(v) => Ok(v),
131 FrcValue::Float(v) => Ok(v as f64),
132 _ => Err(FrcValueError::InvalidCast(
133 value.get_type(),
134 stringify!(f64),
135 CastErrorReason::Type
136 )),
137 }
138 }
139}
140
141impl TryFrom<FrcValue> for f32 {
142 type Error = crate::FrcValueError;
143 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
144 match value {
145 FrcValue::Double(v) => {
146 if v > f32::MAX as f64 {
147 Err(FrcValueError::InvalidCast(
148 value.get_type(),
149 stringify!(f32),
150 CastErrorReason::Overflow
151 ))
152 } else if v < f32::MIN as f64 {
153 Err(FrcValueError::InvalidCast(
154 value.get_type(),
155 stringify!(f32),
156 CastErrorReason::Underflow
157 ))
158 } else {
159 Ok(v as f32)
160 }
161 },
162 FrcValue::Float(v) => Ok(v),
163 _ => Err(FrcValueError::InvalidCast(
164 value.get_type(),
165 stringify!(f32),
166 CastErrorReason::Type
167 ))
168 }
169 }
170}
171
172impl TryFrom<FrcValue> for i64 {
173 type Error = crate::FrcValueError;
174 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
175 match value {
176 FrcValue::Int(v) => Ok(v),
177 _ => Err(FrcValueError::InvalidCast(
178 value.get_type(),
179 stringify!(i64),
180 CastErrorReason::Type
181 )),
182 }
183 }
184}
185
186impl TryFrom<FrcValue> for i32 {
187 type Error = crate::FrcValueError;
188 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
189 match value {
190 FrcValue::Int(v) => {
191 if v > i32::MAX as i64 {
192 Err(FrcValueError::InvalidCast(
193 value.get_type(),
194 stringify!(i32),
195 CastErrorReason::Overflow
196 ))
197 } else if v < i32::MIN as i64 {
198 Err(FrcValueError::InvalidCast(
199 value.get_type(),
200 stringify!(i32),
201 CastErrorReason::Underflow
202 ))
203 } else {
204 Ok(v as i32)
205 }
206 },
207 _ => Err(FrcValueError::InvalidCast(
208 value.get_type(),
209 stringify!(i32),
210 CastErrorReason::Type
211 ))
212 }
213 }
214}
215
216impl TryFrom<FrcValue> for i16 {
217 type Error = crate::FrcValueError;
218 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
219 match value {
220 FrcValue::Int(v) => {
221 if v > i16::MAX as i64 {
222 Err(FrcValueError::InvalidCast(
223 value.get_type(),
224 stringify!(i16),
225 CastErrorReason::Overflow
226 ))
227 } else if v < i16::MIN as i64 {
228 Err(FrcValueError::InvalidCast(
229 value.get_type(),
230 stringify!(i16),
231 CastErrorReason::Underflow
232 ))
233 } else {
234 Ok(v as i16)
235 }
236 },
237 _ => Err(FrcValueError::InvalidCast(
238 value.get_type(),
239 stringify!(i16),
240 CastErrorReason::Type
241 ))
242 }
243 }
244}
245
246impl TryFrom<FrcValue> for i8 {
247 type Error = crate::FrcValueError;
248 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
249 match value {
250 FrcValue::Int(v) => {
251 if v > i8::MAX as i64 {
252 Err(FrcValueError::InvalidCast(
253 value.get_type(),
254 stringify!(i8),
255 CastErrorReason::Overflow
256 ))
257 } else if v < i8::MIN as i64 {
258 Err(FrcValueError::InvalidCast(
259 value.get_type(),
260 stringify!(i8),
261 CastErrorReason::Underflow
262 ))
263 } else {
264 Ok(v as i8)
265 }
266 },
267 _ => Err(FrcValueError::InvalidCast(
268 value.get_type(),
269 stringify!(i8),
270 CastErrorReason::Type
271 ))
272 }
273 }
274}
275
276impl TryFrom<FrcValue> for u64 {
277 type Error = crate::FrcValueError;
278 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
279 match value {
280 FrcValue::Int(v) => {
281 if v < 0 {
282 Err(FrcValueError::InvalidCast(
283 value.get_type(),
284 stringify!(u64),
285 CastErrorReason::Underflow
286 ))
287 } else {
288 Ok(v as u64)
289 }
290 },
291 _ => Err(FrcValueError::InvalidCast(
292 value.get_type(),
293 stringify!(u64),
294 CastErrorReason::Type
295 ))
296 }
297 }
298}
299
300impl TryFrom<FrcValue> for u32 {
301 type Error = crate::FrcValueError;
302 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
303 match value {
304 FrcValue::Int(v) => {
305 if v < 0 {
306 Err(FrcValueError::InvalidCast(
307 value.get_type(),
308 stringify!(u32),
309 CastErrorReason::Underflow
310 ))
311 } else if v > u32::MAX as i64 {
312 Err(FrcValueError::InvalidCast(
313 value.get_type(),
314 stringify!(u32),
315 CastErrorReason::Overflow
316 ))
317 } else {
318 Ok(v as u32)
319 }
320 },
321 _ => Err(FrcValueError::InvalidCast(
322 value.get_type(),
323 stringify!(u32),
324 CastErrorReason::Type
325 ))
326 }
327 }
328}
329
330impl TryFrom<FrcValue> for u16 {
331 type Error = crate::FrcValueError;
332 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
333 match value {
334 FrcValue::Int(v) => {
335 if v < 0 {
336 Err(FrcValueError::InvalidCast(
337 value.get_type(),
338 stringify!(u16),
339 CastErrorReason::Underflow
340 ))
341 } else if v > u16::MAX as i64 {
342 Err(FrcValueError::InvalidCast(
343 value.get_type(),
344 stringify!(u16),
345 CastErrorReason::Overflow
346 ))
347 } else {
348 Ok(v as u16)
349 }
350 },
351 _ => Err(FrcValueError::InvalidCast(
352 value.get_type(),
353 stringify!(u16),
354 CastErrorReason::Type
355 ))
356 }
357 }
358}
359
360impl TryFrom<FrcValue> for u8 {
361 type Error = crate::FrcValueError;
362 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
363 match value {
364 FrcValue::Int(v) => {
365 if v < 0 {
366 Err(FrcValueError::InvalidCast(
367 value.get_type(),
368 stringify!(u8),
369 CastErrorReason::Underflow
370 ))
371 } else if v > u8::MAX as i64 {
372 Err(FrcValueError::InvalidCast(
373 value.get_type(),
374 stringify!(u8),
375 CastErrorReason::Overflow
376 ))
377 } else {
378 Ok(v as u8)
379 }
380 },
381 _ => Err(FrcValueError::InvalidCast(
382 value.get_type(),
383 stringify!(u8),
384 CastErrorReason::Type
385 ))
386 }
387 }
388}
389
390impl TryFrom<FrcValue> for bool {
391 type Error = crate::FrcValueError;
392 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
393 match value {
394 FrcValue::Boolean(v) => Ok(v),
395 _ => Err(FrcValueError::InvalidCast(
396 value.get_type(),
397 stringify!(bool),
398 CastErrorReason::Type
399 )),
400 }
401 }
402}
403
404impl TryFrom<FrcValue> for String {
405 type Error = crate::FrcValueError;
406 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
407 match value {
408 FrcValue::String(v) => Ok(v),
409 _ => Err(FrcValueError::InvalidCast(
410 value.get_type(),
411 stringify!(String),
412 CastErrorReason::Type
413 )),
414 }
415 }
416}
417
418impl TryFrom<FrcValue> for Vec<f64> {
419 type Error = crate::FrcValueError;
420 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
421 match value {
422 FrcValue::DoubleArray(va) => Ok(va),
423 FrcValue::FloatArray(va) => Ok(
424 va.into_iter().map(|v| v as f64).collect()
425 ),
426 _ => Err(FrcValueError::InvalidCast(
427 value.get_type(),
428 stringify!(Vec<f64>),
429 CastErrorReason::Type
430 )),
431 }
432 }
433}
434
435impl TryFrom<FrcValue> for Vec<f32> {
436 type Error = crate::FrcValueError;
437 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
438 match value {
439 FrcValue::DoubleArray(ref va) => {
440 let mut ret_vec = Vec::with_capacity(va.len());
441 for v in va {
442 if *v > f32::MAX as f64 {
443 return Err(FrcValueError::InvalidCast(
444 value.get_type(),
445 stringify!(Vec<f32>),
446 CastErrorReason::Overflow
447 ))
448 } else if *v < f32::MIN as f64 {
449 return Err(FrcValueError::InvalidCast(
450 value.get_type(),
451 stringify!(Vec<f32>),
452 CastErrorReason::Underflow
453 ))
454 } else {
455 ret_vec.push(*v as f32);
456 }
457 }
458 Ok(ret_vec)
459 }
460 FrcValue::FloatArray(v) => Ok(v),
461 _ => Err(FrcValueError::InvalidCast(
462 value.get_type(),
463 stringify!(Vec<f32>),
464 CastErrorReason::Type
465 )),
466 }
467 }
468}
469
470impl TryFrom<FrcValue> for Vec<i64> {
471 type Error = crate::FrcValueError;
472 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
473 match value {
474 FrcValue::IntArray(va) => Ok(va),
475 _ => Err(FrcValueError::InvalidCast(
476 value.get_type(),
477 stringify!(Vec<i64>),
478 CastErrorReason::Type
479 )),
480 }
481 }
482}
483
484impl TryFrom<FrcValue> for Vec<i32> {
485 type Error = crate::FrcValueError;
486 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
487 match value {
488 FrcValue::IntArray(ref va) => {
489 let mut ret_vec = Vec::with_capacity(va.len());
490 for v in va {
491 if *v > i32::MAX as i64 {
492 return Err(FrcValueError::InvalidCast(
493 value.get_type(),
494 stringify!(Vec<i32>),
495 CastErrorReason::Overflow
496 ))
497 } else if *v < i32::MIN as i64 {
498 return Err(FrcValueError::InvalidCast(
499 value.get_type(),
500 stringify!(Vec<i32>),
501 CastErrorReason::Underflow
502 ))
503 } else {
504 ret_vec.push(*v as i32);
505 }
506 }
507 Ok(ret_vec)
508 }
509 _ => Err(FrcValueError::InvalidCast(
510 value.get_type(),
511 stringify!(Vec<i32>),
512 CastErrorReason::Type
513 )),
514 }
515 }
516}
517
518impl TryFrom<FrcValue> for Vec<i16> {
519 type Error = crate::FrcValueError;
520 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
521 match value {
522 FrcValue::IntArray(ref va) => {
523 let mut ret_vec = Vec::with_capacity(va.len());
524 for v in va {
525 if *v > i16::MAX as i64 {
526 return Err(FrcValueError::InvalidCast(
527 value.get_type(),
528 stringify!(Vec<i16>),
529 CastErrorReason::Overflow
530 ))
531 } else if *v < i16::MIN as i64 {
532 return Err(FrcValueError::InvalidCast(
533 value.get_type(),
534 stringify!(Vec<i16>),
535 CastErrorReason::Underflow
536 ))
537 } else {
538 ret_vec.push(*v as i16);
539 }
540 }
541 Ok(ret_vec)
542 }
543 _ => Err(FrcValueError::InvalidCast(
544 value.get_type(),
545 stringify!(Vec<i16>),
546 CastErrorReason::Type
547 )),
548 }
549 }
550}
551
552impl TryFrom<FrcValue> for Vec<i8> {
553 type Error = crate::FrcValueError;
554 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
555 match value {
556 FrcValue::IntArray(ref va) => {
557 let mut ret_vec = Vec::with_capacity(va.len());
558 for v in va {
559 if *v > i8::MAX as i64 {
560 return Err(FrcValueError::InvalidCast(
561 value.get_type(),
562 stringify!(Vec<i8>),
563 CastErrorReason::Overflow
564 ))
565 } else if *v < i8::MIN as i64 {
566 return Err(FrcValueError::InvalidCast(
567 value.get_type(),
568 stringify!(Vec<i8>),
569 CastErrorReason::Underflow
570 ))
571 } else {
572 ret_vec.push(*v as i8);
573 }
574 }
575 Ok(ret_vec)
576 }
577 _ => Err(FrcValueError::InvalidCast(
578 value.get_type(),
579 stringify!(Vec<i8>),
580 CastErrorReason::Type
581 )),
582 }
583 }
584}
585
586impl TryFrom<FrcValue> for Vec<u64> {
587 type Error = crate::FrcValueError;
588 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
589 match value {
590 FrcValue::IntArray(ref va) => {
591 let mut ret_vec = Vec::with_capacity(va.len());
592 for v in va {
593 if *v < 0 {
594 return Err(FrcValueError::InvalidCast(
595 value.get_type(),
596 stringify!(Vec<u64>),
597 CastErrorReason::Underflow
598 ))
599 } else {
600 ret_vec.push(*v as u64);
601 }
602 }
603 Ok(ret_vec)
604 }
605 _ => Err(FrcValueError::InvalidCast(
606 value.get_type(),
607 stringify!(Vec<u64>),
608 CastErrorReason::Type
609 )),
610 }
611 }
612}
613
614impl TryFrom<FrcValue> for Vec<u32> {
615 type Error = crate::FrcValueError;
616 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
617 match value {
618 FrcValue::IntArray(ref va) => {
619 let mut ret_vec = Vec::with_capacity(va.len());
620 for v in va {
621 if *v < 0 {
622 return Err(FrcValueError::InvalidCast(
623 value.get_type(),
624 stringify!(Vec<u32>),
625 CastErrorReason::Underflow
626 ))
627 } else if *v > u32::MAX as i64 {
628 return Err(FrcValueError::InvalidCast(
629 value.get_type(),
630 stringify!(Vec<u32>),
631 CastErrorReason::Overflow
632 ))
633 } else {
634 ret_vec.push(*v as u32);
635 }
636 }
637 Ok(ret_vec)
638 }
639 _ => Err(FrcValueError::InvalidCast(
640 value.get_type(),
641 stringify!(Vec<u32>),
642 CastErrorReason::Type
643 )),
644 }
645 }
646}
647
648impl TryFrom<FrcValue> for Vec<u16> {
649 type Error = crate::FrcValueError;
650 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
651 match value {
652 FrcValue::IntArray(ref va) => {
653 let mut ret_vec = Vec::with_capacity(va.len());
654 for v in va {
655 if *v < 0 {
656 return Err(FrcValueError::InvalidCast(
657 value.get_type(),
658 stringify!(Vec<u16>),
659 CastErrorReason::Underflow
660 ))
661 } else if *v > u16::MAX as i64 {
662 return Err(FrcValueError::InvalidCast(
663 value.get_type(),
664 stringify!(Vec<u16>),
665 CastErrorReason::Overflow
666 ))
667 } else {
668 ret_vec.push(*v as u16);
669 }
670 }
671 Ok(ret_vec)
672 }
673 _ => Err(FrcValueError::InvalidCast(
674 value.get_type(),
675 stringify!(Vec<u16>),
676 CastErrorReason::Type
677 )),
678 }
679 }
680}
681
682impl TryFrom<FrcValue> for Vec<u8> {
683 type Error = crate::FrcValueError;
684 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
685 match value {
686 FrcValue::IntArray(ref va) => {
687 let mut ret_vec = Vec::with_capacity(va.len());
688 for v in va {
689 if *v < 0 {
690 return Err(FrcValueError::InvalidCast(
691 value.get_type(),
692 stringify!(Vec<u8>),
693 CastErrorReason::Underflow
694 ))
695 } else if *v > u8::MAX as i64 {
696 return Err(FrcValueError::InvalidCast(
697 value.get_type(),
698 stringify!(Vec<u8>),
699 CastErrorReason::Overflow
700 ))
701 } else {
702 ret_vec.push(*v as u8);
703 }
704 }
705 Ok(ret_vec)
706 }
707 _ => Err(FrcValueError::InvalidCast(
708 value.get_type(),
709 stringify!(Vec<u8>),
710 CastErrorReason::Type
711 )),
712 }
713 }
714}
715
716impl TryFrom<FrcValue> for Vec<bool> {
717 type Error = crate::FrcValueError;
718 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
719 match value {
720 FrcValue::BooleanArray(va) => Ok(va),
721 _ => Err(FrcValueError::InvalidCast(
722 value.get_type(),
723 stringify!(Vec<bool>),
724 CastErrorReason::Type
725 )),
726 }
727 }
728}
729
730impl TryFrom<FrcValue> for Vec<String> {
731 type Error = crate::FrcValueError;
732 fn try_from(value: FrcValue) -> Result<Self, Self::Error> {
733 match value {
734 FrcValue::StringArray(va) => Ok(va),
735 _ => Err(FrcValueError::InvalidCast(
736 value.get_type(),
737 stringify!(Vec<String>),
738 CastErrorReason::Type
739 )),
740 }
741 }
742}
743
744
745
746
747
748#[cfg(feature = "rmpv-casting")]
749use crate::FrcType;
750
751#[cfg(feature = "rmpv-casting")]
752impl From<rmpv::Value> for FrcValue {
753 fn from(value: rmpv::Value) -> Self {
754 match value {
755 rmpv::Value::Boolean(b) => Self::Boolean(b),
756 rmpv::Value::Integer(i) => Self::Int(i.as_i64().unwrap_or_default()),
757 rmpv::Value::F32(f) => Self::Float(f),
758 rmpv::Value::F64(f) => Self::Double(f),
759 rmpv::Value::String(s) => Self::String(s.to_string()),
760 rmpv::Value::Binary(b) => Self::Binary(crate::FrcBinaryFormats::MsgPack(b)),
761 rmpv::Value::Array(a) => {
762 let mut arr = Vec::with_capacity(a.len());
763 for v in a {
764 arr.push(Self::from(v));
765 }
766 if arr.len() == 0 {
767 Self::empty()
768 } else {
769 match arr[0].get_type() {
770 FrcType::Boolean => Self::BooleanArray(
771 arr.into_iter()
772 .map(|v| match v {
773 Self::Boolean(b) => b,
774 _ => false,
775 })
776 .collect(),
777 ),
778 FrcType::Double => Self::DoubleArray(
779 arr.into_iter()
780 .map(|v| match v {
781 Self::Double(f) => f,
782 _ => 0.0,
783 })
784 .collect(),
785 ),
786 FrcType::Int => Self::IntArray(
787 arr.into_iter()
788 .map(|v| match v {
789 Self::Int(i) => i,
790 _ => 0,
791 })
792 .collect(),
793 ),
794 FrcType::Float => Self::FloatArray(
795 arr.into_iter()
796 .map(|v| match v {
797 Self::Float(f) => f,
798 _ => 0.0,
799 })
800 .collect(),
801 ),
802 FrcType::String => Self::StringArray(
803 arr.into_iter()
804 .map(|v| match v {
805 Self::String(s) => s,
806 _ => String::new(),
807 })
808 .collect(),
809 ),
810 _ => Self::empty(),
811 }
812 }
813 }
814 any => panic!("Unknown type: {}", any),
815 }
816 }
817}
818
819#[cfg(feature = "rmpv-casting")]
820impl From<FrcValue> for rmpv::Value {
821 fn from(value: FrcValue) -> Self {
822 match value {
823 FrcValue::Boolean(b) => Self::Boolean(b),
824 FrcValue::Int(i) => Self::Integer(i.into()),
825 FrcValue::Float(f) => Self::F32(f),
826 FrcValue::Double(f) => Self::F64(f),
827 FrcValue::String(s) => Self::String(s.into()),
828 FrcValue::Binary(bf) => match bf {
829 crate::FrcBinaryFormats::Raw(b) => Self::Binary(b),
830 crate::FrcBinaryFormats::MsgPack(b) => Self::Binary(b),
831 crate::FrcBinaryFormats::Protobuf(b) => Self::Binary(b),
832 },
833 FrcValue::BooleanArray(a) => Self::Array(
834 a.into_iter()
835 .map(|v| Self::Boolean(v))
836 .collect::<Vec<Self>>()
837 .into(),
838 ),
839 FrcValue::IntArray(a) => Self::Array(
840 a.into_iter()
841 .map(|v| Self::Integer(v.into()))
842 .collect::<Vec<Self>>()
843 .into(),
844 ),
845 FrcValue::FloatArray(a) => Self::Array(
846 a.into_iter()
847 .map(|v| Self::F32(v))
848 .collect::<Vec<Self>>()
849 .into(),
850 ),
851 FrcValue::DoubleArray(a) => Self::Array(
852 a.into_iter()
853 .map(|v| Self::F64(v))
854 .collect::<Vec<Self>>()
855 .into(),
856 ),
857 FrcValue::StringArray(a) => Self::Array(
858 a.into_iter()
859 .map(|v| Self::String(v.into()))
860 .collect::<Vec<Self>>()
861 .into(),
862 ),
863 }
864 }
865}