/rust/registry/src/index.crates.io-6f17d22bba15001f/tower-layer-0.3.3/src/tuple.rs

Source (jump to first uncovered line)
use crate::Layer;

impl<S> Layer<S> for () {
    type Service = S;

    fn layer(&self, service: S) -> Self::Service {
        service
    }
}

impl<S, L1> Layer<S> for (L1,)
where
    L1: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1,) = self;
        l1.layer(service)
    }
}

impl<S, L1, L2> Layer<S> for (L1, L2)
where
    L1: Layer<L2::Service>,
    L2: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2) = self;
        l1.layer(l2.layer(service))
    }
}

impl<S, L1, L2, L3> Layer<S> for (L1, L2, L3)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3) = self;
        l1.layer((l2, l3).layer(service))
    }
}

impl<S, L1, L2, L3, L4> Layer<S> for (L1, L2, L3, L4)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4) = self;
        l1.layer((l2, l3, l4).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5> Layer<S> for (L1, L2, L3, L4, L5)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5) = self;
        l1.layer((l2, l3, l4, l5).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5, L6> Layer<S> for (L1, L2, L3, L4, L5, L6)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6) = self;
        l1.layer((l2, l3, l4, l5, l6).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5, L6, L7> Layer<S> for (L1, L2, L3, L4, L5, L6, L7)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7) = self;
        l1.layer((l2, l3, l4, l5, l6, l7).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5, L6, L7, L8> Layer<S> for (L1, L2, L3, L4, L5, L6, L7, L8)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<L8::Service>,
    L8: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7, l8) = self;
        l1.layer((l2, l3, l4, l5, l6, l7, l8).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9> Layer<S> for (L1, L2, L3, L4, L5, L6, L7, L8, L9)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<L8::Service>,
    L8: Layer<L9::Service>,
    L9: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7, l8, l9) = self;
        l1.layer((l2, l3, l4, l5, l6, l7, l8, l9).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10> Layer<S>
    for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<L8::Service>,
    L8: Layer<L9::Service>,
    L9: Layer<L10::Service>,
    L10: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10) = self;
        l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11> Layer<S>
    for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<L8::Service>,
    L8: Layer<L9::Service>,
    L9: Layer<L10::Service>,
    L10: Layer<L11::Service>,
    L11: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11) = self;
        l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12> Layer<S>
    for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<L8::Service>,
    L8: Layer<L9::Service>,
    L9: Layer<L10::Service>,
    L10: Layer<L11::Service>,
    L11: Layer<L12::Service>,
    L12: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12) = self;
        l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13> Layer<S>
    for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<L8::Service>,
    L8: Layer<L9::Service>,
    L9: Layer<L10::Service>,
    L10: Layer<L11::Service>,
    L11: Layer<L12::Service>,
    L12: Layer<L13::Service>,
    L13: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13) = self;
        l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13).layer(service))
    }
}

impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14> Layer<S>
    for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<L8::Service>,
    L8: Layer<L9::Service>,
    L9: Layer<L10::Service>,
    L10: Layer<L11::Service>,
    L11: Layer<L12::Service>,
    L12: Layer<L13::Service>,
    L13: Layer<L14::Service>,
    L14: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14) = self;
        l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14).layer(service))
    }
}

#[rustfmt::skip]
impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15> Layer<S>
    for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<L8::Service>,
    L8: Layer<L9::Service>,
    L9: Layer<L10::Service>,
    L10: Layer<L11::Service>,
    L11: Layer<L12::Service>,
    L12: Layer<L13::Service>,
    L13: Layer<L14::Service>,
    L14: Layer<L15::Service>,
    L15: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15) = self;
        l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15).layer(service))
    }
}

#[rustfmt::skip]
impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16> Layer<S>
    for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16)
