1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use super::{FromJs, FromJsMulti, MultiValue, ToJs, ToJsMulti};
use crate::{Ctx, Result, Value};

impl<'js> ToJsMulti<'js> for Vec<Value<'js>> {
    fn to_js_multi(self, _: Ctx<'js>) -> Result<Vec<Value<'js>>> {
        Ok(self)
    }
}

impl<'js, T: ToJs<'js>> ToJsMulti<'js> for T {
    fn to_js_multi(self, ctx: Ctx<'js>) -> Result<Vec<Value<'js>>> {
        Ok(vec![self.to_js(ctx)?])
    }
}

impl<'js> FromJsMulti<'js> for MultiValue<'js> {
    fn from_js_multi(_: Ctx<'js>, value: MultiValue<'js>) -> Result<Self> {
        Ok(value)
    }

    fn len() -> i64 {
        -1
    }
}

impl<'js> FromJsMulti<'js> for () {
    fn from_js_multi(_: Ctx<'js>, _: MultiValue<'js>) -> Result<Self> {
        Ok(())
    }

    fn len() -> i64 {
        0
    }
}

macro_rules! impl_to_js_multi{
    ($($t:ident),+) => {
        impl<'js, $($t,)*> ToJsMulti<'js> for ($($t,)*)
            where $($t: ToJs<'js>,)*
        {
            #[allow(non_snake_case)]
            fn to_js_multi(self, ctx: Ctx<'js>) -> Result<Vec<Value<'js>>>{
                let ($($t,)*) = self;
                Ok(vec![
                    $($t.to_js(ctx)?,)*
                ])
            }
        }
    }
}

macro_rules! impl_from_js_multi{
    ($num:expr, $($t:ident),*) => {
        impl<'js, $($t,)*> FromJsMulti<'js> for ($($t,)*)
            where $($t: FromJs<'js>,)*
        {
            #[allow(non_snake_case)]
            fn from_js_multi(ctx: Ctx<'js>, mut value: MultiValue<'js>) -> Result<Self> {
                let mut iter = value.iter();
                Ok((
                    $({
                        let v = iter.next()
                            .unwrap_or(Value::Undefined);
                        $t::from_js(ctx,v)?
                    },)*
                ))
            }

            fn len() -> i64{
                $num
            }
        }
    }
}

impl_to_js_multi!(A);
impl_to_js_multi!(A, B);
impl_to_js_multi!(A, B, C);
impl_to_js_multi!(A, B, C, D);
impl_to_js_multi!(A, B, C, D, E);
impl_to_js_multi!(A, B, C, D, E, F);
impl_to_js_multi!(A, B, C, D, E, F, G);
impl_to_js_multi!(A, B, C, D, E, F, G, H);
impl_to_js_multi!(A, B, C, D, E, F, G, H, I);
impl_to_js_multi!(A, B, C, D, E, F, G, H, I, J);
impl_to_js_multi!(A, B, C, D, E, F, G, H, I, J, K);

impl_from_js_multi!(1, A);
impl_from_js_multi!(2, A, B);
impl_from_js_multi!(3, A, B, C);
impl_from_js_multi!(4, A, B, C, D);
impl_from_js_multi!(5, A, B, C, D, E);
impl_from_js_multi!(6, A, B, C, D, E, F);
impl_from_js_multi!(7, A, B, C, D, E, F, G);
impl_from_js_multi!(8, A, B, C, D, E, F, G, H);
impl_from_js_multi!(9, A, B, C, D, E, F, G, H, I);
impl_from_js_multi!(10, A, B, C, D, E, F, G, H, I, J);
impl_from_js_multi!(11, A, B, C, D, E, F, G, H, I, J, K);