Lines Matching refs:TestClass

15 class TestClass {  class
81 template <void (TestClass::*)()> class IT4 {};
87 template <void (TestClass::*)(), int X> class IT8 {};
93 template class IT1<TestClass::PublicClass>;
94 template struct IT1<TestClass::TemplatePublicClass<int>>;
95 template class IT1<TestClass::AliasPublicClass>;
96 template struct IT2<TestClass::PublicClass, TestClass::PublicClass>;
97 template class IT3<TestClass::publicStaticInt>;
98 template struct IT4<&TestClass::publicFunc>;
99 template class IT4<&TestClass::publicFuncOverloaded>;
100 template class IT5<&TestClass::publicStaticFunc>;
101 template class IT5<&TestClass::publicStaticFuncOverloaded>;
103 template class IT6<TestClass::PublicClass>::template NIT1<TestClass::PublicClass>;
104 template class IT7<TestClass::AliasPublicClass, TestClass::PublicClass>;
105 template struct IT7<TestClass::PublicClass, TestClass::TemplatePublicClass<TestClass::PublicClass>>;
106 template class IT8<&TestClass::publicFunc, TestClass::publicStaticInt>;
107 template class IT8<&TestClass::publicFuncOverloaded, TestClass::publicStaticInt>;
108 template class IT9<TestClass::PublicClass, &TestClass::publicStaticFunc>;
109 template class IT9<TestClass::PublicClass, &TestClass::publicStaticFuncOverloaded>;
110 template class IT9<TestClass::PublicClass, &globalFunction>;
113 template class IT1<TestClass::ProtectedClass>;
114 template struct IT1<TestClass::TemplateProtectedClass<int>>;
115 template class IT1<TestClass::AliasProtectedClass>;
116 template struct IT2<TestClass::ProtectedClass, TestClass::ProtectedClass>;
117 template class IT3<TestClass::protectedStaticInt>;
118 template struct IT4<&TestClass::protectedFunc>;
119 template class IT4<&TestClass::protectedFuncOverloaded>;
120 template class IT5<&TestClass::protectedStaticFunc>;
121 template class IT5<&TestClass::protectedStaticFuncOverloaded>;
122 template class IT6<TestClass::ProtectedClass>::template NIT1<TestClass::ProtectedClass>;
123 template class IT7<TestClass::AliasProtectedClass, TestClass::ProtectedClass>;
124 template struct IT7<TestClass::ProtectedClass, TestClass::TemplateProtectedClass<TestClass::Protect…
125 template class IT8<&TestClass::protectedFunc, TestClass::protectedStaticInt>;
126 template class IT8<&TestClass::protectedFuncOverloaded, TestClass::protectedStaticInt>;
127 template class IT9<TestClass::ProtectedClass, &TestClass::protectedStaticFunc>;
128 template class IT9<TestClass::ProtectedClass, &TestClass::protectedStaticFuncOverloaded>;
129 template class IT9<TestClass::ProtectedClass, &globalFunction>;
132 template class IT1<TestClass::PrivateClass>;
133 template struct IT1<TestClass::TemplatePrivateClass<int>>;
134 template class IT1<TestClass::AliasPrivateClass>;
135 template struct IT2<TestClass::PrivateClass, TestClass::PrivateClass>;
136 template class IT3<TestClass::privateStaticInt>;
137 template struct IT4<&TestClass::privateFunc>;
138 template class IT4<&TestClass::privateFuncOverloaded>;
139 template class IT5<&TestClass::privateStaticFunc>;
140 template class IT5<&TestClass::privateStaticFuncOverloaded>;
141 template class IT6<TestClass::PrivateClass>::template NIT1<TestClass::PrivateClass>;
142 template class IT7<TestClass::AliasPrivateClass, TestClass::PrivateClass>;
143 template struct IT7<TestClass::PrivateClass, TestClass::TemplatePrivateClass<TestClass::PrivateClas…
144 template class IT8<&TestClass::privateFunc, TestClass::privateStaticInt>;
145 template class IT8<&TestClass::privateFuncOverloaded, TestClass::privateStaticInt>;
146 template class IT9<TestClass::PrivateClass, &TestClass::privateStaticFunc>;
147 template class IT9<TestClass::PrivateClass, &TestClass::privateStaticFuncOverloaded>;
148 template class IT9<TestClass::PrivateClass, &globalFunction>;
156 template <void (TestClass::*)()> class CT4 {};
166 template <> class CT1<TestClass::PublicClass>;
167 template <typename T> class CT1<TestClass::TemplatePublicClass<T>>; // not full but let it be here
168 template <> struct CT1<TestClass::TemplatePublicClass<int>>;
169 template <> class CT1<TestClass::AliasPublicClass>;
170 template <> struct CT2<TestClass::PublicClass, TestClass::PublicClass>;
171 template <> class CT3<TestClass::publicStaticInt>;
172 template <> struct CT4<&TestClass::publicFunc>;
173 template <> class CT4<&TestClass::publicFuncOverloaded>;
174 template <> struct CT5<&TestClass::publicStaticFunc>;
175 template <> class CT5<&TestClass::publicStaticFuncOverloaded>;
177 template <> template <> class CT6<TestClass::PublicClass>::NCT1<TestClass::PublicClass>;
179 template <> class CT1<TestClass::PublicClass> final {};
180 template <typename T> class CT1<TestClass::TemplatePublicClass<T>> {};
181 template <> class CT1<TestClass::TemplatePublicClass<int>> final {};
182 template <> class CT1<TestClass::AliasPublicClass> {};
183 template <> class CT2<TestClass::PublicClass, TestClass::PublicClass> final {};
184 template <> class CT3<TestClass::publicStaticInt> {};
185 template <> class CT4<&TestClass::publicFunc> final {};
186 template <> class CT4<&TestClass::publicFuncOverloaded> {};
187 template <> class CT5<&TestClass::publicStaticFunc> final {};
188 template <> class CT5<&TestClass::publicStaticFuncOverloaded> {};
190 template <> template <> class CT6<TestClass::PublicClass>::NCT1<TestClass::PublicClass> {};
191 template <> template <typename NT> class CT6<TestClass::PublicClass>::NCT2 final {}; // declaration
194 template <> class CT1<TestClass::ProtectedClass>;
195 template <typename T> class CT1<TestClass::TemplateProtectedClass<T>>; // not full but let it be he…
196 template <> class CT1<TestClass::TemplateProtectedClass<int>>;
197 template <> struct CT1<TestClass::AliasProtectedClass>;
198 template <> class CT2<TestClass::ProtectedClass, TestClass::ProtectedClass>;
199 template <> struct CT3<TestClass::protectedStaticInt>;
200 template <> class CT4<&TestClass::protectedFunc>;
201 template <> struct CT4<&TestClass::protectedFuncOverloaded>;
202 template <> class CT5<&TestClass::protectedStaticFunc>;
203 template <> class CT5<&TestClass::protectedStaticFuncOverloaded>;
204 template <> template <> class CT6<TestClass::ProtectedClass>::NCT1<TestClass::ProtectedClass>;
206 template <> class CT1<TestClass::ProtectedClass> {};
207 template <typename T> class CT1<TestClass::TemplateProtectedClass<T>> final {}; // not full but let…
208 template <> class CT1<TestClass::TemplateProtectedClass<int>> {};
209 template <> class CT1<TestClass::AliasProtectedClass> final {};
210 template <> class CT2<TestClass::ProtectedClass, TestClass::ProtectedClass> {};
211 template <> class CT3<TestClass::protectedStaticInt> final {};
212 template <> class CT4<&TestClass::protectedFunc> {};
213 template <> class CT4<&TestClass::protectedFuncOverloaded> final {};
214 template <> class CT5<&TestClass::protectedStaticFunc> {};
215 template <> class CT5<&TestClass::protectedStaticFuncOverloaded> final {};
216 template <> template <> class CT6<TestClass::ProtectedClass>::NCT1<TestClass::ProtectedClass> {};
217 template <> template <typename NT> class CT6<TestClass::ProtectedClass>::NCT2 final {}; // declarat…
220 template <> class CT1<TestClass::PrivateClass>;
221 template <typename T> class CT1<TestClass::TemplatePrivateClass<T>>; // not full but let it be here
222 template <> struct CT1<TestClass::TemplatePrivateClass<int>>;
223 template <> class CT1<TestClass::AliasPrivateClass>;
224 template <> struct CT2<TestClass::PrivateClass, TestClass::PrivateClass>;
225 template <> class CT3<TestClass::privateStaticInt>;
226 template <> struct CT4<&TestClass::privateFunc>;
227 template <> class CT4<&TestClass::privateFuncOverloaded>;
228 template <> class CT5<&TestClass::privateStaticFunc>;
229 template <> class CT5<&TestClass::privateStaticFuncOverloaded>;
230 template <> template <> class CT6<TestClass::PrivateClass>::NCT1<TestClass::PrivateClass>;
232 template <> class CT1<TestClass::PrivateClass> final {};
233 template <typename T> class CT1<TestClass::TemplatePrivateClass<T>> {}; // not full but let it be h…
234 template <> class CT1<TestClass::TemplatePrivateClass<int>> final {};
235 template <> class CT1<TestClass::AliasPrivateClass> {};
236 template <> class CT2<TestClass::PrivateClass, TestClass::PrivateClass> final {};
237 template <> class CT3<TestClass::privateStaticInt> {};
238 template <> class CT4<&TestClass::privateFunc> final {};     // PR37424
239 template <> class CT4<&TestClass::privateFuncOverloaded> {}; // PR37424
240 template <> class CT5<&TestClass::privateStaticFunc> final {};
241 template <> class CT5<&TestClass::privateStaticFuncOverloaded> {};
242 template <> template <> class CT6<TestClass::PrivateClass>::NCT1<TestClass::PrivateClass> final {};
243 template <> template <typename NT> class CT6<TestClass::PrivateClass>::NCT2 {}; // declaration
252 template <void (TestClass::*)()> class PCT4 {};
264 template <> class PCT1<TestClass::PublicClass> : P1 {};
265 template <typename T> class PCT1<TestClass::TemplatePublicClass<T>> : PCT2<TestClass::PublicClass, …
266 template <> struct PCT1<TestClass::TemplatePublicClass<int>> : PCT1<TestClass::AliasPublicClass> {};
267 template <> class PCT1<TestClass::AliasProtectedClass> : PCT2<TestClass::PublicClass, int> {};
268 template <> struct PCT2<TestClass::ProtectedClass, TestClass::PublicClass> : PCT3<TestClass::public…
269 template <> class PCT3<TestClass::protectedStaticInt> : PCT4<&TestClass::publicFunc> {};
270 template <> struct PCT4<&TestClass::protectedFunc> : PCT5<&TestClass::publicStaticFunc> {};
271 template <> class PCT4<&TestClass::publicFuncOverloaded> : PCT5<&TestClass::publicStaticFuncOverloa…
272 template <> class PCT5<&TestClass::protectedStaticFunc> : PCT5<&TestClass::publicStaticFuncOverload…
274 template <> class PCT5<&TestClass::protectedStaticFuncOverloaded> : PCT6<TestClass::PublicClass>::N…
277 template <> class PCT5<&globalFunction> : PCT6<TestClass::ProtectedClass>::NPCT1<int> {};
278 template <> template <typename NT> class PCT6<TestClass::PublicClass>::NPCT2 : P1 {}; // declaration
279 template <> template <> class PCT6<TestClass::PublicClass>::NPCT1<TestClass::ProtectedClass> : PCT6…
282 template <> class PCT1<TestClass::PrivateClass> : P1 {};
285 template <typename T> class PCT1<TestClass::TemplatePrivateClass<T>> : PCT2<TestClass::PrivateClass…
287 template <> class PCT1<TestClass::TemplatePrivateClass<int>> : PCT1<TestClass::AliasProtectedClass>…
290 template <> class PCT1<TestClass::AliasPrivateClass> : PCT2<TestClass::ProtectedClass, TestClass::P…
292 template <> class PCT2<TestClass::PrivateClass, TestClass::PrivateClass> : PCT3<TestClass::protecte…
294 template <> class PCT3<TestClass::privateStaticInt> : PCT4<&TestClass::protectedFunc> {};
296 template <> class PCT4<&TestClass::privateFunc> : PCT5<&TestClass::protectedStaticFunc> {};
298 template <> class PCT4<&TestClass::privateFuncOverloaded> : PCT5<&TestClass::protectedStaticFuncOve…
299 template <> class PCT5<&TestClass::privateStaticFunc> : P1 {};
302 template <> template <> class PCT6<TestClass::PrivateClass>::NPCT1<TestClass::PrivateClass> : PCT6<…
304 template <> class PCT5<&TestClass::privateStaticFuncOverloaded> : PCT6<TestClass::PrivateClass>::NP…
305 template <> template <typename NT> class PCT6<TestClass::PrivateClass>::NPCT2 : P1 {}; // declarati…
313 template <typename T, void (TestClass::*)()> class CTT4 {};
325 template <typename T> class CTT1<T, TestClass::PublicClass> final {};
326 template <typename T> class CTT1<T, TestClass::TemplatePublicClass<T>> {};
327 template <typename T> struct CTT1<T, TestClass::TemplatePublicClass<int>> final {};
328 template <typename T> class CTT1<T, TestClass::AliasPublicClass> {};
329 template <typename T> struct CTT2<T, TestClass::PublicClass, TestClass::PublicClass> final {};
330 template <typename T> struct CTT2<TestClass::PublicClass, T, TestClass::PublicClass> {};
331 template <typename T> class CTT2<TestClass::PublicClass, TestClass::PublicClass, T> final {};
332 template <typename T> class CTT3<T, TestClass::publicStaticInt> {};
333 template <typename T> class CTT4<T, &TestClass::publicFunc> final {};
334 template <typename T> class CTT4<T, &TestClass::publicFuncOverloaded> {};
335 template <typename T> class CTT5<T, &TestClass::publicStaticFunc> final {};
336 template <typename T> class CTT5<T, &TestClass::publicStaticFuncOverloaded> {};
339 template <typename T1> template <typename T2> class CTT6<T1, TestClass::PublicClass>::template NCT1…
343 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT3<T3, TestClass::…
345 …ypename T1> template <typename T2> class CTT6<T1, TestClass::PublicClass>::template NCT3<T2, TestC…
347 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT4<T3, TestClass::…
348 template <typename T> class CTT6<TestClass::PublicClass, T> {
352 …late <typename T1> template <typename T2> class CTT6<TestClass::PublicClass, T1>::NCT3<T2, TestCla…
353 template <typename T1> template <typename, typename> class CTT6<TestClass::PublicClass, T1>::NCT4 f…
354 …late <typename T1> template <typename T2> class CTT6<TestClass::PublicClass, T1>::NCT4<T2, TestCla…
358 template <typename T> class CTT1<T, TestClass::ProtectedClass> {};
359 template <typename T> class CTT1<T, TestClass::TemplateProtectedClass<T>> final {};
360 template <typename T> struct CTT1<T, TestClass::TemplateProtectedClass<int>> {};
361 template <typename T> class CTT1<T, TestClass::AliasProtectedClass> final {};
362 template <typename T> struct CTT2<T, TestClass::ProtectedClass, TestClass::ProtectedClass> {};
363 template <typename T> class CTT2<TestClass::ProtectedClass, T, TestClass::ProtectedClass> final {};
364 template <typename T> struct CTT2<TestClass::ProtectedClass, TestClass::ProtectedClass, T> {};
365 template <typename T> class CTT3<T, TestClass::protectedStaticInt> final {};
366 template <typename T> class CTT4<T, &TestClass::protectedFunc> {};
367 template <typename T> class CTT4<T, &TestClass::protectedFuncOverloaded> final {};
368 template <typename T> class CTT5<T, &TestClass::protectedStaticFunc> {};
369 template <typename T> class CTT5<T, &TestClass::protectedStaticFuncOverloaded> final {};
371 template <typename T1> template <typename T2> class CTT6<T1, TestClass::ProtectedClass>::template N…
372 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT3<T3, TestClass::…
374 …pename T1> template <typename T2> class CTT6<T1, TestClass::ProtectedClass>::template NCT3<T2, Tes…
375 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT4<T3, TestClass::…
376 template <typename T> class CTT6<TestClass::ProtectedClass, T> {
380 …te <typename T1> template <typename T2> class CTT6<TestClass::ProtectedClass, T1>::NCT3<T2, TestCl…
381 template <typename T1> template <typename, typename> class CTT6<TestClass::ProtectedClass, T1>::NCT…
382 …te <typename T1> template <typename T2> class CTT6<TestClass::ProtectedClass, T1>::NCT4<T2, TestCl…
386 template <typename T> class CTT1<T, TestClass::PrivateClass> final {};
387 template <typename T> class CTT1<T, TestClass::TemplatePrivateClass<T>> {};
388 template <typename T> struct CTT1<T, TestClass::TemplatePrivateClass<int>> final {};
389 template <typename T> class CTT1<T, TestClass::AliasPrivateClass> {};
390 template <typename T> struct CTT2<T, TestClass::PrivateClass, TestClass::PrivateClass> final {};
391 template <typename T> class CTT2<TestClass::PrivateClass, T, TestClass::PrivateClass> {};
392 template <typename T> struct CTT2<TestClass::PrivateClass, TestClass::PrivateClass, T> final {};
393 template <typename T> class CTT3<T, TestClass::privateStaticInt> {};
394 template <typename T> class CTT4<T, &TestClass::privateFunc> final {};
395 template <typename T> class CTT4<T, &TestClass::privateFuncOverloaded> {};
396 template <typename T> class CTT5<T, &TestClass::privateStaticFunc> final {};
397 template <typename T> class CTT5<T, &TestClass::privateStaticFuncOverloaded> {};
399 template <typename T1> template <typename T2> class CTT6<T1, TestClass::PrivateClass>::template NCT…
400 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT3<T3, TestClass::…
402 …ypename T1> template <typename T2> class CTT6<T1, TestClass::PrivateClass>::template NCT3<T2, Test…
403 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT4<T3, TestClass::…
404 template <typename T> class CTT6<TestClass::PrivateClass, T> {
408 …ate <typename T1> template <typename T2> class CTT6<TestClass::PrivateClass, T1>::NCT3<T2, TestCla…
409 template <typename T1> template <typename, typename> class CTT6<TestClass::PrivateClass, T1>::NCT4 …
410 …ate <typename T1> template <typename T2> class CTT6<TestClass::PrivateClass, T1>::NCT4<T2, TestCla…
418 template <typename T, void (TestClass::*)()> class PCTT4 {};
430 template <typename T> class PCTT1<T, TestClass::PublicClass> : P1 {};
431 …late <typename T> struct PCTT1<T, TestClass::TemplatePublicClass<T>> final : PCTT2<T, TestClass::P…
432 template <typename T> class PCTT1<T, TestClass::TemplatePublicClass<int>> : PCTT1<T, TestClass::Ali…
434 …<typename T> class PCTT1<T, TestClass::TemplatePublicClass<TestClass::TemplateProtectedClass<T>>> …
435 template <typename T> struct PCTT1<T, TestClass::AliasProtectedClass> : PCTT2<T, TestClass::PublicC…
436 template <typename T> class PCTT2<T, TestClass::ProtectedClass, TestClass::PublicClass> final : PCT…
437 template <typename T> class PCTT3<T, TestClass::protectedStaticInt> : PCTT4<T, &TestClass::publicFu…
438 template <typename T> struct PCTT4<T, &TestClass::protectedFunc> final : PCTT5<T, &TestClass::publi…
439 template <typename T> class PCTT4<T, &TestClass::publicFuncOverloaded> : PCTT5<T, &TestClass::publi…
440 template <typename T> class PCTT5<T, &TestClass::protectedStaticFunc> final : PCTT5<T, &TestClass::…
441 …pename T> class PCTT5<T, &TestClass::protectedStaticFuncOverloaded> : PCTT6<T, TestClass::PublicCl…
443 template <typename T> class PCTT5<T, &globalFunction> : PCTT6<T, TestClass::ProtectedClass>::templa…
445 …T2> template <typename T3> class PCTT6<T1, T2>::NCT2 final : PCTT4<T1, &TestClass::protectedFunc> …
449 … T> template <typename NT> class PCTT6<T, TestClass::ProtectedClass>::template NCT1<NT *> : PCTT6<…
452 template <typename T> class PCTT1<T, TestClass::PrivateClass> : P1 {};
455 …ate <typename T> struct PCTT1<T, TestClass::TemplatePrivateClass<T>> final : PCTT2<T, TestClass::P…
457 template <typename T> class PCTT1<T, TestClass::TemplatePrivateClass<int>> : PCTT1<T, TestClass::Al…
460 …plate <typename T> struct PCTT1<T, TestClass::AliasPrivateClass> final : PCTT2<T, TestClass::Prote…
462 …emplate <typename T> class PCTT2<T, TestClass::PrivateClass, TestClass::TemplatePrivateClass<T>> :…
464 template <typename T> class PCTT3<T, TestClass::privateStaticInt> final : PCTT4<T, &TestClass::prot…
466 template <typename T> struct PCTT4<T, &TestClass::privateFunc> : PCTT5<T, &TestClass::protectedStat…
468 template <typename T> class PCTT4<T, &TestClass::privateFuncOverloaded> final : PCTT5<T, &TestClass…
469 template <typename T> class PCTT5<T, &TestClass::privateStaticFunc> : P1 {};
472 …late <typename T> class PCTT6<T, TestClass::PrivateClass>::template PCTT1<TestClass::PrivateClass>…
474 …late <typename T> class PCTT5<T, &TestClass::privateStaticFuncOverloaded> final : PCTT6<T, T>::tem…
475 template <typename T> class PCTT6<TestClass::PrivateClass, T> {
479 template <typename T1> template <typename, typename> class PCTT6<TestClass::PrivateClass, T1>::NCT4…
481 …TestClass::PrivateClass, T1>::NCT3<T2, TestClass::TemplatePrivateClass<TestClass::TemplateProtecte…