where
    L1: Layer<L2::Service>,
    L2: Layer<L3::Service>,
    L3: Layer<L4::Service>,
    L4: Layer<L5::Service>,
    L5: Layer<L6::Service>,
    L6: Layer<L7::Service>,
    L7: Layer<L8::Service>,
    L8: Layer<L9::Service>,
    L9: Layer<L10::Service>,
    L10: Layer<L11::Service>,
    L11: Layer<L12::Service>,
    L12: Layer<L13::Service>,
    L13: Layer<L14::Service>,
    L14: Layer<L15::Service>,
    L15: Layer<L16::Service>,
    L16: Layer<S>,
{
    type Service = L1::Service;

    fn layer(&self, service: S) -> Self::Service {
        let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15, l16) = self;
        l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15, l16).layer(service))
    }
}

Coverage Report

Created: 2024-12-17 06:15

Line	Count	Source (jump to first uncovered line)
1		use crate::Layer;
2
3		impl<S> Layer<S> for () {
4		type Service = S;
5
6	0	fn layer(&self, service: S) -> Self::Service {
7	0	service
8	0	}
9		}
10
11		impl<S, L1> Layer<S> for (L1,)
12		where
13		L1: Layer<S>,
14		{
15		type Service = L1::Service;
16
17	0	fn layer(&self, service: S) -> Self::Service {
18	0	let (l1,) = self;
19	0	l1.layer(service)
20	0	}
21		}
22
23		impl<S, L1, L2> Layer<S> for (L1, L2)
24		where
25		L1: Layer<L2::Service>,
26		L2: Layer<S>,
27		{
28		type Service = L1::Service;
29
30	0	fn layer(&self, service: S) -> Self::Service {
31	0	let (l1, l2) = self;
32	0	l1.layer(l2.layer(service))
33	0	}
34		}
35
36		impl<S, L1, L2, L3> Layer<S> for (L1, L2, L3)
37		where
38		L1: Layer<L2::Service>,
39		L2: Layer<L3::Service>,
40		L3: Layer<S>,
41		{
42		type Service = L1::Service;
43
44	0	fn layer(&self, service: S) -> Self::Service {
45	0	let (l1, l2, l3) = self;
46	0	l1.layer((l2, l3).layer(service))
47	0	}
48		}
49
50		impl<S, L1, L2, L3, L4> Layer<S> for (L1, L2, L3, L4)
51		where
52		L1: Layer<L2::Service>,
53		L2: Layer<L3::Service>,
54		L3: Layer<L4::Service>,
55		L4: Layer<S>,
56		{
57		type Service = L1::Service;
58
59	0	fn layer(&self, service: S) -> Self::Service {
60	0	let (l1, l2, l3, l4) = self;
61	0	l1.layer((l2, l3, l4).layer(service))
62	0	}
63		}
64
65		impl<S, L1, L2, L3, L4, L5> Layer<S> for (L1, L2, L3, L4, L5)
66		where
67		L1: Layer<L2::Service>,
68		L2: Layer<L3::Service>,
69		L3: Layer<L4::Service>,
70		L4: Layer<L5::Service>,
71		L5: Layer<S>,
72		{
73		type Service = L1::Service;
74
75	0	fn layer(&self, service: S) -> Self::Service {
76	0	let (l1, l2, l3, l4, l5) = self;
77	0	l1.layer((l2, l3, l4, l5).layer(service))
78	0	}
79		}
80
81		impl<S, L1, L2, L3, L4, L5, L6> Layer<S> for (L1, L2, L3, L4, L5, L6)
82		where
83		L1: Layer<L2::Service>,
84		L2: Layer<L3::Service>,
85		L3: Layer<L4::Service>,
86		L4: Layer<L5::Service>,
87		L5: Layer<L6::Service>,
88		L6: Layer<S>,
89		{
90		type Service = L1::Service;
91
92	0	fn layer(&self, service: S) -> Self::Service {
93	0	let (l1, l2, l3, l4, l5, l6) = self;
94	0	l1.layer((l2, l3, l4, l5, l6).layer(service))
95	0	}
96		}
97
98		impl<S, L1, L2, L3, L4, L5, L6, L7> Layer<S> for (L1, L2, L3, L4, L5, L6, L7)
99		where
100		L1: Layer<L2::Service>,
101		L2: Layer<L3::Service>,
102		L3: Layer<L4::Service>,
103		L4: Layer<L5::Service>,
104		L5: Layer<L6::Service>,
105		L6: Layer<L7::Service>,
106		L7: Layer<S>,
107		{
108		type Service = L1::Service;
109
110	0	fn layer(&self, service: S) -> Self::Service {
111	0	let (l1, l2, l3, l4, l5, l6, l7) = self;
112	0	l1.layer((l2, l3, l4, l5, l6, l7).layer(service))
113	0	}
114		}
115
116		impl<S, L1, L2, L3, L4, L5, L6, L7, L8> Layer<S> for (L1, L2, L3, L4, L5, L6, L7, L8)
117		where
118		L1: Layer<L2::Service>,
119		L2: Layer<L3::Service>,
120		L3: Layer<L4::Service>,
121		L4: Layer<L5::Service>,
122		L5: Layer<L6::Service>,
123		L6: Layer<L7::Service>,
124		L7: Layer<L8::Service>,
125		L8: Layer<S>,
126		{
127		type Service = L1::Service;
128
129	0	fn layer(&self, service: S) -> Self::Service {
130	0	let (l1, l2, l3, l4, l5, l6, l7, l8) = self;
131	0	l1.layer((l2, l3, l4, l5, l6, l7, l8).layer(service))
132	0	}
133		}
134
135		impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9> Layer<S> for (L1, L2, L3, L4, L5, L6, L7, L8, L9)
136		where
137		L1: Layer<L2::Service>,
138		L2: Layer<L3::Service>,
139		L3: Layer<L4::Service>,
140		L4: Layer<L5::Service>,
141		L5: Layer<L6::Service>,
142		L6: Layer<L7::Service>,
143		L7: Layer<L8::Service>,
144		L8: Layer<L9::Service>,
145		L9: Layer<S>,
146		{
147		type Service = L1::Service;
148
149	0	fn layer(&self, service: S) -> Self::Service {
150	0	let (l1, l2, l3, l4, l5, l6, l7, l8, l9) = self;
151	0	l1.layer((l2, l3, l4, l5, l6, l7, l8, l9).layer(service))
152	0	}
153		}
154
155		impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10> Layer<S>
156		for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10)
157		where
158		L1: Layer<L2::Service>,
159		L2: Layer<L3::Service>,
160		L3: Layer<L4::Service>,
161		L4: Layer<L5::Service>,
162		L5: Layer<L6::Service>,
163		L6: Layer<L7::Service>,
164		L7: Layer<L8::Service>,
165		L8: Layer<L9::Service>,
166		L9: Layer<L10::Service>,
167		L10: Layer<S>,
168		{
169		type Service = L1::Service;
170
171	0	fn layer(&self, service: S) -> Self::Service {
172	0	let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10) = self;
173	0	l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10).layer(service))
174	0	}
175		}
176
177		impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11> Layer<S>
178		for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11)
179		where
180		L1: Layer<L2::Service>,
181		L2: Layer<L3::Service>,
182		L3: Layer<L4::Service>,
183		L4: Layer<L5::Service>,
184		L5: Layer<L6::Service>,
185		L6: Layer<L7::Service>,
186		L7: Layer<L8::Service>,
187		L8: Layer<L9::Service>,
188		L9: Layer<L10::Service>,
189		L10: Layer<L11::Service>,
190		L11: Layer<S>,
191		{
192		type Service = L1::Service;
193
194	0	fn layer(&self, service: S) -> Self::Service {
195	0	let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11) = self;
196	0	l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11).layer(service))
197	0	}
198		}
199
200		impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12> Layer<S>
201		for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12)
202		where
203		L1: Layer<L2::Service>,
204		L2: Layer<L3::Service>,
205		L3: Layer<L4::Service>,
206		L4: Layer<L5::Service>,
207		L5: Layer<L6::Service>,
208		L6: Layer<L7::Service>,
209		L7: Layer<L8::Service>,
210		L8: Layer<L9::Service>,
211		L9: Layer<L10::Service>,
212		L10: Layer<L11::Service>,
213		L11: Layer<L12::Service>,
214		L12: Layer<S>,
215		{
216		type Service = L1::Service;
217
218	0	fn layer(&self, service: S) -> Self::Service {
219	0	let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12) = self;
220	0	l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12).layer(service))
221	0	}
222		}
223
224		impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13> Layer<S>
225		for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13)
226		where
227		L1: Layer<L2::Service>,
228		L2: Layer<L3::Service>,
229		L3: Layer<L4::Service>,
230		L4: Layer<L5::Service>,
231		L5: Layer<L6::Service>,
232		L6: Layer<L7::Service>,
233		L7: Layer<L8::Service>,
234		L8: Layer<L9::Service>,
235		L9: Layer<L10::Service>,
236		L10: Layer<L11::Service>,
237		L11: Layer<L12::Service>,
238		L12: Layer<L13::Service>,
239		L13: Layer<S>,
240		{
241		type Service = L1::Service;
242
243	0	fn layer(&self, service: S) -> Self::Service {
244	0	let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13) = self;
245	0	l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13).layer(service))
246	0	}
247		}
248
249		impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14> Layer<S>
250		for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14)
251		where
252		L1: Layer<L2::Service>,
253		L2: Layer<L3::Service>,
254		L3: Layer<L4::Service>,
255		L4: Layer<L5::Service>,
256		L5: Layer<L6::Service>,
257		L6: Layer<L7::Service>,
258		L7: Layer<L8::Service>,
259		L8: Layer<L9::Service>,
260		L9: Layer<L10::Service>,
261		L10: Layer<L11::Service>,
262		L11: Layer<L12::Service>,
263		L12: Layer<L13::Service>,
264		L13: Layer<L14::Service>,
265		L14: Layer<S>,
266		{
267		type Service = L1::Service;
268
269	0	fn layer(&self, service: S) -> Self::Service {
270	0	let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14) = self;
271	0	l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14).layer(service))
272	0	}
273		}
274
275		#[rustfmt::skip]
276		impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15> Layer<S>
277		for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15)
278		where
279		L1: Layer<L2::Service>,
280		L2: Layer<L3::Service>,
281		L3: Layer<L4::Service>,
282		L4: Layer<L5::Service>,
283		L5: Layer<L6::Service>,
284		L6: Layer<L7::Service>,
285		L7: Layer<L8::Service>,
286		L8: Layer<L9::Service>,
287		L9: Layer<L10::Service>,
288		L10: Layer<L11::Service>,
289		L11: Layer<L12::Service>,
290		L12: Layer<L13::Service>,
291		L13: Layer<L14::Service>,
292		L14: Layer<L15::Service>,
293		L15: Layer<S>,
294		{
295		type Service = L1::Service;
296
297	0	fn layer(&self, service: S) -> Self::Service {
298	0	let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15) = self;
299	0	l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15).layer(service))
300	0	}
301		}
302
303		#[rustfmt::skip]
304		impl<S, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16> Layer<S>
305		for (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16)
306		where
307		L1: Layer<L2::Service>,
308		L2: Layer<L3::Service>,
309		L3: Layer<L4::Service>,
310		L4: Layer<L5::Service>,
311		L5: Layer<L6::Service>,
312		L6: Layer<L7::Service>,
313		L7: Layer<L8::Service>,
314		L8: Layer<L9::Service>,
315		L9: Layer<L10::Service>,
316		L10: Layer<L11::Service>,
317		L11: Layer<L12::Service>,
318		L12: Layer<L13::Service>,
319		L13: Layer<L14::Service>,
320		L14: Layer<L15::Service>,
321		L15: Layer<L16::Service>,
322		L16: Layer<S>,
323		{
324		type Service = L1::Service;
325
326	0	fn layer(&self, service: S) -> Self::Service {
327	0	let (l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15, l16) = self;
328	0	l1.layer((l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15, l16).layer(service))
329	0	}
330		}