1use crate::{
2 resp::{FromValue, Value},
3 Error, Result,
4};
5
6impl<T1, T2> FromValue for (T1, T2)
7where
8 T1: FromValue,
9 T2: FromValue,
10{
11 fn from_value(value: Value) -> Result<Self> {
12 match value {
13 Value::Array(Some(values)) => {
14 let mut it = values.into_iter();
15 match (it.next(), it.next(), it.next()) {
16 (Some(v1), Some(v2), None) => Ok((v1.into()?, v2.into()?)),
17 v => Err(Error::Client(format!("Cannot parse result {v:?} to Tuple"))),
18 }
19 }
20 Value::Error(e) => Err(Error::Redis(e)),
21 _ => Err(Error::Client(format!(
22 "Cannot parse result {:?} to Tuple",
23 value
24 ))),
25 }
26 }
27
28 fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>> {
29 fn transpose<T1, T2>(tuple: (Result<T1>, Result<T2>)) -> Result<(T1, T2)> {
30 let (v1, v2) = tuple;
31 Ok((v1?, v2?))
32 }
33 Box::new(|iter| {
34 let first = iter.next()?;
35 match first {
36 Value::Array(_) => Some(Self::from_value(first)),
37 _ => Some(transpose((first.into(), iter.next()?.into()))),
38 }
39 })
40 }
41}
42
43impl<T1, T2, T3> FromValue for (T1, T2, T3)
44where
45 T1: FromValue,
46 T2: FromValue,
47 T3: FromValue,
48{
49 fn from_value(value: Value) -> Result<Self> {
50 match value {
51 Value::Array(Some(values)) => {
52 let mut it = values.into_iter();
53 match (it.next(), it.next(), it.next(), it.next()) {
54 (Some(v1), Some(v2), Some(v3), None) => {
55 Ok((v1.into()?, v2.into()?, v3.into()?))
56 }
57 _ => Err(Error::Client("Cannot parse result to Tuple".to_owned())),
58 }
59 }
60 Value::Error(e) => Err(Error::Redis(e)),
61 _ => Err(Error::Client(format!(
62 "Cannot parse result {:?} to Tuple",
63 value
64 ))),
65 }
66 }
67
68 fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>> {
69 fn transpose<T1, T2, T3>(
70 tuple: (Result<T1>, Result<T2>, Result<T3>),
71 ) -> Result<(T1, T2, T3)> {
72 let (v1, v2, v3) = tuple;
73 Ok((v1?, v2?, v3?))
74 }
75 Box::new(|iter| {
76 let first = iter.next()?;
77 match first {
78 Value::Array(_) => Some(Self::from_value(first)),
79 _ => Some(transpose((
80 first.into(),
81 iter.next()?.into(),
82 iter.next()?.into(),
83 ))),
84 }
85 })
86 }
87}
88
89impl<T1, T2, T3, T4> FromValue for (T1, T2, T3, T4)
90where
91 T1: FromValue,
92 T2: FromValue,
93 T3: FromValue,
94 T4: FromValue,
95{
96 fn from_value(value: Value) -> Result<Self> {
97 match value {
98 Value::Array(Some(values)) => {
99 let mut it = values.into_iter();
100 match (it.next(), it.next(), it.next(), it.next(), it.next()) {
101 (Some(v1), Some(v2), Some(v3), Some(v4), None) => {
102 Ok((v1.into()?, v2.into()?, v3.into()?, v4.into()?))
103 }
104 _ => Err(Error::Client("Cannot parse result to Tuple".to_owned())),
105 }
106 }
107 Value::Error(e) => Err(Error::Redis(e)),
108 _ => Err(Error::Client(format!(
109 "Cannot parse result {:?} to Tuple",
110 value
111 ))),
112 }
113 }
114
115 fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>> {
116 fn transpose<T1, T2, T3, T4>(
117 tuple: (Result<T1>, Result<T2>, Result<T3>, Result<T4>),
118 ) -> Result<(T1, T2, T3, T4)> {
119 let (v1, v2, v3, v4) = tuple;
120 Ok((v1?, v2?, v3?, v4?))
121 }
122 Box::new(|iter| {
123 let first = iter.next()?;
124 match first {
125 Value::Array(_) => Some(Self::from_value(first)),
126 _ => Some(transpose((
127 first.into(),
128 iter.next()?.into(),
129 iter.next()?.into(),
130 iter.next()?.into(),
131 ))),
132 }
133 })
134 }
135}
136
137impl<T1, T2, T3, T4, T5> FromValue for (T1, T2, T3, T4, T5)
138where
139 T1: FromValue,
140 T2: FromValue,
141 T3: FromValue,
142 T4: FromValue,
143 T5: FromValue,
144{
145 fn from_value(value: Value) -> Result<Self> {
146 match value {
147 Value::Array(Some(values)) => {
148 let mut it = values.into_iter();
149 match (
150 it.next(),
151 it.next(),
152 it.next(),
153 it.next(),
154 it.next(),
155 it.next(),
156 ) {
157 (Some(v1), Some(v2), Some(v3), Some(v4), Some(v5), None) => {
158 Ok((v1.into()?, v2.into()?, v3.into()?, v4.into()?, v5.into()?))
159 }
160 _ => Err(Error::Client("Cannot parse result to Tuple".to_owned())),
161 }
162 }
163 Value::Error(e) => Err(Error::Redis(e)),
164 _ => Err(Error::Client(format!(
165 "Cannot parse result {:?} to Tuple",
166 value
167 ))),
168 }
169 }
170
171 #[allow(clippy::complexity)]
172 fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>> {
173 #[allow(clippy::complexity)]
174 fn transpose<T1, T2, T3, T4, T5>(
175 tuple: (Result<T1>, Result<T2>, Result<T3>, Result<T4>, Result<T5>),
176 ) -> Result<(T1, T2, T3, T4, T5)> {
177 let (v1, v2, v3, v4, v5) = tuple;
178 Ok((v1?, v2?, v3?, v4?, v5?))
179 }
180 Box::new(|iter| {
181 let first = iter.next()?;
182 match first {
183 Value::Array(_) => Some(Self::from_value(first)),
184 _ => Some(transpose((
185 first.into(),
186 iter.next()?.into(),
187 iter.next()?.into(),
188 iter.next()?.into(),
189 iter.next()?.into(),
190 ))),
191 }
192 })
193 }
194}
195
196impl<T1, T2, T3, T4, T5, T6> FromValue for (T1, T2, T3, T4, T5, T6)
197where
198 T1: FromValue,
199 T2: FromValue,
200 T3: FromValue,
201 T4: FromValue,
202 T5: FromValue,
203 T6: FromValue,
204{
205 fn from_value(value: Value) -> Result<Self> {
206 match value {
207 Value::Array(Some(values)) => {
208 let mut it = values.into_iter();
209 match (
210 it.next(),
211 it.next(),
212 it.next(),
213 it.next(),
214 it.next(),
215 it.next(),
216 it.next(),
217 ) {
218 (Some(v1), Some(v2), Some(v3), Some(v4), Some(v5), Some(v6), None) => Ok((
219 v1.into()?,
220 v2.into()?,
221 v3.into()?,
222 v4.into()?,
223 v5.into()?,
224 v6.into()?,
225 )),
226 _ => Err(Error::Client("Cannot parse result to Tuple".to_owned())),
227 }
228 }
229 Value::Error(e) => Err(Error::Redis(e)),
230 _ => Err(Error::Client(format!(
231 "Cannot parse result {:?} to Tuple",
232 value
233 ))),
234 }
235 }
236
237 #[allow(clippy::complexity)]
238 fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>> {
239 fn transpose<T1, T2, T3, T4, T5, T6>(
240 tuple: (
241 Result<T1>,
242 Result<T2>,
243 Result<T3>,
244 Result<T4>,
245 Result<T5>,
246 Result<T6>,
247 ),
248 ) -> Result<(T1, T2, T3, T4, T5, T6)> {
249 let (v1, v2, v3, v4, v5, v6) = tuple;
250 Ok((v1?, v2?, v3?, v4?, v5?, v6?))
251 }
252 Box::new(|iter| {
253 let first = iter.next()?;
254 match first {
255 Value::Array(_) => Some(Self::from_value(first)),
256 _ => Some(transpose((
257 first.into(),
258 iter.next()?.into(),
259 iter.next()?.into(),
260 iter.next()?.into(),
261 iter.next()?.into(),
262 iter.next()?.into(),
263 ))),
264 }
265 })
266 }
267}
268
269impl<T1, T2, T3, T4, T5, T6, T7> FromValue for (T1, T2, T3, T4, T5, T6, T7)
270where
271 T1: FromValue,
272 T2: FromValue,
273 T3: FromValue,
274 T4: FromValue,
275 T5: FromValue,
276 T6: FromValue,
277 T7: FromValue,
278{
279 fn from_value(value: Value) -> Result<Self> {
280 match value {
281 Value::Array(Some(values)) => {
282 let mut it = values.into_iter();
283 match (
284 it.next(),
285 it.next(),
286 it.next(),
287 it.next(),
288 it.next(),
289 it.next(),
290 it.next(),
291 it.next(),
292 ) {
293 (
294 Some(v1),
295 Some(v2),
296 Some(v3),
297 Some(v4),
298 Some(v5),
299 Some(v6),
300 Some(v7),
301 None,
302 ) => Ok((
303 v1.into()?,
304 v2.into()?,
305 v3.into()?,
306 v4.into()?,
307 v5.into()?,
308 v6.into()?,
309 v7.into()?,
310 )),
311 _ => Err(Error::Client("Cannot parse result to Tuple".to_owned())),
312 }
313 }
314 Value::Error(e) => Err(Error::Redis(e)),
315 _ => Err(Error::Client(format!(
316 "Cannot parse result {:?} to Tuple",
317 value
318 ))),
319 }
320 }
321
322 #[allow(clippy::complexity)]
323 fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>> {
324 fn transpose<T1, T2, T3, T4, T5, T6, T7>(
325 tuple: (
326 Result<T1>,
327 Result<T2>,
328 Result<T3>,
329 Result<T4>,
330 Result<T5>,
331 Result<T6>,
332 Result<T7>,
333 ),
334 ) -> Result<(T1, T2, T3, T4, T5, T6, T7)> {
335 let (v1, v2, v3, v4, v5, v6, v7) = tuple;
336 Ok((v1?, v2?, v3?, v4?, v5?, v6?, v7?))
337 }
338 Box::new(|iter| {
339 let first = iter.next()?;
340 match first {
341 Value::Array(_) => Some(Self::from_value(first)),
342 _ => Some(transpose((
343 first.into(),
344 iter.next()?.into(),
345 iter.next()?.into(),
346 iter.next()?.into(),
347 iter.next()?.into(),
348 iter.next()?.into(),
349 iter.next()?.into(),
350 ))),
351 }
352 })
353 }
354}
355
356impl<T1, T2, T3, T4, T5, T6, T7, T8> FromValue for (T1, T2, T3, T4, T5, T6, T7, T8)
357where
358 T1: FromValue,
359 T2: FromValue,
360 T3: FromValue,
361 T4: FromValue,
362 T5: FromValue,
363 T6: FromValue,
364 T7: FromValue,
365 T8: FromValue,
366{
367 fn from_value(value: Value) -> Result<Self> {
368 match value {
369 Value::Array(Some(values)) => {
370 let mut it = values.into_iter();
371 match (
372 it.next(),
373 it.next(),
374 it.next(),
375 it.next(),
376 it.next(),
377 it.next(),
378 it.next(),
379 it.next(),
380 it.next(),
381 ) {
382 (
383 Some(v1),
384 Some(v2),
385 Some(v3),
386 Some(v4),
387 Some(v5),
388 Some(v6),
389 Some(v7),
390 Some(v8),
391 None,
392 ) => Ok((
393 v1.into()?,
394 v2.into()?,
395 v3.into()?,
396 v4.into()?,
397 v5.into()?,
398 v6.into()?,
399 v7.into()?,
400 v8.into()?,
401 )),
402 _ => Err(Error::Client("Cannot parse result to Tuple".to_owned())),
403 }
404 }
405 Value::Error(e) => Err(Error::Redis(e)),
406 _ => Err(Error::Client(format!(
407 "Cannot parse result {:?} to Tuple",
408 value
409 ))),
410 }
411 }
412
413 #[allow(clippy::complexity)]
414 fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>> {
415 fn transpose<T1, T2, T3, T4, T5, T6, T7, T8>(
416 tuple: (
417 Result<T1>,
418 Result<T2>,
419 Result<T3>,
420 Result<T4>,
421 Result<T5>,
422 Result<T6>,
423 Result<T7>,
424 Result<T8>,
425 ),
426 ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8)> {
427 let (v1, v2, v3, v4, v5, v6, v7, v8) = tuple;
428 Ok((v1?, v2?, v3?, v4?, v5?, v6?, v7?, v8?))
429 }
430 Box::new(|iter| {
431 let first = iter.next()?;
432 match first {
433 Value::Array(_) => Some(Self::from_value(first)),
434 _ => Some(transpose((
435 first.into(),
436 iter.next()?.into(),
437 iter.next()?.into(),
438 iter.next()?.into(),
439 iter.next()?.into(),
440 iter.next()?.into(),
441 iter.next()?.into(),
442 iter.next()?.into(),
443 ))),
444 }
445 })
446 }
447}
448
449impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> FromValue for (T1, T2, T3, T4, T5, T6, T7, T8, T9)
450where
451 T1: FromValue,
452 T2: FromValue,
453 T3: FromValue,
454 T4: FromValue,
455 T5: FromValue,
456 T6: FromValue,
457 T7: FromValue,
458 T8: FromValue,
459 T9: FromValue,
460{
461 fn from_value(value: Value) -> Result<Self> {
462 match value {
463 Value::Array(Some(values)) => {
464 let mut it = values.into_iter();
465 match (
466 it.next(),
467 it.next(),
468 it.next(),
469 it.next(),
470 it.next(),
471 it.next(),
472 it.next(),
473 it.next(),
474 it.next(),
475 it.next(),
476 ) {
477 (
478 Some(v1),
479 Some(v2),
480 Some(v3),
481 Some(v4),
482 Some(v5),
483 Some(v6),
484 Some(v7),
485 Some(v8),
486 Some(v9),
487 None,
488 ) => Ok((
489 v1.into()?,
490 v2.into()?,
491 v3.into()?,
492 v4.into()?,
493 v5.into()?,
494 v6.into()?,
495 v7.into()?,
496 v8.into()?,
497 v9.into()?,
498 )),
499 _ => Err(Error::Client("Cannot parse result to Tuple".to_owned())),
500 }
501 }
502 Value::Error(e) => Err(Error::Redis(e)),
503 _ => Err(Error::Client(format!(
504 "Cannot parse result {:?} to Tuple",
505 value
506 ))),
507 }
508 }
509
510 #[allow(clippy::complexity)]
511 fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>> {
512 fn transpose<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
513 tuple: (
514 Result<T1>,
515 Result<T2>,
516 Result<T3>,
517 Result<T4>,
518 Result<T5>,
519 Result<T6>,
520 Result<T7>,
521 Result<T8>,
522 Result<T9>,
523 ),
524 ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> {
525 let (v1, v2, v3, v4, v5, v6, v7, v8, v9) = tuple;
526 Ok((v1?, v2?, v3?, v4?, v5?, v6?, v7?, v8?, v9?))
527 }
528 Box::new(|iter| {
529 let first = iter.next()?;
530 match first {
531 Value::Array(_) => Some(Self::from_value(first)),
532 _ => Some(transpose((
533 first.into(),
534 iter.next()?.into(),
535 iter.next()?.into(),
536 iter.next()?.into(),
537 iter.next()?.into(),
538 iter.next()?.into(),
539 iter.next()?.into(),
540 iter.next()?.into(),
541 iter.next()?.into(),
542 ))),
543 }
544 })
545 }
546}
547
548impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> FromValue
549 for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
550where
551 T1: FromValue,
552 T2: FromValue,
553 T3: FromValue,
554 T4: FromValue,
555 T5: FromValue,
556 T6: FromValue,
557 T7: FromValue,
558 T8: FromValue,
559 T9: FromValue,
560 T10: FromValue,
561{
562 fn from_value(value: Value) -> Result<Self> {
563 match value {
564 Value::Array(Some(values)) => {
565 let mut it = values.into_iter();
566 match (
567 it.next(),
568 it.next(),
569 it.next(),
570 it.next(),
571 it.next(),
572 it.next(),
573 it.next(),
574 it.next(),
575 it.next(),
576 it.next(),
577 it.next(),
578 ) {
579 (
580 Some(v1),
581 Some(v2),
582 Some(v3),
583 Some(v4),
584 Some(v5),
585 Some(v6),
586 Some(v7),
587 Some(v8),
588 Some(v9),
589 Some(v10),
590 None,
591 ) => Ok((
592 v1.into()?,
593 v2.into()?,
594 v3.into()?,
595 v4.into()?,
596 v5.into()?,
597 v6.into()?,
598 v7.into()?,
599 v8.into()?,
600 v9.into()?,
601 v10.into()?,
602 )),
603 _ => Err(Error::Client("Cannot parse result to Tuple".to_owned())),
604 }
605 }
606 Value::Error(e) => Err(Error::Redis(e)),
607 _ => Err(Error::Client(format!(
608 "Cannot parse result {:?} to Tuple",
609 value
610 ))),
611 }
612 }
613
614 #[allow(clippy::complexity)]
615 fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>> {
616 fn transpose<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
617 tuple: (
618 Result<T1>,
619 Result<T2>,
620 Result<T3>,
621 Result<T4>,
622 Result<T5>,
623 Result<T6>,
624 Result<T7>,
625 Result<T8>,
626 Result<T9>,
627 Result<T10>,
628 ),
629 ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> {
630 let (v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) = tuple;
631 Ok((v1?, v2?, v3?, v4?, v5?, v6?, v7?, v8?, v9?, v10?))
632 }
633 Box::new(|iter| {
634 let first = iter.next()?;
635 match first {
636 Value::Array(_) => Some(Self::from_value(first)),
637 _ => Some(transpose((
638 first.into(),
639 iter.next()?.into(),
640 iter.next()?.into(),
641 iter.next()?.into(),
642 iter.next()?.into(),
643 iter.next()?.into(),
644 iter.next()?.into(),
645 iter.next()?.into(),
646 iter.next()?.into(),
647 iter.next()?.into(),
648 ))),
649 }
650 })
651 }
652}