1use crate::source::{Expansion, Source};
2
3macro_rules! impl_tuple {
4 ($($T:ident),*) => {
5 #[allow(nonstandard_style)]
6 impl<$($T,)*> Source for ($($T,)*)
7 where
8 $($T: Source,)*
9 {
10 fn expand_bool<E>(&mut self, v: &str) -> Result<Option<bool>, E>
11 where
12 E: serde::de::Error,
13 {
14 let ($($T,)*) = self;
15 $(if let Some(value) = $T.expand_bool(v)? { return Ok(Some(value)); })*
16 Ok(None)
17 }
18
19 fn expand_i8<E>(&mut self, v: &str) -> Result<Option<i8>, E>
20 where
21 E: serde::de::Error,
22 {
23 let ($($T,)*) = self;
24 $(if let Some(value) = $T.expand_i8(v)? { return Ok(Some(value)); })*
25 Ok(None)
26 }
27
28 fn expand_i16<E>(&mut self, v: &str) -> Result<Option<i16>, E>
29 where
30 E: serde::de::Error,
31 {
32 let ($($T,)*) = self;
33 $(if let Some(value) = $T.expand_i16(v)? { return Ok(Some(value)); })*
34 Ok(None)
35 }
36
37 fn expand_i32<E>(&mut self, v: &str) -> Result<Option<i32>, E>
38 where
39 E: serde::de::Error,
40 {
41 let ($($T,)*) = self;
42 $(if let Some(value) = $T.expand_i32(v)? { return Ok(Some(value)); })*
43 Ok(None)
44 }
45
46 fn expand_i64<E>(&mut self, v: &str) -> Result<Option<i64>, E>
47 where
48 E: serde::de::Error,
49 {
50 let ($($T,)*) = self;
51 $(if let Some(value) = $T.expand_i64(v)? { return Ok(Some(value)); })*
52 Ok(None)
53 }
54
55 fn expand_u8<E>(&mut self, v: &str) -> Result<Option<u8>, E>
56 where
57 E: serde::de::Error,
58 {
59 let ($($T,)*) = self;
60 $(if let Some(value) = $T.expand_u8(v)? { return Ok(Some(value)); })*
61 Ok(None)
62 }
63
64 fn expand_u16<E>(&mut self, v: &str) -> Result<Option<u16>, E>
65 where
66 E: serde::de::Error,
67 {
68 let ($($T,)*) = self;
69 $(if let Some(value) = $T.expand_u16(v)? { return Ok(Some(value)); })*
70 Ok(None)
71 }
72
73 fn expand_u32<E>(&mut self, v: &str) -> Result<Option<u32>, E>
74 where
75 E: serde::de::Error,
76 {
77 let ($($T,)*) = self;
78 $(if let Some(value) = $T.expand_u32(v)? { return Ok(Some(value)); })*
79 Ok(None)
80 }
81
82 fn expand_u64<E>(&mut self, v: &str) -> Result<Option<u64>, E>
83 where
84 E: serde::de::Error,
85 {
86 let ($($T,)*) = self;
87 $(if let Some(value) = $T.expand_u64(v)? { return Ok(Some(value)); })*
88 Ok(None)
89 }
90
91 fn expand_f32<E>(&mut self, v: &str) -> Result<Option<f32>, E>
92 where
93 E: serde::de::Error,
94 {
95 let ($($T,)*) = self;
96 $(if let Some(value) = $T.expand_f32(v)? { return Ok(Some(value)); })*
97 Ok(None)
98 }
99
100 fn expand_f64<E>(&mut self, v: &str) -> Result<Option<f64>, E>
101 where
102 E: serde::de::Error,
103 {
104 let ($($T,)*) = self;
105 $(if let Some(value) = $T.expand_f64(v)? { return Ok(Some(value)); })*
106 Ok(None)
107 }
108
109 fn expand_str<'a, E>(
110 &mut self,
111 v: std::borrow::Cow<'a, str>,
112 ) -> Result<super::Expansion<std::borrow::Cow<'a, str>>, E>
113 where
114 E: serde::de::Error,
115 {
116 let ($($T,)*) = self;
117 $(let v = match $T.expand_str(v)? {
118 Expansion::Expanded(v) => return Ok(Expansion::Expanded(v)),
119 Expansion::Original(v) => v,
120 };)*
121 Ok(Expansion::Original(v))
122 }
123
124 fn expand_bytes<'a, E>(
125 &mut self,
126 v: std::borrow::Cow<'a, [u8]>,
127 ) -> Result<super::Expansion<std::borrow::Cow<'a, [u8]>>, E>
128 where
129 E: serde::de::Error,
130 {
131 let ($($T,)*) = self;
132 $(let v = match $T.expand_bytes(v)? {
133 Expansion::Expanded(v) => return Ok(Expansion::Expanded(v)),
134 Expansion::Original(v) => v,
135 };)*
136 Ok(Expansion::Original(v))
137 }
138
139 fn expand_any<'a, E>(
140 &mut self,
141 v: std::borrow::Cow<'a, str>,
142 ) -> Result<super::Expansion<super::Any<'a>, std::borrow::Cow<'a, str>>, E>
143 where
144 E: serde::de::Error,
145 {
146 let ($($T,)*) = self;
147 $(let v = match $T.expand_any(v)? {
148 Expansion::Expanded(v) => return Ok(Expansion::Expanded(v)),
149 Expansion::Original(v) => v,
150 };)*
151 Ok(Expansion::Original(v))
152 }
153 }
154 };
155}
156
157impl_tuple!(T1);
158impl_tuple!(T1, T2);
159impl_tuple!(T1, T2, T3);
160impl_tuple!(T1, T2, T3, T4);
161impl_tuple!(T1, T2, T3, T4, T5);
162impl_tuple!(T1, T2, T3, T4, T5, T6);
163impl_tuple!(T1, T2, T3, T4, T5, T6, T7);
164impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8);
165impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9);
166impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
167impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
168impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
169impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
170impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
171impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);