Skip to main content

drizzle_core/traits/
tuple.rs

1// =============================================================================
2// Recursive accumulator macros
3// =============================================================================
4//
5// These macros generate all tuple arities from a flat list of elements.
6// Each element is listed once; the macro automatically generates all
7// prefix arities (1-element, 2-element, ..., N-element tuples).
8
9/// Recursive accumulator for type-only callbacks.
10macro_rules! seq_types {
11    (@acc $callback:ident [$($acc:ident),*]) => {};
12    (@acc $callback:ident [$($acc:ident),*] $next:ident $($rest:ident)*) => {
13        $callback!($($acc,)* $next);
14        seq_types!(@acc $callback [$($acc,)* $next] $($rest)*);
15    };
16}
17
18/// Recursive accumulator for dual-type callbacks.
19macro_rules! seq_dual {
20    (@acc $callback:ident [$($sa:ident),*] [$($da:ident),*]) => {};
21    (@acc $callback:ident [$($sa:ident),*] [$($da:ident),*] ($s:ident, $d:ident) $($rest:tt)*) => {
22        $callback!($($sa,)* $s; $($da,)* $d);
23        seq_dual!(@acc $callback [$($sa,)* $s] [$($da,)* $d] $($rest)*);
24    };
25}
26
27/// Recursive accumulator for type+index callbacks.
28macro_rules! seq_tuples {
29    (@acc $callback:ident [$($aT:ident),*] [$($ai:tt),*]) => {};
30    (@acc $callback:ident [$($aT:ident),*] [$($ai:tt),*] ($T:ident, $i:tt) $($rest:tt)*) => {
31        $callback!($($aT,)* $T; $($ai,)* $i);
32        seq_tuples!(@acc $callback [$($aT,)* $T] [$($ai,)* $i] $($rest)*);
33    };
34    ($callback:ident; $($pairs:tt)+) => {
35        seq_tuples!(@acc $callback [] [] $($pairs)+);
36    };
37    (@from $callback:ident [$($aT:ident),*] [$($ai:tt),*]; $($pairs:tt)+) => {
38        seq_tuples!(@acc $callback [$($aT),*] [$($ai),*] $($pairs)+);
39    };
40}
41
42// =============================================================================
43// Constraint tuple macros (used by constraint.rs)
44// =============================================================================
45
46/// Calls `$callback!(T0)`, ..., `$callback!(T0, ..., T15)` for arities 1..16.
47macro_rules! with_tuple_sizes {
48    ($callback:ident) => {
49        seq_types!(@acc $callback [] T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15);
50    };
51}
52
53/// Calls `$callback!(S0; D0)`, ..., `$callback!(S0..S15; D0..D15)` for arities 1..16.
54macro_rules! with_dual_tuple_sizes {
55    ($callback:ident) => {
56        seq_dual!(@acc $callback [] [] (S0,D0) (S1,D1) (S2,D2) (S3,D3) (S4,D4) (S5,D5) (S6,D6) (S7,D7) (S8,D8) (S9,D9) (S10,D10) (S11,D11) (S12,D12) (S13,D13) (S14,D14) (S15,D15));
57    };
58}
59
60// =============================================================================
61// ToSQL tuple impls
62// =============================================================================
63
64use crate::{SQL, SQLParam, ToSQL, Token};
65
66/// Callback: implements `ToSQL` for a tuple of the given arity.
67macro_rules! impl_tosql_tuple {
68    ($($T:ident),+; $($idx:tt),+) => {
69        impl<'a, V: SQLParam, $($T: ToSQL<'a, V>),+> ToSQL<'a, V> for ($($T,)+) {
70            fn to_sql(&self) -> SQL<'a, V> {
71                SQL::join([$(self.$idx.to_sql(),)+], Token::COMMA)
72            }
73        }
74    };
75}
76
77/// Calls `$callback!` for arities 1..=8.
78macro_rules! with_col_sizes_8 {
79    ($callback:ident) => {
80        seq_tuples!($callback;
81            (T0,0) (T1,1) (T2,2) (T3,3)
82            (T4,4) (T5,5) (T6,6) (T7,7)
83        );
84    };
85}
86
87/// Calls `$callback!` for arities 9..=16.
88#[allow(unused_macros)]
89macro_rules! with_col_sizes_16 {
90    ($callback:ident) => {
91        seq_tuples!(@from $callback
92            [T0,T1,T2,T3,T4,T5,T6,T7]
93            [0,1,2,3,4,5,6,7];
94            (T8,8) (T9,9) (T10,10) (T11,11)
95            (T12,12) (T13,13) (T14,14) (T15,15)
96        );
97    };
98}
99
100/// Calls `$callback!` for arities 17..=32.
101#[allow(unused_macros)]
102macro_rules! with_col_sizes_32 {
103    ($callback:ident) => {
104        seq_tuples!(@from $callback
105            [T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15]
106            [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];
107            (T16,16) (T17,17) (T18,18) (T19,19)
108            (T20,20) (T21,21) (T22,22) (T23,23)
109            (T24,24) (T25,25) (T26,26) (T27,27)
110            (T28,28) (T29,29) (T30,30) (T31,31)
111        );
112    };
113}
114
115/// Calls `$callback!` for arities 33..=64.
116#[allow(unused_macros)]
117macro_rules! with_col_sizes_64 {
118    ($callback:ident) => {
119        seq_tuples!(@from $callback
120            [T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,
121             T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31]
122            [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
123             16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31];
124            (T32,32) (T33,33) (T34,34) (T35,35)
125            (T36,36) (T37,37) (T38,38) (T39,39)
126            (T40,40) (T41,41) (T42,42) (T43,43)
127            (T44,44) (T45,45) (T46,46) (T47,47)
128            (T48,48) (T49,49) (T50,50) (T51,51)
129            (T52,52) (T53,53) (T54,54) (T55,55)
130            (T56,56) (T57,57) (T58,58) (T59,59)
131            (T60,60) (T61,61) (T62,62) (T63,63)
132        );
133    };
134}
135
136/// Calls `$callback!` for arities 65..=128.
137#[allow(unused_macros)]
138macro_rules! with_col_sizes_128 {
139    ($callback:ident) => {
140        seq_tuples!(@from $callback
141            [T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,
142             T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,
143             T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,
144             T48,T49,T50,T51,T52,T53,T54,T55,T56,T57,T58,T59,T60,T61,T62,T63]
145            [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
146             16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
147             32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
148             48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63];
149            (T64,64) (T65,65) (T66,66) (T67,67)
150            (T68,68) (T69,69) (T70,70) (T71,71)
151            (T72,72) (T73,73) (T74,74) (T75,75)
152            (T76,76) (T77,77) (T78,78) (T79,79)
153            (T80,80) (T81,81) (T82,82) (T83,83)
154            (T84,84) (T85,85) (T86,86) (T87,87)
155            (T88,88) (T89,89) (T90,90) (T91,91)
156            (T92,92) (T93,93) (T94,94) (T95,95)
157            (T96,96) (T97,97) (T98,98) (T99,99)
158            (T100,100) (T101,101) (T102,102) (T103,103)
159            (T104,104) (T105,105) (T106,106) (T107,107)
160            (T108,108) (T109,109) (T110,110) (T111,111)
161            (T112,112) (T113,113) (T114,114) (T115,115)
162            (T116,116) (T117,117) (T118,118) (T119,119)
163            (T120,120) (T121,121) (T122,122) (T123,123)
164            (T124,124) (T125,125) (T126,126) (T127,127)
165        );
166    };
167}
168
169/// Calls `$callback!` for arities 129..=200.
170#[allow(unused_macros)]
171macro_rules! with_col_sizes_200 {
172    ($callback:ident) => {
173        seq_tuples!(@from $callback
174            [T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,
175             T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,
176             T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,
177             T48,T49,T50,T51,T52,T53,T54,T55,T56,T57,T58,T59,T60,T61,T62,T63,
178             T64,T65,T66,T67,T68,T69,T70,T71,T72,T73,T74,T75,T76,T77,T78,T79,
179             T80,T81,T82,T83,T84,T85,T86,T87,T88,T89,T90,T91,T92,T93,T94,T95,
180             T96,T97,T98,T99,T100,T101,T102,T103,T104,T105,T106,T107,T108,T109,T110,T111,
181             T112,T113,T114,T115,T116,T117,T118,T119,T120,T121,T122,T123,T124,T125,T126,T127]
182            [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
183             16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
184             32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
185             48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,
186             64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
187             80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,
188             96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,
189             112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127];
190            (T128,128) (T129,129) (T130,130) (T131,131)
191            (T132,132) (T133,133) (T134,134) (T135,135)
192            (T136,136) (T137,137) (T138,138) (T139,139)
193            (T140,140) (T141,141) (T142,142) (T143,143)
194            (T144,144) (T145,145) (T146,146) (T147,147)
195            (T148,148) (T149,149) (T150,150) (T151,151)
196            (T152,152) (T153,153) (T154,154) (T155,155)
197            (T156,156) (T157,157) (T158,158) (T159,159)
198            (T160,160) (T161,161) (T162,162) (T163,163)
199            (T164,164) (T165,165) (T166,166) (T167,167)
200            (T168,168) (T169,169) (T170,170) (T171,171)
201            (T172,172) (T173,173) (T174,174) (T175,175)
202            (T176,176) (T177,177) (T178,178) (T179,179)
203            (T180,180) (T181,181) (T182,182) (T183,183)
204            (T184,184) (T185,185) (T186,186) (T187,187)
205            (T188,188) (T189,189) (T190,190) (T191,191)
206            (T192,192) (T193,193) (T194,194) (T195,195)
207            (T196,196) (T197,197) (T198,198) (T199,199)
208        );
209    };
210}
211
212// =============================================================================
213// Feature-gated invocations
214// =============================================================================
215
216with_col_sizes_8!(impl_tosql_tuple);
217
218#[cfg(any(
219    feature = "col16",
220    feature = "col32",
221    feature = "col64",
222    feature = "col128",
223    feature = "col200"
224))]
225with_col_sizes_16!(impl_tosql_tuple);
226
227#[cfg(any(
228    feature = "col32",
229    feature = "col64",
230    feature = "col128",
231    feature = "col200"
232))]
233with_col_sizes_32!(impl_tosql_tuple);
234
235#[cfg(any(feature = "col64", feature = "col128", feature = "col200"))]
236with_col_sizes_64!(impl_tosql_tuple);
237
238#[cfg(any(feature = "col128", feature = "col200"))]
239with_col_sizes_128!(impl_tosql_tuple);
240
241#[cfg(feature = "col200")]
242with_col_sizes_200!(impl_tosql_tuple);