BDE 4.14.0 Production release
Loading...
Searching...
No Matches
bslmf_invokeresult_cpp03.h
Go to the documentation of this file.
1/// @file bslmf_invokeresult_cpp03.h
2///
3/// The content of this file has been pre-processed for Doxygen.
4///
5
6
7// bslmf_invokeresult_cpp03.h -*-C++-*-
8
9// Automatically generated file. **DO NOT EDIT**
10
11#ifndef INCLUDED_BSLMF_INVOKERESULT_CPP03
12#define INCLUDED_BSLMF_INVOKERESULT_CPP03
13
14/// @defgroup bslmf_invokeresult_cpp03 bslmf_invokeresult_cpp03
15/// @brief Provide C++03 implementation for bslmf_invokeresult.h
16/// @addtogroup bsl
17/// @{
18/// @addtogroup bslmf
19/// @{
20/// @addtogroup bslmf_invokeresult_cpp03
21/// @{
22///
23/// <h1> Outline </h1>
24/// * <a href="#bslmf_invokeresult_cpp03-purpose"> Purpose</a>
25/// * <a href="#bslmf_invokeresult_cpp03-classes"> Classes </a>
26/// * <a href="#bslmf_invokeresult_cpp03-description"> Description </a>
27///
28/// # Purpose {#bslmf_invokeresult_cpp03-purpose}
29/// Provide C++03 implementation for bslmf_invokeresult.h
30///
31/// # Classes {#bslmf_invokeresult_cpp03-classes}
32/// See bslmf_invokeresult.h for list of classes
33///
34/// @see bslmf_invokeresult
35///
36/// # Description {#bslmf_invokeresult_cpp03-description}
37/// This component is the C++03 translation of a C++11 component,
38/// generated by the 'sim_cpp11_features.pl' program. If the original header
39/// contains any specially delimited regions of C++11 code, then this generated
40/// file contains the C++03 equivalent, i.e., with variadic templates expanded
41/// and rvalue-references replaced by 'bslmf::MovableRef' objects. The header
42/// code in this file is designed to be '#include'd into the original header
43/// when compiling with a C++03 compiler. If there are no specially delimited
44/// regions of C++11 code, then this header contains no code and is not
45/// '#include'd in the original header.
46///
47/// Generated on Sun Sep 1 05:38:31 2024
48/// Command line: sim_cpp11_features.pl bslmf_invokeresult.h
49/// @}
50/** @} */
51/** @} */
52
53/** @addtogroup bsl
54 * @{
55 */
56/** @addtogroup bslmf
57 * @{
58 */
59/** @addtogroup bslmf_invokeresult_cpp03
60 * @{
61 */
62
63#ifdef COMPILING_BSLMF_INVOKERESULT_H
64
65#if defined(BSLS_COMPILERFEATURES_SUPPORT_DECLTYPE) \
66 && !(defined(BSLS_PLATFORM_CMP_MSVC) && BSLS_PLATFORM_CMP_VERSION == 1800)
67// The implementation of C++17 semantics in this component depends upon the
68// use of 'decltype' for expression SFINAE. MSVC 2013 (which has version
69// number 1800) claims to support 'decltype', but does not have a sufficiently
70// functional implementation of expression sfinae to enable C++17 semantics.
71#define BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS 1
72#endif
73
74
75namespace bslmf {
76
77 // ==========================================
78 // class template InvokeResultDeductionFailed
79 // ==========================================
80
81/// When @ref invoke_result cannot deduce the actual return type of a functor
82/// (in C++03 mode), it yields this type as a placeholder. The advantage of
83/// using this placeholder instead of a compilation failure (e.g., using a
84/// static assert) is that the return type of an INVOKE() operation is
85/// often discarded, so our failure to deduce the return type is often
86/// harmless. Since `InvokeResultDeductionFailed` is a return type, it must
87/// be convertible from the actual return type; this conversion is
88/// accomplished by means of a constructor that makes it convertible from
89/// *any* type.
90struct InvokeResultDeductionFailed {
91
92 // CREATORS
93
94 /// Convert from an arbitrary type. The actual argument value is
95 /// discarded.
96 template <class t_TYPE>
97 InvokeResultDeductionFailed(const t_TYPE&)
98 {
99 }
100};
101
102#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
103// {{{ BEGIN GENERATED CODE
104// Command line: sim_cpp11_features.pl bslmf_invokeresult.h
105#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT
106#define BSLMF_INVOKERESULT_VARIADIC_LIMIT 13
107#endif
108#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT_A
109#define BSLMF_INVOKERESULT_VARIADIC_LIMIT_A BSLMF_INVOKERESULT_VARIADIC_LIMIT
110#endif
111
112template <class t_FN
113#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 0
114 , class t_ARGTYPES_0 = BSLS_COMPILERFEATURES_NILT
115#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 0
116
117#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 1
118 , class t_ARGTYPES_1 = BSLS_COMPILERFEATURES_NILT
119#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 1
120
121#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 2
122 , class t_ARGTYPES_2 = BSLS_COMPILERFEATURES_NILT
123#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 2
124
125#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 3
126 , class t_ARGTYPES_3 = BSLS_COMPILERFEATURES_NILT
127#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 3
128
129#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 4
130 , class t_ARGTYPES_4 = BSLS_COMPILERFEATURES_NILT
131#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 4
132
133#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 5
134 , class t_ARGTYPES_5 = BSLS_COMPILERFEATURES_NILT
135#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 5
136
137#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 6
138 , class t_ARGTYPES_6 = BSLS_COMPILERFEATURES_NILT
139#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 6
140
141#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 7
142 , class t_ARGTYPES_7 = BSLS_COMPILERFEATURES_NILT
143#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 7
144
145#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 8
146 , class t_ARGTYPES_8 = BSLS_COMPILERFEATURES_NILT
147#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 8
148
149#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 9
150 , class t_ARGTYPES_9 = BSLS_COMPILERFEATURES_NILT
151#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 9
152
153#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 10
154 , class t_ARGTYPES_10 = BSLS_COMPILERFEATURES_NILT
155#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 10
156
157#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 11
158 , class t_ARGTYPES_11 = BSLS_COMPILERFEATURES_NILT
159#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 11
160
161#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 12
162 , class t_ARGTYPES_12 = BSLS_COMPILERFEATURES_NILT
163#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_A >= 12
164 , class = BSLS_COMPILERFEATURES_NILT>
165struct InvokeResult_BaseCalcUtil;
166
167#else
168// The generated code below is a workaround for the absence of perfect
169// forwarding in some compilers.
170
171template <class t_FN, class... t_ARGTYPES>
172struct InvokeResult_BaseCalcUtil;
173
174// }}} END GENERATED CODE
175#endif
176
177} // close package namespace
178
179
180 // ============================
181 // class template invoke_result
182 // ============================
183
184namespace bsl {
185
186#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
187// {{{ BEGIN GENERATED CODE
188// Command line: sim_cpp11_features.pl bslmf_invokeresult.h
189#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT
190#define BSLMF_INVOKERESULT_VARIADIC_LIMIT 13
191#endif
192#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT_B
193#define BSLMF_INVOKERESULT_VARIADIC_LIMIT_B BSLMF_INVOKERESULT_VARIADIC_LIMIT
194#endif
195
196template <class t_FN
197#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 0
198 , class t_ARGTYPES_0 = BSLS_COMPILERFEATURES_NILT
199#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 0
200
201#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 1
202 , class t_ARGTYPES_1 = BSLS_COMPILERFEATURES_NILT
203#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 1
204
205#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 2
206 , class t_ARGTYPES_2 = BSLS_COMPILERFEATURES_NILT
207#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 2
208
209#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 3
210 , class t_ARGTYPES_3 = BSLS_COMPILERFEATURES_NILT
211#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 3
212
213#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 4
214 , class t_ARGTYPES_4 = BSLS_COMPILERFEATURES_NILT
215#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 4
216
217#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 5
218 , class t_ARGTYPES_5 = BSLS_COMPILERFEATURES_NILT
219#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 5
220
221#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 6
222 , class t_ARGTYPES_6 = BSLS_COMPILERFEATURES_NILT
223#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 6
224
225#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 7
226 , class t_ARGTYPES_7 = BSLS_COMPILERFEATURES_NILT
227#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 7
228
229#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 8
230 , class t_ARGTYPES_8 = BSLS_COMPILERFEATURES_NILT
231#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 8
232
233#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 9
234 , class t_ARGTYPES_9 = BSLS_COMPILERFEATURES_NILT
235#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 9
236
237#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 10
238 , class t_ARGTYPES_10 = BSLS_COMPILERFEATURES_NILT
239#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 10
240
241#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 11
242 , class t_ARGTYPES_11 = BSLS_COMPILERFEATURES_NILT
243#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 11
244
245#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 12
246 , class t_ARGTYPES_12 = BSLS_COMPILERFEATURES_NILT
247#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 12
248 , class = BSLS_COMPILERFEATURES_NILT>
249class invoke_result;
250
251#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 0
252template <class t_FN>
253class invoke_result<t_FN>
254: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN>::
255 BaseType {
256
257};
258#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 0
259
260#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 1
261template <class t_FN, class t_ARGTYPES_01>
262class invoke_result<t_FN, t_ARGTYPES_01>
263: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01>::
264 BaseType {
265
266};
267#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 1
268
269#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 2
270template <class t_FN, class t_ARGTYPES_01,
271 class t_ARGTYPES_02>
272class invoke_result<t_FN, t_ARGTYPES_01,
273 t_ARGTYPES_02>
274: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
275 t_ARGTYPES_02>::
276 BaseType {
277
278};
279#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 2
280
281#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 3
282template <class t_FN, class t_ARGTYPES_01,
283 class t_ARGTYPES_02,
284 class t_ARGTYPES_03>
285class invoke_result<t_FN, t_ARGTYPES_01,
286 t_ARGTYPES_02,
287 t_ARGTYPES_03>
288: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
289 t_ARGTYPES_02,
290 t_ARGTYPES_03>::
291 BaseType {
292
293};
294#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 3
295
296#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 4
297template <class t_FN, class t_ARGTYPES_01,
298 class t_ARGTYPES_02,
299 class t_ARGTYPES_03,
300 class t_ARGTYPES_04>
301class invoke_result<t_FN, t_ARGTYPES_01,
302 t_ARGTYPES_02,
303 t_ARGTYPES_03,
304 t_ARGTYPES_04>
305: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
306 t_ARGTYPES_02,
307 t_ARGTYPES_03,
308 t_ARGTYPES_04>::
309 BaseType {
310
311};
312#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 4
313
314#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 5
315template <class t_FN, class t_ARGTYPES_01,
316 class t_ARGTYPES_02,
317 class t_ARGTYPES_03,
318 class t_ARGTYPES_04,
319 class t_ARGTYPES_05>
320class invoke_result<t_FN, t_ARGTYPES_01,
321 t_ARGTYPES_02,
322 t_ARGTYPES_03,
323 t_ARGTYPES_04,
324 t_ARGTYPES_05>
325: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
326 t_ARGTYPES_02,
327 t_ARGTYPES_03,
328 t_ARGTYPES_04,
329 t_ARGTYPES_05>::
330 BaseType {
331
332};
333#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 5
334
335#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 6
336template <class t_FN, class t_ARGTYPES_01,
337 class t_ARGTYPES_02,
338 class t_ARGTYPES_03,
339 class t_ARGTYPES_04,
340 class t_ARGTYPES_05,
341 class t_ARGTYPES_06>
342class invoke_result<t_FN, t_ARGTYPES_01,
343 t_ARGTYPES_02,
344 t_ARGTYPES_03,
345 t_ARGTYPES_04,
346 t_ARGTYPES_05,
347 t_ARGTYPES_06>
348: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
349 t_ARGTYPES_02,
350 t_ARGTYPES_03,
351 t_ARGTYPES_04,
352 t_ARGTYPES_05,
353 t_ARGTYPES_06>::
354 BaseType {
355
356};
357#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 6
358
359#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 7
360template <class t_FN, class t_ARGTYPES_01,
361 class t_ARGTYPES_02,
362 class t_ARGTYPES_03,
363 class t_ARGTYPES_04,
364 class t_ARGTYPES_05,
365 class t_ARGTYPES_06,
366 class t_ARGTYPES_07>
367class invoke_result<t_FN, t_ARGTYPES_01,
368 t_ARGTYPES_02,
369 t_ARGTYPES_03,
370 t_ARGTYPES_04,
371 t_ARGTYPES_05,
372 t_ARGTYPES_06,
373 t_ARGTYPES_07>
374: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
375 t_ARGTYPES_02,
376 t_ARGTYPES_03,
377 t_ARGTYPES_04,
378 t_ARGTYPES_05,
379 t_ARGTYPES_06,
380 t_ARGTYPES_07>::
381 BaseType {
382
383};
384#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 7
385
386#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 8
387template <class t_FN, class t_ARGTYPES_01,
388 class t_ARGTYPES_02,
389 class t_ARGTYPES_03,
390 class t_ARGTYPES_04,
391 class t_ARGTYPES_05,
392 class t_ARGTYPES_06,
393 class t_ARGTYPES_07,
394 class t_ARGTYPES_08>
395class invoke_result<t_FN, t_ARGTYPES_01,
396 t_ARGTYPES_02,
397 t_ARGTYPES_03,
398 t_ARGTYPES_04,
399 t_ARGTYPES_05,
400 t_ARGTYPES_06,
401 t_ARGTYPES_07,
402 t_ARGTYPES_08>
403: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
404 t_ARGTYPES_02,
405 t_ARGTYPES_03,
406 t_ARGTYPES_04,
407 t_ARGTYPES_05,
408 t_ARGTYPES_06,
409 t_ARGTYPES_07,
410 t_ARGTYPES_08>::
411 BaseType {
412
413};
414#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 8
415
416#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 9
417template <class t_FN, class t_ARGTYPES_01,
418 class t_ARGTYPES_02,
419 class t_ARGTYPES_03,
420 class t_ARGTYPES_04,
421 class t_ARGTYPES_05,
422 class t_ARGTYPES_06,
423 class t_ARGTYPES_07,
424 class t_ARGTYPES_08,
425 class t_ARGTYPES_09>
426class invoke_result<t_FN, t_ARGTYPES_01,
427 t_ARGTYPES_02,
428 t_ARGTYPES_03,
429 t_ARGTYPES_04,
430 t_ARGTYPES_05,
431 t_ARGTYPES_06,
432 t_ARGTYPES_07,
433 t_ARGTYPES_08,
434 t_ARGTYPES_09>
435: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
436 t_ARGTYPES_02,
437 t_ARGTYPES_03,
438 t_ARGTYPES_04,
439 t_ARGTYPES_05,
440 t_ARGTYPES_06,
441 t_ARGTYPES_07,
442 t_ARGTYPES_08,
443 t_ARGTYPES_09>::
444 BaseType {
445
446};
447#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 9
448
449#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 10
450template <class t_FN, class t_ARGTYPES_01,
451 class t_ARGTYPES_02,
452 class t_ARGTYPES_03,
453 class t_ARGTYPES_04,
454 class t_ARGTYPES_05,
455 class t_ARGTYPES_06,
456 class t_ARGTYPES_07,
457 class t_ARGTYPES_08,
458 class t_ARGTYPES_09,
459 class t_ARGTYPES_10>
460class invoke_result<t_FN, t_ARGTYPES_01,
461 t_ARGTYPES_02,
462 t_ARGTYPES_03,
463 t_ARGTYPES_04,
464 t_ARGTYPES_05,
465 t_ARGTYPES_06,
466 t_ARGTYPES_07,
467 t_ARGTYPES_08,
468 t_ARGTYPES_09,
469 t_ARGTYPES_10>
470: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
471 t_ARGTYPES_02,
472 t_ARGTYPES_03,
473 t_ARGTYPES_04,
474 t_ARGTYPES_05,
475 t_ARGTYPES_06,
476 t_ARGTYPES_07,
477 t_ARGTYPES_08,
478 t_ARGTYPES_09,
479 t_ARGTYPES_10>::
480 BaseType {
481
482};
483#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 10
484
485#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 11
486template <class t_FN, class t_ARGTYPES_01,
487 class t_ARGTYPES_02,
488 class t_ARGTYPES_03,
489 class t_ARGTYPES_04,
490 class t_ARGTYPES_05,
491 class t_ARGTYPES_06,
492 class t_ARGTYPES_07,
493 class t_ARGTYPES_08,
494 class t_ARGTYPES_09,
495 class t_ARGTYPES_10,
496 class t_ARGTYPES_11>
497class invoke_result<t_FN, t_ARGTYPES_01,
498 t_ARGTYPES_02,
499 t_ARGTYPES_03,
500 t_ARGTYPES_04,
501 t_ARGTYPES_05,
502 t_ARGTYPES_06,
503 t_ARGTYPES_07,
504 t_ARGTYPES_08,
505 t_ARGTYPES_09,
506 t_ARGTYPES_10,
507 t_ARGTYPES_11>
508: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
509 t_ARGTYPES_02,
510 t_ARGTYPES_03,
511 t_ARGTYPES_04,
512 t_ARGTYPES_05,
513 t_ARGTYPES_06,
514 t_ARGTYPES_07,
515 t_ARGTYPES_08,
516 t_ARGTYPES_09,
517 t_ARGTYPES_10,
518 t_ARGTYPES_11>::
519 BaseType {
520
521};
522#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 11
523
524#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 12
525template <class t_FN, class t_ARGTYPES_01,
526 class t_ARGTYPES_02,
527 class t_ARGTYPES_03,
528 class t_ARGTYPES_04,
529 class t_ARGTYPES_05,
530 class t_ARGTYPES_06,
531 class t_ARGTYPES_07,
532 class t_ARGTYPES_08,
533 class t_ARGTYPES_09,
534 class t_ARGTYPES_10,
535 class t_ARGTYPES_11,
536 class t_ARGTYPES_12>
537class invoke_result<t_FN, t_ARGTYPES_01,
538 t_ARGTYPES_02,
539 t_ARGTYPES_03,
540 t_ARGTYPES_04,
541 t_ARGTYPES_05,
542 t_ARGTYPES_06,
543 t_ARGTYPES_07,
544 t_ARGTYPES_08,
545 t_ARGTYPES_09,
546 t_ARGTYPES_10,
547 t_ARGTYPES_11,
548 t_ARGTYPES_12>
549: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
550 t_ARGTYPES_02,
551 t_ARGTYPES_03,
552 t_ARGTYPES_04,
553 t_ARGTYPES_05,
554 t_ARGTYPES_06,
555 t_ARGTYPES_07,
556 t_ARGTYPES_08,
557 t_ARGTYPES_09,
558 t_ARGTYPES_10,
559 t_ARGTYPES_11,
560 t_ARGTYPES_12>::
561 BaseType {
562
563};
564#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 12
565
566#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 13
567template <class t_FN, class t_ARGTYPES_01,
568 class t_ARGTYPES_02,
569 class t_ARGTYPES_03,
570 class t_ARGTYPES_04,
571 class t_ARGTYPES_05,
572 class t_ARGTYPES_06,
573 class t_ARGTYPES_07,
574 class t_ARGTYPES_08,
575 class t_ARGTYPES_09,
576 class t_ARGTYPES_10,
577 class t_ARGTYPES_11,
578 class t_ARGTYPES_12,
579 class t_ARGTYPES_13>
580class invoke_result<t_FN, t_ARGTYPES_01,
581 t_ARGTYPES_02,
582 t_ARGTYPES_03,
583 t_ARGTYPES_04,
584 t_ARGTYPES_05,
585 t_ARGTYPES_06,
586 t_ARGTYPES_07,
587 t_ARGTYPES_08,
588 t_ARGTYPES_09,
589 t_ARGTYPES_10,
590 t_ARGTYPES_11,
591 t_ARGTYPES_12,
592 t_ARGTYPES_13>
593: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
594 t_ARGTYPES_02,
595 t_ARGTYPES_03,
596 t_ARGTYPES_04,
597 t_ARGTYPES_05,
598 t_ARGTYPES_06,
599 t_ARGTYPES_07,
600 t_ARGTYPES_08,
601 t_ARGTYPES_09,
602 t_ARGTYPES_10,
603 t_ARGTYPES_11,
604 t_ARGTYPES_12,
605 t_ARGTYPES_13>::
606 BaseType {
607
608};
609#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 13
610
611
612#ifdef BSLS_COMPILERFEATURES_SUPPORT_ALIAS_TEMPLATES
613
614
615#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 0
616template <class t_FN>
617using invoke_result_t = typename invoke_result<t_FN,
618 BSLS_COMPILERFEATURES_FILLT(13)
619 >::type;
620#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 0
621
622#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 1
623template <class t_FN, class t_ARGTYPES_01>
624using invoke_result_t = typename invoke_result<t_FN,
625 t_ARGTYPES_01,
626 BSLS_COMPILERFEATURES_FILLT(12)
627 >::type;
628#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 1
629
630#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 2
631template <class t_FN, class t_ARGTYPES_01,
632 class t_ARGTYPES_02>
633using invoke_result_t = typename invoke_result<t_FN,
634 t_ARGTYPES_01,
635 t_ARGTYPES_02,
636 BSLS_COMPILERFEATURES_FILLT(11)
637 >::type;
638#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 2
639
640#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 3
641template <class t_FN, class t_ARGTYPES_01,
642 class t_ARGTYPES_02,
643 class t_ARGTYPES_03>
644using invoke_result_t = typename invoke_result<t_FN,
645 t_ARGTYPES_01,
646 t_ARGTYPES_02,
647 t_ARGTYPES_03,
648 BSLS_COMPILERFEATURES_FILLT(10)
649 >::type;
650#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 3
651
652#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 4
653template <class t_FN, class t_ARGTYPES_01,
654 class t_ARGTYPES_02,
655 class t_ARGTYPES_03,
656 class t_ARGTYPES_04>
657using invoke_result_t = typename invoke_result<t_FN,
658 t_ARGTYPES_01,
659 t_ARGTYPES_02,
660 t_ARGTYPES_03,
661 t_ARGTYPES_04,
662 BSLS_COMPILERFEATURES_FILLT( 9)
663 >::type;
664#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 4
665
666#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 5
667template <class t_FN, class t_ARGTYPES_01,
668 class t_ARGTYPES_02,
669 class t_ARGTYPES_03,
670 class t_ARGTYPES_04,
671 class t_ARGTYPES_05>
672using invoke_result_t = typename invoke_result<t_FN,
673 t_ARGTYPES_01,
674 t_ARGTYPES_02,
675 t_ARGTYPES_03,
676 t_ARGTYPES_04,
677 t_ARGTYPES_05,
678 BSLS_COMPILERFEATURES_FILLT( 8)
679 >::type;
680#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 5
681
682#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 6
683template <class t_FN, class t_ARGTYPES_01,
684 class t_ARGTYPES_02,
685 class t_ARGTYPES_03,
686 class t_ARGTYPES_04,
687 class t_ARGTYPES_05,
688 class t_ARGTYPES_06>
689using invoke_result_t = typename invoke_result<t_FN,
690 t_ARGTYPES_01,
691 t_ARGTYPES_02,
692 t_ARGTYPES_03,
693 t_ARGTYPES_04,
694 t_ARGTYPES_05,
695 t_ARGTYPES_06,
696 BSLS_COMPILERFEATURES_FILLT( 7)
697 >::type;
698#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 6
699
700#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 7
701template <class t_FN, class t_ARGTYPES_01,
702 class t_ARGTYPES_02,
703 class t_ARGTYPES_03,
704 class t_ARGTYPES_04,
705 class t_ARGTYPES_05,
706 class t_ARGTYPES_06,
707 class t_ARGTYPES_07>
708using invoke_result_t = typename invoke_result<t_FN,
709 t_ARGTYPES_01,
710 t_ARGTYPES_02,
711 t_ARGTYPES_03,
712 t_ARGTYPES_04,
713 t_ARGTYPES_05,
714 t_ARGTYPES_06,
715 t_ARGTYPES_07,
716 BSLS_COMPILERFEATURES_FILLT( 6)
717 >::type;
718#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 7
719
720#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 8
721template <class t_FN, class t_ARGTYPES_01,
722 class t_ARGTYPES_02,
723 class t_ARGTYPES_03,
724 class t_ARGTYPES_04,
725 class t_ARGTYPES_05,
726 class t_ARGTYPES_06,
727 class t_ARGTYPES_07,
728 class t_ARGTYPES_08>
729using invoke_result_t = typename invoke_result<t_FN,
730 t_ARGTYPES_01,
731 t_ARGTYPES_02,
732 t_ARGTYPES_03,
733 t_ARGTYPES_04,
734 t_ARGTYPES_05,
735 t_ARGTYPES_06,
736 t_ARGTYPES_07,
737 t_ARGTYPES_08,
738 BSLS_COMPILERFEATURES_FILLT( 5)
739 >::type;
740#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 8
741
742#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 9
743template <class t_FN, class t_ARGTYPES_01,
744 class t_ARGTYPES_02,
745 class t_ARGTYPES_03,
746 class t_ARGTYPES_04,
747 class t_ARGTYPES_05,
748 class t_ARGTYPES_06,
749 class t_ARGTYPES_07,
750 class t_ARGTYPES_08,
751 class t_ARGTYPES_09>
752using invoke_result_t = typename invoke_result<t_FN,
753 t_ARGTYPES_01,
754 t_ARGTYPES_02,
755 t_ARGTYPES_03,
756 t_ARGTYPES_04,
757 t_ARGTYPES_05,
758 t_ARGTYPES_06,
759 t_ARGTYPES_07,
760 t_ARGTYPES_08,
761 t_ARGTYPES_09,
762 BSLS_COMPILERFEATURES_FILLT( 4)
763 >::type;
764#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 9
765
766#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 10
767template <class t_FN, class t_ARGTYPES_01,
768 class t_ARGTYPES_02,
769 class t_ARGTYPES_03,
770 class t_ARGTYPES_04,
771 class t_ARGTYPES_05,
772 class t_ARGTYPES_06,
773 class t_ARGTYPES_07,
774 class t_ARGTYPES_08,
775 class t_ARGTYPES_09,
776 class t_ARGTYPES_10>
777using invoke_result_t = typename invoke_result<t_FN,
778 t_ARGTYPES_01,
779 t_ARGTYPES_02,
780 t_ARGTYPES_03,
781 t_ARGTYPES_04,
782 t_ARGTYPES_05,
783 t_ARGTYPES_06,
784 t_ARGTYPES_07,
785 t_ARGTYPES_08,
786 t_ARGTYPES_09,
787 t_ARGTYPES_10,
788 BSLS_COMPILERFEATURES_FILLT( 3)
789 >::type;
790#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 10
791
792#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 11
793template <class t_FN, class t_ARGTYPES_01,
794 class t_ARGTYPES_02,
795 class t_ARGTYPES_03,
796 class t_ARGTYPES_04,
797 class t_ARGTYPES_05,
798 class t_ARGTYPES_06,
799 class t_ARGTYPES_07,
800 class t_ARGTYPES_08,
801 class t_ARGTYPES_09,
802 class t_ARGTYPES_10,
803 class t_ARGTYPES_11>
804using invoke_result_t = typename invoke_result<t_FN,
805 t_ARGTYPES_01,
806 t_ARGTYPES_02,
807 t_ARGTYPES_03,
808 t_ARGTYPES_04,
809 t_ARGTYPES_05,
810 t_ARGTYPES_06,
811 t_ARGTYPES_07,
812 t_ARGTYPES_08,
813 t_ARGTYPES_09,
814 t_ARGTYPES_10,
815 t_ARGTYPES_11,
816 BSLS_COMPILERFEATURES_FILLT( 2)
817 >::type;
818#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 11
819
820#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 12
821template <class t_FN, class t_ARGTYPES_01,
822 class t_ARGTYPES_02,
823 class t_ARGTYPES_03,
824 class t_ARGTYPES_04,
825 class t_ARGTYPES_05,
826 class t_ARGTYPES_06,
827 class t_ARGTYPES_07,
828 class t_ARGTYPES_08,
829 class t_ARGTYPES_09,
830 class t_ARGTYPES_10,
831 class t_ARGTYPES_11,
832 class t_ARGTYPES_12>
833using invoke_result_t = typename invoke_result<t_FN,
834 t_ARGTYPES_01,
835 t_ARGTYPES_02,
836 t_ARGTYPES_03,
837 t_ARGTYPES_04,
838 t_ARGTYPES_05,
839 t_ARGTYPES_06,
840 t_ARGTYPES_07,
841 t_ARGTYPES_08,
842 t_ARGTYPES_09,
843 t_ARGTYPES_10,
844 t_ARGTYPES_11,
845 t_ARGTYPES_12,
846 BSLS_COMPILERFEATURES_FILLT( 1)
847 >::type;
848#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 12
849
850#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 13
851template <class t_FN, class t_ARGTYPES_01,
852 class t_ARGTYPES_02,
853 class t_ARGTYPES_03,
854 class t_ARGTYPES_04,
855 class t_ARGTYPES_05,
856 class t_ARGTYPES_06,
857 class t_ARGTYPES_07,
858 class t_ARGTYPES_08,
859 class t_ARGTYPES_09,
860 class t_ARGTYPES_10,
861 class t_ARGTYPES_11,
862 class t_ARGTYPES_12,
863 class t_ARGTYPES_13>
864using invoke_result_t = typename invoke_result<t_FN,
865 t_ARGTYPES_01,
866 t_ARGTYPES_02,
867 t_ARGTYPES_03,
868 t_ARGTYPES_04,
869 t_ARGTYPES_05,
870 t_ARGTYPES_06,
871 t_ARGTYPES_07,
872 t_ARGTYPES_08,
873 t_ARGTYPES_09,
874 t_ARGTYPES_10,
875 t_ARGTYPES_11,
876 t_ARGTYPES_12,
877 t_ARGTYPES_13,
878 BSLS_COMPILERFEATURES_FILLT( 0)
879 >::type;
880#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_B >= 13
881
882#endif
883#else
884// The generated code below is a workaround for the absence of perfect
885// forwarding in some compilers.
886
887template <class t_FN, class... t_ARGTYPES>
888class invoke_result
889: public BloombergLP::bslmf::InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES...>::
890 BaseType {
891
892};
893
894#ifdef BSLS_COMPILERFEATURES_SUPPORT_ALIAS_TEMPLATES
895
896
897template <class t_FN, class... t_ARGTYPES>
898using invoke_result_t = typename invoke_result<t_FN, t_ARGTYPES...>::type;
899#endif
900
901// }}} END GENERATED CODE
902#endif
903
904} // close namespace bsl
905
906// ============================================================================
907// TEMPLATE IMPLEMENTATIONS
908// ============================================================================
909
910
911namespace bslmf {
912
913#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
914// {{{ BEGIN GENERATED CODE
915// Command line: sim_cpp11_features.pl bslmf_invokeresult.h
916#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT
917#define BSLMF_INVOKERESULT_VARIADIC_LIMIT 13
918#endif
919#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT_C
920#define BSLMF_INVOKERESULT_VARIADIC_LIMIT_C BSLMF_INVOKERESULT_VARIADIC_LIMIT
921#endif
922
923template <bool t_IS_FUNCPTR,
924 bool t_IS_MEMFUNCPTR,
925 bool t_IS_MEMOBJPTR,
926 class t_FN
927#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 0
928 , class t_ARGTYPES_0 = BSLS_COMPILERFEATURES_NILT
929#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 0
930
931#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 1
932 , class t_ARGTYPES_1 = BSLS_COMPILERFEATURES_NILT
933#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 1
934
935#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 2
936 , class t_ARGTYPES_2 = BSLS_COMPILERFEATURES_NILT
937#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 2
938
939#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 3
940 , class t_ARGTYPES_3 = BSLS_COMPILERFEATURES_NILT
941#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 3
942
943#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 4
944 , class t_ARGTYPES_4 = BSLS_COMPILERFEATURES_NILT
945#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 4
946
947#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 5
948 , class t_ARGTYPES_5 = BSLS_COMPILERFEATURES_NILT
949#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 5
950
951#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 6
952 , class t_ARGTYPES_6 = BSLS_COMPILERFEATURES_NILT
953#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 6
954
955#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 7
956 , class t_ARGTYPES_7 = BSLS_COMPILERFEATURES_NILT
957#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 7
958
959#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 8
960 , class t_ARGTYPES_8 = BSLS_COMPILERFEATURES_NILT
961#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 8
962
963#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 9
964 , class t_ARGTYPES_9 = BSLS_COMPILERFEATURES_NILT
965#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 9
966
967#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 10
968 , class t_ARGTYPES_10 = BSLS_COMPILERFEATURES_NILT
969#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 10
970
971#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 11
972 , class t_ARGTYPES_11 = BSLS_COMPILERFEATURES_NILT
973#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 11
974
975#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 12
976 , class t_ARGTYPES_12 = BSLS_COMPILERFEATURES_NILT
977#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 12
978 , class = BSLS_COMPILERFEATURES_NILT>
979struct InvokeResult_Imp;
980
981
982
983#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 0
984template <class t_FN>
985struct InvokeResult_BaseCalcUtil<t_FN> {
986
987 private:
988
989 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
990
991 enum {
992 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
993 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
994 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
995 };
996
997 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
998 k_IS_MEMOBJPTR,
999 F,
1000 t_FN>::type FwdFn;
1001
1002 public:
1003
1004 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1005 k_IS_MEMFUNCPTR,
1006 k_IS_MEMOBJPTR,
1007 FwdFn>
1008 BaseType;
1009};
1010#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 0
1011
1012#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 1
1013template <class t_FN, class t_ARGTYPES_01>
1014struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01> {
1015
1016 private:
1017
1018 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1019
1020 enum {
1021 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1022 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1023 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1024 };
1025
1026 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1027 k_IS_MEMOBJPTR,
1028 F,
1029 t_FN>::type FwdFn;
1030
1031 public:
1032
1033 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1034 k_IS_MEMFUNCPTR,
1035 k_IS_MEMOBJPTR,
1036 FwdFn,
1037 t_ARGTYPES_01>
1038 BaseType;
1039};
1040#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 1
1041
1042#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 2
1043template <class t_FN, class t_ARGTYPES_01,
1044 class t_ARGTYPES_02>
1045struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1046 t_ARGTYPES_02> {
1047
1048 private:
1049
1050 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1051
1052 enum {
1053 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1054 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1055 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1056 };
1057
1058 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1059 k_IS_MEMOBJPTR,
1060 F,
1061 t_FN>::type FwdFn;
1062
1063 public:
1064
1065 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1066 k_IS_MEMFUNCPTR,
1067 k_IS_MEMOBJPTR,
1068 FwdFn,
1069 t_ARGTYPES_01,
1070 t_ARGTYPES_02>
1071 BaseType;
1072};
1073#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 2
1074
1075#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 3
1076template <class t_FN, class t_ARGTYPES_01,
1077 class t_ARGTYPES_02,
1078 class t_ARGTYPES_03>
1079struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1080 t_ARGTYPES_02,
1081 t_ARGTYPES_03> {
1082
1083 private:
1084
1085 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1086
1087 enum {
1088 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1089 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1090 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1091 };
1092
1093 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1094 k_IS_MEMOBJPTR,
1095 F,
1096 t_FN>::type FwdFn;
1097
1098 public:
1099
1100 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1101 k_IS_MEMFUNCPTR,
1102 k_IS_MEMOBJPTR,
1103 FwdFn,
1104 t_ARGTYPES_01,
1105 t_ARGTYPES_02,
1106 t_ARGTYPES_03>
1107 BaseType;
1108};
1109#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 3
1110
1111#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 4
1112template <class t_FN, class t_ARGTYPES_01,
1113 class t_ARGTYPES_02,
1114 class t_ARGTYPES_03,
1115 class t_ARGTYPES_04>
1116struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1117 t_ARGTYPES_02,
1118 t_ARGTYPES_03,
1119 t_ARGTYPES_04> {
1120
1121 private:
1122
1123 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1124
1125 enum {
1126 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1127 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1128 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1129 };
1130
1131 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1132 k_IS_MEMOBJPTR,
1133 F,
1134 t_FN>::type FwdFn;
1135
1136 public:
1137
1138 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1139 k_IS_MEMFUNCPTR,
1140 k_IS_MEMOBJPTR,
1141 FwdFn,
1142 t_ARGTYPES_01,
1143 t_ARGTYPES_02,
1144 t_ARGTYPES_03,
1145 t_ARGTYPES_04>
1146 BaseType;
1147};
1148#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 4
1149
1150#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 5
1151template <class t_FN, class t_ARGTYPES_01,
1152 class t_ARGTYPES_02,
1153 class t_ARGTYPES_03,
1154 class t_ARGTYPES_04,
1155 class t_ARGTYPES_05>
1156struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1157 t_ARGTYPES_02,
1158 t_ARGTYPES_03,
1159 t_ARGTYPES_04,
1160 t_ARGTYPES_05> {
1161
1162 private:
1163
1164 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1165
1166 enum {
1167 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1168 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1169 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1170 };
1171
1172 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1173 k_IS_MEMOBJPTR,
1174 F,
1175 t_FN>::type FwdFn;
1176
1177 public:
1178
1179 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1180 k_IS_MEMFUNCPTR,
1181 k_IS_MEMOBJPTR,
1182 FwdFn,
1183 t_ARGTYPES_01,
1184 t_ARGTYPES_02,
1185 t_ARGTYPES_03,
1186 t_ARGTYPES_04,
1187 t_ARGTYPES_05>
1188 BaseType;
1189};
1190#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 5
1191
1192#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 6
1193template <class t_FN, class t_ARGTYPES_01,
1194 class t_ARGTYPES_02,
1195 class t_ARGTYPES_03,
1196 class t_ARGTYPES_04,
1197 class t_ARGTYPES_05,
1198 class t_ARGTYPES_06>
1199struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1200 t_ARGTYPES_02,
1201 t_ARGTYPES_03,
1202 t_ARGTYPES_04,
1203 t_ARGTYPES_05,
1204 t_ARGTYPES_06> {
1205
1206 private:
1207
1208 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1209
1210 enum {
1211 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1212 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1213 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1214 };
1215
1216 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1217 k_IS_MEMOBJPTR,
1218 F,
1219 t_FN>::type FwdFn;
1220
1221 public:
1222
1223 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1224 k_IS_MEMFUNCPTR,
1225 k_IS_MEMOBJPTR,
1226 FwdFn,
1227 t_ARGTYPES_01,
1228 t_ARGTYPES_02,
1229 t_ARGTYPES_03,
1230 t_ARGTYPES_04,
1231 t_ARGTYPES_05,
1232 t_ARGTYPES_06>
1233 BaseType;
1234};
1235#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 6
1236
1237#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 7
1238template <class t_FN, class t_ARGTYPES_01,
1239 class t_ARGTYPES_02,
1240 class t_ARGTYPES_03,
1241 class t_ARGTYPES_04,
1242 class t_ARGTYPES_05,
1243 class t_ARGTYPES_06,
1244 class t_ARGTYPES_07>
1245struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1246 t_ARGTYPES_02,
1247 t_ARGTYPES_03,
1248 t_ARGTYPES_04,
1249 t_ARGTYPES_05,
1250 t_ARGTYPES_06,
1251 t_ARGTYPES_07> {
1252
1253 private:
1254
1255 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1256
1257 enum {
1258 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1259 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1260 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1261 };
1262
1263 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1264 k_IS_MEMOBJPTR,
1265 F,
1266 t_FN>::type FwdFn;
1267
1268 public:
1269
1270 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1271 k_IS_MEMFUNCPTR,
1272 k_IS_MEMOBJPTR,
1273 FwdFn,
1274 t_ARGTYPES_01,
1275 t_ARGTYPES_02,
1276 t_ARGTYPES_03,
1277 t_ARGTYPES_04,
1278 t_ARGTYPES_05,
1279 t_ARGTYPES_06,
1280 t_ARGTYPES_07>
1281 BaseType;
1282};
1283#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 7
1284
1285#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 8
1286template <class t_FN, class t_ARGTYPES_01,
1287 class t_ARGTYPES_02,
1288 class t_ARGTYPES_03,
1289 class t_ARGTYPES_04,
1290 class t_ARGTYPES_05,
1291 class t_ARGTYPES_06,
1292 class t_ARGTYPES_07,
1293 class t_ARGTYPES_08>
1294struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1295 t_ARGTYPES_02,
1296 t_ARGTYPES_03,
1297 t_ARGTYPES_04,
1298 t_ARGTYPES_05,
1299 t_ARGTYPES_06,
1300 t_ARGTYPES_07,
1301 t_ARGTYPES_08> {
1302
1303 private:
1304
1305 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1306
1307 enum {
1308 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1309 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1310 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1311 };
1312
1313 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1314 k_IS_MEMOBJPTR,
1315 F,
1316 t_FN>::type FwdFn;
1317
1318 public:
1319
1320 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1321 k_IS_MEMFUNCPTR,
1322 k_IS_MEMOBJPTR,
1323 FwdFn,
1324 t_ARGTYPES_01,
1325 t_ARGTYPES_02,
1326 t_ARGTYPES_03,
1327 t_ARGTYPES_04,
1328 t_ARGTYPES_05,
1329 t_ARGTYPES_06,
1330 t_ARGTYPES_07,
1331 t_ARGTYPES_08>
1332 BaseType;
1333};
1334#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 8
1335
1336#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 9
1337template <class t_FN, class t_ARGTYPES_01,
1338 class t_ARGTYPES_02,
1339 class t_ARGTYPES_03,
1340 class t_ARGTYPES_04,
1341 class t_ARGTYPES_05,
1342 class t_ARGTYPES_06,
1343 class t_ARGTYPES_07,
1344 class t_ARGTYPES_08,
1345 class t_ARGTYPES_09>
1346struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1347 t_ARGTYPES_02,
1348 t_ARGTYPES_03,
1349 t_ARGTYPES_04,
1350 t_ARGTYPES_05,
1351 t_ARGTYPES_06,
1352 t_ARGTYPES_07,
1353 t_ARGTYPES_08,
1354 t_ARGTYPES_09> {
1355
1356 private:
1357
1358 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1359
1360 enum {
1361 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1362 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1363 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1364 };
1365
1366 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1367 k_IS_MEMOBJPTR,
1368 F,
1369 t_FN>::type FwdFn;
1370
1371 public:
1372
1373 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1374 k_IS_MEMFUNCPTR,
1375 k_IS_MEMOBJPTR,
1376 FwdFn,
1377 t_ARGTYPES_01,
1378 t_ARGTYPES_02,
1379 t_ARGTYPES_03,
1380 t_ARGTYPES_04,
1381 t_ARGTYPES_05,
1382 t_ARGTYPES_06,
1383 t_ARGTYPES_07,
1384 t_ARGTYPES_08,
1385 t_ARGTYPES_09>
1386 BaseType;
1387};
1388#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 9
1389
1390#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 10
1391template <class t_FN, class t_ARGTYPES_01,
1392 class t_ARGTYPES_02,
1393 class t_ARGTYPES_03,
1394 class t_ARGTYPES_04,
1395 class t_ARGTYPES_05,
1396 class t_ARGTYPES_06,
1397 class t_ARGTYPES_07,
1398 class t_ARGTYPES_08,
1399 class t_ARGTYPES_09,
1400 class t_ARGTYPES_10>
1401struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1402 t_ARGTYPES_02,
1403 t_ARGTYPES_03,
1404 t_ARGTYPES_04,
1405 t_ARGTYPES_05,
1406 t_ARGTYPES_06,
1407 t_ARGTYPES_07,
1408 t_ARGTYPES_08,
1409 t_ARGTYPES_09,
1410 t_ARGTYPES_10> {
1411
1412 private:
1413
1414 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1415
1416 enum {
1417 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1418 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1419 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1420 };
1421
1422 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1423 k_IS_MEMOBJPTR,
1424 F,
1425 t_FN>::type FwdFn;
1426
1427 public:
1428
1429 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1430 k_IS_MEMFUNCPTR,
1431 k_IS_MEMOBJPTR,
1432 FwdFn,
1433 t_ARGTYPES_01,
1434 t_ARGTYPES_02,
1435 t_ARGTYPES_03,
1436 t_ARGTYPES_04,
1437 t_ARGTYPES_05,
1438 t_ARGTYPES_06,
1439 t_ARGTYPES_07,
1440 t_ARGTYPES_08,
1441 t_ARGTYPES_09,
1442 t_ARGTYPES_10>
1443 BaseType;
1444};
1445#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 10
1446
1447#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 11
1448template <class t_FN, class t_ARGTYPES_01,
1449 class t_ARGTYPES_02,
1450 class t_ARGTYPES_03,
1451 class t_ARGTYPES_04,
1452 class t_ARGTYPES_05,
1453 class t_ARGTYPES_06,
1454 class t_ARGTYPES_07,
1455 class t_ARGTYPES_08,
1456 class t_ARGTYPES_09,
1457 class t_ARGTYPES_10,
1458 class t_ARGTYPES_11>
1459struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1460 t_ARGTYPES_02,
1461 t_ARGTYPES_03,
1462 t_ARGTYPES_04,
1463 t_ARGTYPES_05,
1464 t_ARGTYPES_06,
1465 t_ARGTYPES_07,
1466 t_ARGTYPES_08,
1467 t_ARGTYPES_09,
1468 t_ARGTYPES_10,
1469 t_ARGTYPES_11> {
1470
1471 private:
1472
1473 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1474
1475 enum {
1476 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1477 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1478 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1479 };
1480
1481 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1482 k_IS_MEMOBJPTR,
1483 F,
1484 t_FN>::type FwdFn;
1485
1486 public:
1487
1488 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1489 k_IS_MEMFUNCPTR,
1490 k_IS_MEMOBJPTR,
1491 FwdFn,
1492 t_ARGTYPES_01,
1493 t_ARGTYPES_02,
1494 t_ARGTYPES_03,
1495 t_ARGTYPES_04,
1496 t_ARGTYPES_05,
1497 t_ARGTYPES_06,
1498 t_ARGTYPES_07,
1499 t_ARGTYPES_08,
1500 t_ARGTYPES_09,
1501 t_ARGTYPES_10,
1502 t_ARGTYPES_11>
1503 BaseType;
1504};
1505#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 11
1506
1507#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 12
1508template <class t_FN, class t_ARGTYPES_01,
1509 class t_ARGTYPES_02,
1510 class t_ARGTYPES_03,
1511 class t_ARGTYPES_04,
1512 class t_ARGTYPES_05,
1513 class t_ARGTYPES_06,
1514 class t_ARGTYPES_07,
1515 class t_ARGTYPES_08,
1516 class t_ARGTYPES_09,
1517 class t_ARGTYPES_10,
1518 class t_ARGTYPES_11,
1519 class t_ARGTYPES_12>
1520struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1521 t_ARGTYPES_02,
1522 t_ARGTYPES_03,
1523 t_ARGTYPES_04,
1524 t_ARGTYPES_05,
1525 t_ARGTYPES_06,
1526 t_ARGTYPES_07,
1527 t_ARGTYPES_08,
1528 t_ARGTYPES_09,
1529 t_ARGTYPES_10,
1530 t_ARGTYPES_11,
1531 t_ARGTYPES_12> {
1532
1533 private:
1534
1535 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1536
1537 enum {
1538 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1539 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1540 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1541 };
1542
1543 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1544 k_IS_MEMOBJPTR,
1545 F,
1546 t_FN>::type FwdFn;
1547
1548 public:
1549
1550 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1551 k_IS_MEMFUNCPTR,
1552 k_IS_MEMOBJPTR,
1553 FwdFn,
1554 t_ARGTYPES_01,
1555 t_ARGTYPES_02,
1556 t_ARGTYPES_03,
1557 t_ARGTYPES_04,
1558 t_ARGTYPES_05,
1559 t_ARGTYPES_06,
1560 t_ARGTYPES_07,
1561 t_ARGTYPES_08,
1562 t_ARGTYPES_09,
1563 t_ARGTYPES_10,
1564 t_ARGTYPES_11,
1565 t_ARGTYPES_12>
1566 BaseType;
1567};
1568#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 12
1569
1570#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 13
1571template <class t_FN, class t_ARGTYPES_01,
1572 class t_ARGTYPES_02,
1573 class t_ARGTYPES_03,
1574 class t_ARGTYPES_04,
1575 class t_ARGTYPES_05,
1576 class t_ARGTYPES_06,
1577 class t_ARGTYPES_07,
1578 class t_ARGTYPES_08,
1579 class t_ARGTYPES_09,
1580 class t_ARGTYPES_10,
1581 class t_ARGTYPES_11,
1582 class t_ARGTYPES_12,
1583 class t_ARGTYPES_13>
1584struct InvokeResult_BaseCalcUtil<t_FN, t_ARGTYPES_01,
1585 t_ARGTYPES_02,
1586 t_ARGTYPES_03,
1587 t_ARGTYPES_04,
1588 t_ARGTYPES_05,
1589 t_ARGTYPES_06,
1590 t_ARGTYPES_07,
1591 t_ARGTYPES_08,
1592 t_ARGTYPES_09,
1593 t_ARGTYPES_10,
1594 t_ARGTYPES_11,
1595 t_ARGTYPES_12,
1596 t_ARGTYPES_13> {
1597
1598 private:
1599
1600 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1601
1602 enum {
1603 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1604 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1605 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1606 };
1607
1608 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1609 k_IS_MEMOBJPTR,
1610 F,
1611 t_FN>::type FwdFn;
1612
1613 public:
1614
1615 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1616 k_IS_MEMFUNCPTR,
1617 k_IS_MEMOBJPTR,
1618 FwdFn,
1619 t_ARGTYPES_01,
1620 t_ARGTYPES_02,
1621 t_ARGTYPES_03,
1622 t_ARGTYPES_04,
1623 t_ARGTYPES_05,
1624 t_ARGTYPES_06,
1625 t_ARGTYPES_07,
1626 t_ARGTYPES_08,
1627 t_ARGTYPES_09,
1628 t_ARGTYPES_10,
1629 t_ARGTYPES_11,
1630 t_ARGTYPES_12,
1631 t_ARGTYPES_13>
1632 BaseType;
1633};
1634#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_C >= 13
1635
1636#else
1637// The generated code below is a workaround for the absence of perfect
1638// forwarding in some compilers.
1639
1640template <bool t_IS_FUNCPTR,
1641 bool t_IS_MEMFUNCPTR,
1642 bool t_IS_MEMOBJPTR,
1643 class t_FN,
1644 class... t_ARGTYPES>
1645struct InvokeResult_Imp;
1646
1647
1648template <class t_FN, class... t_ARGTYPES>
1649struct InvokeResult_BaseCalcUtil {
1650
1651 private:
1652
1653 typedef typename bslmf::MovableRefUtil::Decay<t_FN>::type F;
1654
1655 enum {
1656 k_IS_FUNCPTR = BloombergLP::bslmf::IsFunctionPointer<F>::value,
1657 k_IS_MEMFUNCPTR= BloombergLP::bslmf::IsMemberFunctionPointer<F>::value,
1658 k_IS_MEMOBJPTR = bsl::is_member_object_pointer<F>::value
1659 };
1660
1661 typedef typename bsl::conditional<k_IS_FUNCPTR || k_IS_MEMFUNCPTR ||
1662 k_IS_MEMOBJPTR,
1663 F,
1664 t_FN>::type FwdFn;
1665
1666 public:
1667
1668 typedef typename BloombergLP::bslmf::InvokeResult_Imp<k_IS_FUNCPTR,
1669 k_IS_MEMFUNCPTR,
1670 k_IS_MEMOBJPTR,
1671 FwdFn,
1672 t_ARGTYPES...>
1673 BaseType;
1674};
1675
1676// }}} END GENERATED CODE
1677#endif
1678
1679 // ===============================
1680 // struct InvokeResult_VoidChecker
1681 // ===============================
1682
1683/// Empty type used to detect void expressions. The size of this type is
1684/// the same as `bslmf::Tag<1>`.
1685struct InvokeResult_VoidChecker : Tag<true> {
1686};
1687
1688/// Return `InvokeResult_VoidChecker()` if the left argument is of type
1689/// cv-`void`; otherwise `bslmf::Tag<false>()`. This overload of the comma
1690/// operator is declared but not defined, and is intended to be used in
1691/// metafunctions in an unevaluated context to detect void expressions. For
1692/// any non-void expression `expr`, `(expr,InvokeResult_VoidChecker())`,
1693/// will match this overload and produce a result of type
1694/// `bslmf::Tag<false>`. However, `const t_TYPE&` will not match `void`, so
1695/// if `expr` is a void expression, the built-in comma operator is matched
1696/// and the result will have type `InvokeResult_VoidChecker` (i.e., the
1697/// second argument).
1698///
1699/// Note that Sun CC incorrectly matches this overload for a void
1700/// expression, then fails hard. The `enable_if` prevents this match for
1701/// Sun CC and any other compilers that may similarly match `void` and is
1702/// harmless for compilers that don't.
1703template <class t_TYPE>
1704typename bsl::enable_if<!bsl::is_void<t_TYPE>::value, Tag<false> >::type
1705operator,(const t_TYPE&, InvokeResult_VoidChecker);
1706
1707/// Metafunction helpers for deducing the return type of an expression.
1708struct InvokeResult_Index {
1709
1710 enum {
1711 // Enumeration of possible return types.
1712
1713 e_VOID,
1714 e_BOOL,
1715 e_CHAR,
1716 e_SCHAR,
1717 e_UCHAR,
1718 e_CHAR8_T,
1719 e_WCHAR_T,
1720 e_CHAR16_T,
1721 e_CHAR32_T,
1722 e_SHORT,
1723 e_USHORT,
1724 e_INT,
1725 e_UNSIGNED,
1726 e_LONG,
1727 e_ULONG,
1728 e_LONG_LONG,
1729 e_ULONG_LONG,
1730 e_FLOAT,
1731 e_DOUBLE,
1732 e_LONG_DOUBLE,
1733
1734 // Pointer to void is special among pointers because it cannot be
1735 // dereferenced.
1736 e_VOIDPTR,
1737 e_CONST_VOIDPTR,
1738 e_VOLATILE_VOIDPTR,
1739 e_CONST_VOLATILE_VOIDPTR,
1740
1741 e_NULLPTR_T,
1742 e_POINTER, // Any pointer type other than 'void *' or 'nullptr_t'
1743 e_OTHER // Anything other than above
1744 };
1745
1746 // CLASS METHODS
1747 static bslmf::Tag<e_BOOL> fromVal(bool& );
1748 static bslmf::Tag<e_CHAR> fromVal(char& );
1749 static bslmf::Tag<e_SCHAR> fromVal(signed char& );
1750 static bslmf::Tag<e_UCHAR> fromVal(unsigned char& );
1751#ifdef BSLS_COMPILERFEATURES_SUPPORT_UTF8_CHAR_TYPE
1752 static bslmf::Tag<e_CHAR8_T> fromVal(char8_t& );
1753#endif
1754 static bslmf::Tag<e_WCHAR_T> fromVal(wchar_t& );
1755#ifdef BSLS_COMPILERFEATURES_SUPPORT_UNICODE_CHAR_TYPES
1756 static bslmf::Tag<e_CHAR16_T> fromVal(char16_t& );
1757 static bslmf::Tag<e_CHAR32_T> fromVal(char32_t& );
1758#endif
1759 /// Return a tag type representing the argument type. These functions
1760 /// are declared but not defined and are intended to be used in an
1761 /// unevaluated context (e.g., within `sizeof`) to convert an expression
1762 /// into a compile-time enumeration constant.
1763 static bslmf::Tag<e_SHORT> fromVal(short& );
1764 static bslmf::Tag<e_USHORT> fromVal(unsigned short& );
1765 static bslmf::Tag<e_INT> fromVal(int& );
1766 static bslmf::Tag<e_UNSIGNED> fromVal(unsigned& );
1767 static bslmf::Tag<e_LONG> fromVal(long& );
1768 static bslmf::Tag<e_ULONG> fromVal(unsigned long& );
1769 static bslmf::Tag<e_LONG_LONG> fromVal(long long& );
1770 static bslmf::Tag<e_ULONG_LONG> fromVal(unsigned long long& );
1771 static bslmf::Tag<e_FLOAT> fromVal(float& );
1772 static bslmf::Tag<e_DOUBLE> fromVal(double& );
1773 static bslmf::Tag<e_LONG_DOUBLE> fromVal(long double& );
1774 static bslmf::Tag<e_VOIDPTR> fromVal(void *& );
1775 static bslmf::Tag<e_CONST_VOIDPTR> fromVal(const void *& );
1776 static bslmf::Tag<e_VOLATILE_VOIDPTR> fromVal(volatile void *& );
1777 static bslmf::Tag<e_CONST_VOLATILE_VOIDPTR> fromVal(const volatile void*&);
1778 static bslmf::Tag<e_NULLPTR_T> fromVal(bsl::nullptr_t&);
1779 template <class t_TP>
1780 static bslmf::Tag<e_POINTER> fromVal(t_TP *&);
1781 template <class t_TP>
1782 static bslmf::Tag<e_OTHER> fromVal(t_TP&);
1783};
1784
1785/// Metafunction to convert a type index back to a type. For each
1786/// specialization of this struct, the `type` member will be the type
1787/// corresponding to `index`. For example, if `index` is `e_UCHAR`, then
1788/// `InvokeResult_Type<index>::type` is `unsigned char`.
1789template <int t_INDEX> struct InvokeResult_Type;
1790
1791// Turn off bde_verify warnings for "Declaration without tag". Pedantically,
1792// every 'type' declared in a metafunction should have the tag '// TYPES', but
1793// that breaks up the clean 3-line declaration of each specialization, making
1794// the pattern harder to for the eye to follow.
1795// BDE_VERIFY pragma: push
1796// BDE_VERIFY pragma: -KS00
1797template <>
1798struct InvokeResult_Type<InvokeResult_Index::e_VOID>
1799 { typedef void type; };
1800template <>
1801struct InvokeResult_Type<InvokeResult_Index::e_BOOL>
1802 { typedef bool type; };
1803template <>
1804struct InvokeResult_Type<InvokeResult_Index::e_CHAR>
1805 { typedef char type; };
1806template <>
1807struct InvokeResult_Type<InvokeResult_Index::e_SCHAR>
1808 { typedef signed char type; };
1809template <>
1810struct InvokeResult_Type<InvokeResult_Index::e_UCHAR>
1811 { typedef unsigned char type; };
1812#ifdef BSLS_COMPILERFEATURES_SUPPORT_UTF8_CHAR_TYPE
1813template <>
1814struct InvokeResult_Type<InvokeResult_Index::e_CHAR8_T>
1815 { typedef char8_t type; };
1816#endif
1817template <>
1818struct InvokeResult_Type<InvokeResult_Index::e_WCHAR_T>
1819 { typedef wchar_t type; };
1820#ifdef BSLS_COMPILERFEATURES_SUPPORT_UNICODE_CHAR_TYPES
1821template <>
1822struct InvokeResult_Type<InvokeResult_Index::e_CHAR16_T>
1823 { typedef char16_t type; };
1824template <>
1825struct InvokeResult_Type<InvokeResult_Index::e_CHAR32_T>
1826 { typedef char32_t type; };
1827#endif
1828template <>
1829struct InvokeResult_Type<InvokeResult_Index::e_SHORT>
1830 { typedef short type; };
1831template <>
1832struct InvokeResult_Type<InvokeResult_Index::e_USHORT>
1833 { typedef unsigned short type; };
1834template <>
1835struct InvokeResult_Type<InvokeResult_Index::e_INT>
1836 { typedef int type; };
1837template <>
1838struct InvokeResult_Type<InvokeResult_Index::e_UNSIGNED>
1839 { typedef unsigned type; };
1840template <>
1841struct InvokeResult_Type<InvokeResult_Index::e_LONG>
1842 { typedef long type; };
1843template <>
1844struct InvokeResult_Type<InvokeResult_Index::e_ULONG>
1845 { typedef unsigned long type; };
1846template <>
1847struct InvokeResult_Type<InvokeResult_Index::e_LONG_LONG>
1848 { typedef long long type; };
1849template <>
1850struct InvokeResult_Type<InvokeResult_Index::e_ULONG_LONG>
1851 { typedef unsigned long long type; };
1852template <>
1853struct InvokeResult_Type<InvokeResult_Index::e_FLOAT>
1854 { typedef float type; };
1855template <>
1856struct InvokeResult_Type<InvokeResult_Index::e_DOUBLE>
1857 { typedef double type; };
1858template <>
1859struct InvokeResult_Type<InvokeResult_Index::e_LONG_DOUBLE>
1860 { typedef long double type; };
1861template <>
1862struct InvokeResult_Type<InvokeResult_Index::e_VOIDPTR>
1863 { typedef void *type; };
1864template <>
1865struct InvokeResult_Type<InvokeResult_Index::e_CONST_VOIDPTR>
1866 { typedef const void *type; };
1867template <>
1868struct InvokeResult_Type<InvokeResult_Index::e_VOLATILE_VOIDPTR>
1869 { typedef volatile void *type; };
1870template <>
1871struct InvokeResult_Type<InvokeResult_Index::e_CONST_VOLATILE_VOIDPTR>
1872 { typedef const volatile void *type; };
1873template <>
1874struct InvokeResult_Type<InvokeResult_Index::e_NULLPTR_T>
1875 { typedef bsl::nullptr_t type; };
1876template <>
1877struct InvokeResult_Type<InvokeResult_Index::e_POINTER>
1878 { typedef void *type; };
1879template <>
1880struct InvokeResult_Type<InvokeResult_Index::e_OTHER>
1881 { typedef InvokeResultDeductionFailed type; };
1882// Re-enable warnings for "Declaration without tag"
1883// BDE_VERIFY pragma: pop
1884
1885/// Utility metaprogramming functions inherited by other metaprogramming
1886/// classes.
1887struct InvokeResult_ImpUtils
1888{
1889
1890 // TYPES
1891
1892 /// Type convertible from any lvalue type. Used for overload resolution
1893 /// in metafunctions.
1894 struct AnyLvalue {
1895
1896 // CREATORS
1897
1898 /// (Declared but not defined) Convert from any lvalue argument.
1899 template <class t_TP>
1900 AnyLvalue(volatile t_TP&);
1901 };
1902
1903 /// Type convertible from any rvalue type. Used for overload resolution
1904 /// in metafunctions.
1905 struct AnyRvalue {
1906
1907 // CREATORS
1908#ifdef BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES
1909 /// (Declared but not defined) Convert from any rvalue argument.
1910 template <class t_TP>
1911 AnyRvalue(
1912 t_TP&&,
1913 typename bsl::enable_if<bsl::is_rvalue_reference<t_TP&&>::value,
1914 int>::type = 0);
1915#else
1916 template <class t_TP>
1917 AnyRvalue(t_TP);
1918 // (Declared but not defined) Convert from any rvalue argument.
1919 // This constructor will also match lvalue arguments, but is used
1920 // in a context where 'AnyLValue' is a better conversion path.
1921#endif
1922 };
1923
1924 // CLASS METHODS
1925#ifdef BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES
1926 /// Return a reference to the specified `t_SOME_TYPE` template parameter
1927 /// type; if `t_SOME_TYPE` is an rvalue, then the returned reference is
1928 /// an rvalue reference. This function is declared but not defined and
1929 /// is intended to be called in an unevaluated context. Because there
1930 /// is no definition, the available constructors for `t_SOME_TYPE` are
1931 /// irrelevant.
1932 template <class t_SOME_TYPE>
1933 static typename bsl::add_rvalue_reference<t_SOME_TYPE>::type myDeclval();
1934#else
1935 template <class t_SOME_TYPE>
1936 static t_SOME_TYPE myDeclval();
1937 // Return an object of the specified 't_SOME_TYPE' template parameter
1938 // type. This function is declared but not defined and is intended to
1939 // be called in an unevaluated context. Because there is no
1940 // definition, the available constructors for 't_SOME_TYPE' are
1941 // irrelevant.
1942#endif
1943
1944 /// (Declared but not defined) Return `bslmf::Tag<false>()` if the
1945 /// first argument is an rvalue and `bslmf::Tag<true>()` if it is
1946 /// lvalue. In actual use, the second argument is always a literal
1947 /// `int`, which causes the second overload to be preferred in case of
1948 /// ambiguity.
1949 static bslmf::Tag<false> checkLvalue(AnyRvalue, ...);
1950 static bslmf::Tag<true > checkLvalue(AnyLvalue, int);
1951
1952 /// (Declared but not defined) Return `bslmf::Tag<true>()` if the
1953 /// argument is `const`-qualified and `bslmf::Tag<false>()` otherwise.
1954 template <class t_TP>
1955 static bslmf::Tag<false> checkConst(t_TP&);
1956 template <class t_TP>
1957 static bslmf::Tag<true> checkConst(const t_TP&);
1958
1959 /// (Declared but not defined) Return `bslmf::Tag<true>()` if the
1960 /// argument is `volatile`-qualified and `bslmf::Tag<false>()`
1961 /// otherwise. Note that if `t_TP` is both const- and
1962 /// volatile-qualified, it will not match `volatile t_TP&`, hence the
1963 /// need for the const overloads.
1964 template <class t_TP>
1965 static bslmf::Tag<false> checkVolatile(t_TP&);
1966 template <class t_TP>
1967 static bslmf::Tag<false> checkVolatile(const t_TP&);
1968 template <class t_TP>
1969 static bslmf::Tag<true> checkVolatile(volatile t_TP&);
1970 template <class t_TP>
1971 static bslmf::Tag<true> checkVolatile(const volatile t_TP&);
1972
1973 /// (Declared but not defined) Return the argument, with cv-qualifiers
1974 /// removed.
1975 template <class t_TP>
1976 static t_TP& uncv(const t_TP&);
1977 template <class t_TP>
1978 static t_TP& uncv(const volatile t_TP&);
1979
1980 /// If the argument type `t_TP` is pointer to type `X`, where `X` is not
1981 /// cv-`void`, return a reference to `X`; otherwise return a reference
1982 /// to `t_TP`. Note that these functions are declared but not defined
1983 /// and are intended to be called only in an unevaluated context.
1984 template <class t_TP>
1985 static t_TP& unpoint(t_TP&);
1986 template <class t_TP>
1987 static const t_TP& unpoint(const t_TP&);
1988 template <class t_TP>
1989 static typename bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type&
1990 unpoint(t_TP *&);
1991 template <class t_TP>
1992 static typename bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type&
1993 unpoint(t_TP *const&);
1994 template <class t_TP>
1995 static typename bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type&
1996 unpoint(t_TP *volatile&);
1997 template <class t_TP>
1998 static typename bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type&
1999 unpoint(t_TP *const volatile&);
2000};
2001
2002/// Starting with type, `t_UNQUAL_TYPE`, generate a new type by applying the
2003/// following steps in order:
2004///
2005/// 1. If the specified `t_IS_CONST` parameter is true, apply
2006/// `bsl::add_const`; otherwise leave unchanged.
2007/// 2. If the specified `t_IS_VOLATILE` parameter is true, apply
2008/// `bsl::add_volatile`; otherwise leave unchanged.
2009/// 3. If the specified `t_IS_LVALUE` parameter is true, apply
2010/// `bsl::add_lvalue_reference`; otherwise leave unchanged.
2011///
2012/// Set the `type` member to the resulting type.
2013template <class t_UNQUAL_TYPE,
2014 bool t_IS_CONST,
2015 bool t_IS_VOLATILE,
2016 bool t_IS_LVALUE>
2017struct InvokeResult_AddCVRef {
2018
2019 private:
2020 // PRIVATE TYPES
2021 typedef
2022 typename bsl::conditional<t_IS_CONST,
2023 typename bsl::add_const<t_UNQUAL_TYPE>::type,
2024 t_UNQUAL_TYPE>::type CQualType;
2025
2026 typedef
2027 typename bsl::conditional<t_IS_VOLATILE,
2028 typename bsl::add_volatile<CQualType>::type,
2029 CQualType>::type CVQualType;
2030
2031 public:
2032 // TYPES
2033 typedef typename bsl::conditional<
2034 t_IS_LVALUE,
2035 typename bsl::add_lvalue_reference<CVQualType>::type,
2036 CVQualType>::type type;
2037};
2038
2039#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
2040// {{{ BEGIN GENERATED CODE
2041// Command line: sim_cpp11_features.pl bslmf_invokeresult.h
2042#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT
2043#define BSLMF_INVOKERESULT_VARIADIC_LIMIT 13
2044#endif
2045#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT_D
2046#define BSLMF_INVOKERESULT_VARIADIC_LIMIT_D BSLMF_INVOKERESULT_VARIADIC_LIMIT
2047#endif
2048
2049#ifndef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
2050template <bool __Param__0,
2051 class t_FN
2052#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 0
2053 , class t_ARGTYPES_0 = BSLS_COMPILERFEATURES_NILT
2054#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 0
2055
2056#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 1
2057 , class t_ARGTYPES_1 = BSLS_COMPILERFEATURES_NILT
2058#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 1
2059
2060#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 2
2061 , class t_ARGTYPES_2 = BSLS_COMPILERFEATURES_NILT
2062#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 2
2063
2064#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 3
2065 , class t_ARGTYPES_3 = BSLS_COMPILERFEATURES_NILT
2066#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 3
2067
2068#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 4
2069 , class t_ARGTYPES_4 = BSLS_COMPILERFEATURES_NILT
2070#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 4
2071
2072#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 5
2073 , class t_ARGTYPES_5 = BSLS_COMPILERFEATURES_NILT
2074#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 5
2075
2076#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 6
2077 , class t_ARGTYPES_6 = BSLS_COMPILERFEATURES_NILT
2078#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 6
2079
2080#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 7
2081 , class t_ARGTYPES_7 = BSLS_COMPILERFEATURES_NILT
2082#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 7
2083
2084#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 8
2085 , class t_ARGTYPES_8 = BSLS_COMPILERFEATURES_NILT
2086#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 8
2087
2088#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 9
2089 , class t_ARGTYPES_9 = BSLS_COMPILERFEATURES_NILT
2090#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 9
2091
2092#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 10
2093 , class t_ARGTYPES_10 = BSLS_COMPILERFEATURES_NILT
2094#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 10
2095
2096#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 11
2097 , class t_ARGTYPES_11 = BSLS_COMPILERFEATURES_NILT
2098#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 11
2099
2100#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 12
2101 , class t_ARGTYPES_12 = BSLS_COMPILERFEATURES_NILT
2102#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 12
2103 , class = BSLS_COMPILERFEATURES_NILT>
2104struct InvokeResult_FunctorDeduction;
2105
2106#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 0
2107template <bool __Param__0, class t_FN>
2108struct InvokeResult_FunctorDeduction<__Param__0, t_FN
2109 > : InvokeResult_ImpUtils {
2110
2111 typedef typename bsl::decay<t_FN>::type F;
2112
2113 enum {
2114
2115 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2116 uncv(myDeclval<t_FN>()()))),
2117 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2118 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2119 checkLvalue(myDeclval<t_FN>()(), 0)),
2120 k_IS_CONST_PTR = k_IS_POINTER &&
2121 BSLMF_TAG_TO_INT(checkConst(
2122 myDeclval<t_FN>()())),
2123 k_IS_VOLATILE_PTR = k_IS_POINTER &&
2124 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
2125 ))),
2126 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2127 uncv(unpoint(myDeclval<t_FN>()())))),
2128 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
2129 unpoint(myDeclval<t_FN>()()))),
2130 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
2131 unpoint(myDeclval<t_FN>()()))),
2132 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
2133 (int)InvokeResult_Index::e_OTHER)
2134 };
2135
2136 typedef typename bsl::conditional<
2137 ! k_CANT_DEDUCE_TYPE,
2138 typename InvokeResult_Type<k_TARGET_INDEX>::type,
2139 typename ResultType<F,InvokeResultDeductionFailed>::type
2140 >::type UnqualTargetType;
2141
2142 typedef typename
2143 InvokeResult_AddCVRef<UnqualTargetType,
2144 static_cast<bool>(k_IS_CONST_TARGET)
2145 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2146 static_cast<bool>(k_IS_VOLATILE_TARGET)
2147 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2148 false>::type CVQualTargetType;
2149
2150 typedef typename
2151 bsl::conditional<static_cast<bool>(k_IS_POINTER)
2152 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2153 typename bsl::add_pointer<CVQualTargetType>::type,
2154 CVQualTargetType>::type UnqualType;
2155
2156 typedef typename
2157 InvokeResult_AddCVRef<
2158 UnqualType,
2159 static_cast<bool>(k_IS_CONST_PTR)
2160 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2161 static_cast<bool>(k_IS_VOLATILE_PTR)
2162 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2163 static_cast<bool>(k_IS_LVALUE)
2164 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
2165
2166 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
2167 typename bsl::remove_cv<Qtype>::type>::type type;
2168};
2169#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 0
2170
2171#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 1
2172template <bool __Param__0, class t_FN, class t_ARGTYPES_01>
2173struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01
2174 > : InvokeResult_ImpUtils {
2175
2176 typedef typename bsl::decay<t_FN>::type F;
2177
2178 enum {
2179
2180 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2181 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>())))),
2182 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2183 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2184 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>()), 0)),
2185 k_IS_CONST_PTR = k_IS_POINTER &&
2186 BSLMF_TAG_TO_INT(checkConst(
2187 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>()))),
2188 k_IS_VOLATILE_PTR = k_IS_POINTER &&
2189 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
2190 myDeclval<t_ARGTYPES_01>()))),
2191 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2192 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>()))))),
2193 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
2194 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>())))),
2195 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
2196 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>())))),
2197 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
2198 (int)InvokeResult_Index::e_OTHER)
2199 };
2200
2201 typedef typename bsl::conditional<
2202 ! k_CANT_DEDUCE_TYPE,
2203 typename InvokeResult_Type<k_TARGET_INDEX>::type,
2204 typename ResultType<F,InvokeResultDeductionFailed>::type
2205 >::type UnqualTargetType;
2206
2207 typedef typename
2208 InvokeResult_AddCVRef<UnqualTargetType,
2209 static_cast<bool>(k_IS_CONST_TARGET)
2210 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2211 static_cast<bool>(k_IS_VOLATILE_TARGET)
2212 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2213 false>::type CVQualTargetType;
2214
2215 typedef typename
2216 bsl::conditional<static_cast<bool>(k_IS_POINTER)
2217 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2218 typename bsl::add_pointer<CVQualTargetType>::type,
2219 CVQualTargetType>::type UnqualType;
2220
2221 typedef typename
2222 InvokeResult_AddCVRef<
2223 UnqualType,
2224 static_cast<bool>(k_IS_CONST_PTR)
2225 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2226 static_cast<bool>(k_IS_VOLATILE_PTR)
2227 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2228 static_cast<bool>(k_IS_LVALUE)
2229 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
2230
2231 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
2232 typename bsl::remove_cv<Qtype>::type>::type type;
2233};
2234#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 1
2235
2236#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 2
2237template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
2238 class t_ARGTYPES_02>
2239struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
2240 t_ARGTYPES_02
2241 > : InvokeResult_ImpUtils {
2242
2243 typedef typename bsl::decay<t_FN>::type F;
2244
2245 enum {
2246
2247 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2248 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2249 myDeclval<t_ARGTYPES_02>())))),
2250 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2251 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2252 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2253 myDeclval<t_ARGTYPES_02>()), 0)),
2254 k_IS_CONST_PTR = k_IS_POINTER &&
2255 BSLMF_TAG_TO_INT(checkConst(
2256 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2257 myDeclval<t_ARGTYPES_02>()))),
2258 k_IS_VOLATILE_PTR = k_IS_POINTER &&
2259 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
2260 myDeclval<t_ARGTYPES_01>(),
2261 myDeclval<t_ARGTYPES_02>()))),
2262 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2263 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2264 myDeclval<t_ARGTYPES_02>()))))),
2265 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
2266 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2267 myDeclval<t_ARGTYPES_02>())))),
2268 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
2269 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2270 myDeclval<t_ARGTYPES_02>())))),
2271 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
2272 (int)InvokeResult_Index::e_OTHER)
2273 };
2274
2275 typedef typename bsl::conditional<
2276 ! k_CANT_DEDUCE_TYPE,
2277 typename InvokeResult_Type<k_TARGET_INDEX>::type,
2278 typename ResultType<F,InvokeResultDeductionFailed>::type
2279 >::type UnqualTargetType;
2280
2281 typedef typename
2282 InvokeResult_AddCVRef<UnqualTargetType,
2283 static_cast<bool>(k_IS_CONST_TARGET)
2284 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2285 static_cast<bool>(k_IS_VOLATILE_TARGET)
2286 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2287 false>::type CVQualTargetType;
2288
2289 typedef typename
2290 bsl::conditional<static_cast<bool>(k_IS_POINTER)
2291 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2292 typename bsl::add_pointer<CVQualTargetType>::type,
2293 CVQualTargetType>::type UnqualType;
2294
2295 typedef typename
2296 InvokeResult_AddCVRef<
2297 UnqualType,
2298 static_cast<bool>(k_IS_CONST_PTR)
2299 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2300 static_cast<bool>(k_IS_VOLATILE_PTR)
2301 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2302 static_cast<bool>(k_IS_LVALUE)
2303 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
2304
2305 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
2306 typename bsl::remove_cv<Qtype>::type>::type type;
2307};
2308#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 2
2309
2310#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 3
2311template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
2312 class t_ARGTYPES_02,
2313 class t_ARGTYPES_03>
2314struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
2315 t_ARGTYPES_02,
2316 t_ARGTYPES_03
2317 > : InvokeResult_ImpUtils {
2318
2319 typedef typename bsl::decay<t_FN>::type F;
2320
2321 enum {
2322
2323 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2324 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2325 myDeclval<t_ARGTYPES_02>(),
2326 myDeclval<t_ARGTYPES_03>())))),
2327 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2328 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2329 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2330 myDeclval<t_ARGTYPES_02>(),
2331 myDeclval<t_ARGTYPES_03>()), 0)),
2332 k_IS_CONST_PTR = k_IS_POINTER &&
2333 BSLMF_TAG_TO_INT(checkConst(
2334 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2335 myDeclval<t_ARGTYPES_02>(),
2336 myDeclval<t_ARGTYPES_03>()))),
2337 k_IS_VOLATILE_PTR = k_IS_POINTER &&
2338 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
2339 myDeclval<t_ARGTYPES_01>(),
2340 myDeclval<t_ARGTYPES_02>(),
2341 myDeclval<t_ARGTYPES_03>()))),
2342 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2343 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2344 myDeclval<t_ARGTYPES_02>(),
2345 myDeclval<t_ARGTYPES_03>()))))),
2346 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
2347 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2348 myDeclval<t_ARGTYPES_02>(),
2349 myDeclval<t_ARGTYPES_03>())))),
2350 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
2351 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2352 myDeclval<t_ARGTYPES_02>(),
2353 myDeclval<t_ARGTYPES_03>())))),
2354 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
2355 (int)InvokeResult_Index::e_OTHER)
2356 };
2357
2358 typedef typename bsl::conditional<
2359 ! k_CANT_DEDUCE_TYPE,
2360 typename InvokeResult_Type<k_TARGET_INDEX>::type,
2361 typename ResultType<F,InvokeResultDeductionFailed>::type
2362 >::type UnqualTargetType;
2363
2364 typedef typename
2365 InvokeResult_AddCVRef<UnqualTargetType,
2366 static_cast<bool>(k_IS_CONST_TARGET)
2367 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2368 static_cast<bool>(k_IS_VOLATILE_TARGET)
2369 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2370 false>::type CVQualTargetType;
2371
2372 typedef typename
2373 bsl::conditional<static_cast<bool>(k_IS_POINTER)
2374 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2375 typename bsl::add_pointer<CVQualTargetType>::type,
2376 CVQualTargetType>::type UnqualType;
2377
2378 typedef typename
2379 InvokeResult_AddCVRef<
2380 UnqualType,
2381 static_cast<bool>(k_IS_CONST_PTR)
2382 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2383 static_cast<bool>(k_IS_VOLATILE_PTR)
2384 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2385 static_cast<bool>(k_IS_LVALUE)
2386 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
2387
2388 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
2389 typename bsl::remove_cv<Qtype>::type>::type type;
2390};
2391#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 3
2392
2393#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 4
2394template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
2395 class t_ARGTYPES_02,
2396 class t_ARGTYPES_03,
2397 class t_ARGTYPES_04>
2398struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
2399 t_ARGTYPES_02,
2400 t_ARGTYPES_03,
2401 t_ARGTYPES_04
2402 > : InvokeResult_ImpUtils {
2403
2404 typedef typename bsl::decay<t_FN>::type F;
2405
2406 enum {
2407
2408 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2409 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2410 myDeclval<t_ARGTYPES_02>(),
2411 myDeclval<t_ARGTYPES_03>(),
2412 myDeclval<t_ARGTYPES_04>())))),
2413 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2414 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2415 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2416 myDeclval<t_ARGTYPES_02>(),
2417 myDeclval<t_ARGTYPES_03>(),
2418 myDeclval<t_ARGTYPES_04>()), 0)),
2419 k_IS_CONST_PTR = k_IS_POINTER &&
2420 BSLMF_TAG_TO_INT(checkConst(
2421 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2422 myDeclval<t_ARGTYPES_02>(),
2423 myDeclval<t_ARGTYPES_03>(),
2424 myDeclval<t_ARGTYPES_04>()))),
2425 k_IS_VOLATILE_PTR = k_IS_POINTER &&
2426 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
2427 myDeclval<t_ARGTYPES_01>(),
2428 myDeclval<t_ARGTYPES_02>(),
2429 myDeclval<t_ARGTYPES_03>(),
2430 myDeclval<t_ARGTYPES_04>()))),
2431 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2432 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2433 myDeclval<t_ARGTYPES_02>(),
2434 myDeclval<t_ARGTYPES_03>(),
2435 myDeclval<t_ARGTYPES_04>()))))),
2436 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
2437 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2438 myDeclval<t_ARGTYPES_02>(),
2439 myDeclval<t_ARGTYPES_03>(),
2440 myDeclval<t_ARGTYPES_04>())))),
2441 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
2442 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2443 myDeclval<t_ARGTYPES_02>(),
2444 myDeclval<t_ARGTYPES_03>(),
2445 myDeclval<t_ARGTYPES_04>())))),
2446 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
2447 (int)InvokeResult_Index::e_OTHER)
2448 };
2449
2450 typedef typename bsl::conditional<
2451 ! k_CANT_DEDUCE_TYPE,
2452 typename InvokeResult_Type<k_TARGET_INDEX>::type,
2453 typename ResultType<F,InvokeResultDeductionFailed>::type
2454 >::type UnqualTargetType;
2455
2456 typedef typename
2457 InvokeResult_AddCVRef<UnqualTargetType,
2458 static_cast<bool>(k_IS_CONST_TARGET)
2459 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2460 static_cast<bool>(k_IS_VOLATILE_TARGET)
2461 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2462 false>::type CVQualTargetType;
2463
2464 typedef typename
2465 bsl::conditional<static_cast<bool>(k_IS_POINTER)
2466 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2467 typename bsl::add_pointer<CVQualTargetType>::type,
2468 CVQualTargetType>::type UnqualType;
2469
2470 typedef typename
2471 InvokeResult_AddCVRef<
2472 UnqualType,
2473 static_cast<bool>(k_IS_CONST_PTR)
2474 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2475 static_cast<bool>(k_IS_VOLATILE_PTR)
2476 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2477 static_cast<bool>(k_IS_LVALUE)
2478 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
2479
2480 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
2481 typename bsl::remove_cv<Qtype>::type>::type type;
2482};
2483#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 4
2484
2485#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 5
2486template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
2487 class t_ARGTYPES_02,
2488 class t_ARGTYPES_03,
2489 class t_ARGTYPES_04,
2490 class t_ARGTYPES_05>
2491struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
2492 t_ARGTYPES_02,
2493 t_ARGTYPES_03,
2494 t_ARGTYPES_04,
2495 t_ARGTYPES_05
2496 > : InvokeResult_ImpUtils {
2497
2498 typedef typename bsl::decay<t_FN>::type F;
2499
2500 enum {
2501
2502 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2503 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2504 myDeclval<t_ARGTYPES_02>(),
2505 myDeclval<t_ARGTYPES_03>(),
2506 myDeclval<t_ARGTYPES_04>(),
2507 myDeclval<t_ARGTYPES_05>())))),
2508 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2509 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2510 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2511 myDeclval<t_ARGTYPES_02>(),
2512 myDeclval<t_ARGTYPES_03>(),
2513 myDeclval<t_ARGTYPES_04>(),
2514 myDeclval<t_ARGTYPES_05>()), 0)),
2515 k_IS_CONST_PTR = k_IS_POINTER &&
2516 BSLMF_TAG_TO_INT(checkConst(
2517 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2518 myDeclval<t_ARGTYPES_02>(),
2519 myDeclval<t_ARGTYPES_03>(),
2520 myDeclval<t_ARGTYPES_04>(),
2521 myDeclval<t_ARGTYPES_05>()))),
2522 k_IS_VOLATILE_PTR = k_IS_POINTER &&
2523 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
2524 myDeclval<t_ARGTYPES_01>(),
2525 myDeclval<t_ARGTYPES_02>(),
2526 myDeclval<t_ARGTYPES_03>(),
2527 myDeclval<t_ARGTYPES_04>(),
2528 myDeclval<t_ARGTYPES_05>()))),
2529 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2530 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2531 myDeclval<t_ARGTYPES_02>(),
2532 myDeclval<t_ARGTYPES_03>(),
2533 myDeclval<t_ARGTYPES_04>(),
2534 myDeclval<t_ARGTYPES_05>()))))),
2535 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
2536 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2537 myDeclval<t_ARGTYPES_02>(),
2538 myDeclval<t_ARGTYPES_03>(),
2539 myDeclval<t_ARGTYPES_04>(),
2540 myDeclval<t_ARGTYPES_05>())))),
2541 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
2542 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2543 myDeclval<t_ARGTYPES_02>(),
2544 myDeclval<t_ARGTYPES_03>(),
2545 myDeclval<t_ARGTYPES_04>(),
2546 myDeclval<t_ARGTYPES_05>())))),
2547 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
2548 (int)InvokeResult_Index::e_OTHER)
2549 };
2550
2551 typedef typename bsl::conditional<
2552 ! k_CANT_DEDUCE_TYPE,
2553 typename InvokeResult_Type<k_TARGET_INDEX>::type,
2554 typename ResultType<F,InvokeResultDeductionFailed>::type
2555 >::type UnqualTargetType;
2556
2557 typedef typename
2558 InvokeResult_AddCVRef<UnqualTargetType,
2559 static_cast<bool>(k_IS_CONST_TARGET)
2560 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2561 static_cast<bool>(k_IS_VOLATILE_TARGET)
2562 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2563 false>::type CVQualTargetType;
2564
2565 typedef typename
2566 bsl::conditional<static_cast<bool>(k_IS_POINTER)
2567 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2568 typename bsl::add_pointer<CVQualTargetType>::type,
2569 CVQualTargetType>::type UnqualType;
2570
2571 typedef typename
2572 InvokeResult_AddCVRef<
2573 UnqualType,
2574 static_cast<bool>(k_IS_CONST_PTR)
2575 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2576 static_cast<bool>(k_IS_VOLATILE_PTR)
2577 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2578 static_cast<bool>(k_IS_LVALUE)
2579 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
2580
2581 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
2582 typename bsl::remove_cv<Qtype>::type>::type type;
2583};
2584#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 5
2585
2586#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 6
2587template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
2588 class t_ARGTYPES_02,
2589 class t_ARGTYPES_03,
2590 class t_ARGTYPES_04,
2591 class t_ARGTYPES_05,
2592 class t_ARGTYPES_06>
2593struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
2594 t_ARGTYPES_02,
2595 t_ARGTYPES_03,
2596 t_ARGTYPES_04,
2597 t_ARGTYPES_05,
2598 t_ARGTYPES_06
2599 > : InvokeResult_ImpUtils {
2600
2601 typedef typename bsl::decay<t_FN>::type F;
2602
2603 enum {
2604
2605 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2606 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2607 myDeclval<t_ARGTYPES_02>(),
2608 myDeclval<t_ARGTYPES_03>(),
2609 myDeclval<t_ARGTYPES_04>(),
2610 myDeclval<t_ARGTYPES_05>(),
2611 myDeclval<t_ARGTYPES_06>())))),
2612 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2613 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2614 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2615 myDeclval<t_ARGTYPES_02>(),
2616 myDeclval<t_ARGTYPES_03>(),
2617 myDeclval<t_ARGTYPES_04>(),
2618 myDeclval<t_ARGTYPES_05>(),
2619 myDeclval<t_ARGTYPES_06>()), 0)),
2620 k_IS_CONST_PTR = k_IS_POINTER &&
2621 BSLMF_TAG_TO_INT(checkConst(
2622 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2623 myDeclval<t_ARGTYPES_02>(),
2624 myDeclval<t_ARGTYPES_03>(),
2625 myDeclval<t_ARGTYPES_04>(),
2626 myDeclval<t_ARGTYPES_05>(),
2627 myDeclval<t_ARGTYPES_06>()))),
2628 k_IS_VOLATILE_PTR = k_IS_POINTER &&
2629 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
2630 myDeclval<t_ARGTYPES_01>(),
2631 myDeclval<t_ARGTYPES_02>(),
2632 myDeclval<t_ARGTYPES_03>(),
2633 myDeclval<t_ARGTYPES_04>(),
2634 myDeclval<t_ARGTYPES_05>(),
2635 myDeclval<t_ARGTYPES_06>()))),
2636 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2637 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2638 myDeclval<t_ARGTYPES_02>(),
2639 myDeclval<t_ARGTYPES_03>(),
2640 myDeclval<t_ARGTYPES_04>(),
2641 myDeclval<t_ARGTYPES_05>(),
2642 myDeclval<t_ARGTYPES_06>()))))),
2643 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
2644 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2645 myDeclval<t_ARGTYPES_02>(),
2646 myDeclval<t_ARGTYPES_03>(),
2647 myDeclval<t_ARGTYPES_04>(),
2648 myDeclval<t_ARGTYPES_05>(),
2649 myDeclval<t_ARGTYPES_06>())))),
2650 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
2651 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2652 myDeclval<t_ARGTYPES_02>(),
2653 myDeclval<t_ARGTYPES_03>(),
2654 myDeclval<t_ARGTYPES_04>(),
2655 myDeclval<t_ARGTYPES_05>(),
2656 myDeclval<t_ARGTYPES_06>())))),
2657 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
2658 (int)InvokeResult_Index::e_OTHER)
2659 };
2660
2661 typedef typename bsl::conditional<
2662 ! k_CANT_DEDUCE_TYPE,
2663 typename InvokeResult_Type<k_TARGET_INDEX>::type,
2664 typename ResultType<F,InvokeResultDeductionFailed>::type
2665 >::type UnqualTargetType;
2666
2667 typedef typename
2668 InvokeResult_AddCVRef<UnqualTargetType,
2669 static_cast<bool>(k_IS_CONST_TARGET)
2670 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2671 static_cast<bool>(k_IS_VOLATILE_TARGET)
2672 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2673 false>::type CVQualTargetType;
2674
2675 typedef typename
2676 bsl::conditional<static_cast<bool>(k_IS_POINTER)
2677 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2678 typename bsl::add_pointer<CVQualTargetType>::type,
2679 CVQualTargetType>::type UnqualType;
2680
2681 typedef typename
2682 InvokeResult_AddCVRef<
2683 UnqualType,
2684 static_cast<bool>(k_IS_CONST_PTR)
2685 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2686 static_cast<bool>(k_IS_VOLATILE_PTR)
2687 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2688 static_cast<bool>(k_IS_LVALUE)
2689 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
2690
2691 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
2692 typename bsl::remove_cv<Qtype>::type>::type type;
2693};
2694#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 6
2695
2696#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 7
2697template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
2698 class t_ARGTYPES_02,
2699 class t_ARGTYPES_03,
2700 class t_ARGTYPES_04,
2701 class t_ARGTYPES_05,
2702 class t_ARGTYPES_06,
2703 class t_ARGTYPES_07>
2704struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
2705 t_ARGTYPES_02,
2706 t_ARGTYPES_03,
2707 t_ARGTYPES_04,
2708 t_ARGTYPES_05,
2709 t_ARGTYPES_06,
2710 t_ARGTYPES_07
2711 > : InvokeResult_ImpUtils {
2712
2713 typedef typename bsl::decay<t_FN>::type F;
2714
2715 enum {
2716
2717 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2718 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2719 myDeclval<t_ARGTYPES_02>(),
2720 myDeclval<t_ARGTYPES_03>(),
2721 myDeclval<t_ARGTYPES_04>(),
2722 myDeclval<t_ARGTYPES_05>(),
2723 myDeclval<t_ARGTYPES_06>(),
2724 myDeclval<t_ARGTYPES_07>())))),
2725 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2726 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2727 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2728 myDeclval<t_ARGTYPES_02>(),
2729 myDeclval<t_ARGTYPES_03>(),
2730 myDeclval<t_ARGTYPES_04>(),
2731 myDeclval<t_ARGTYPES_05>(),
2732 myDeclval<t_ARGTYPES_06>(),
2733 myDeclval<t_ARGTYPES_07>()), 0)),
2734 k_IS_CONST_PTR = k_IS_POINTER &&
2735 BSLMF_TAG_TO_INT(checkConst(
2736 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2737 myDeclval<t_ARGTYPES_02>(),
2738 myDeclval<t_ARGTYPES_03>(),
2739 myDeclval<t_ARGTYPES_04>(),
2740 myDeclval<t_ARGTYPES_05>(),
2741 myDeclval<t_ARGTYPES_06>(),
2742 myDeclval<t_ARGTYPES_07>()))),
2743 k_IS_VOLATILE_PTR = k_IS_POINTER &&
2744 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
2745 myDeclval<t_ARGTYPES_01>(),
2746 myDeclval<t_ARGTYPES_02>(),
2747 myDeclval<t_ARGTYPES_03>(),
2748 myDeclval<t_ARGTYPES_04>(),
2749 myDeclval<t_ARGTYPES_05>(),
2750 myDeclval<t_ARGTYPES_06>(),
2751 myDeclval<t_ARGTYPES_07>()))),
2752 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2753 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2754 myDeclval<t_ARGTYPES_02>(),
2755 myDeclval<t_ARGTYPES_03>(),
2756 myDeclval<t_ARGTYPES_04>(),
2757 myDeclval<t_ARGTYPES_05>(),
2758 myDeclval<t_ARGTYPES_06>(),
2759 myDeclval<t_ARGTYPES_07>()))))),
2760 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
2761 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2762 myDeclval<t_ARGTYPES_02>(),
2763 myDeclval<t_ARGTYPES_03>(),
2764 myDeclval<t_ARGTYPES_04>(),
2765 myDeclval<t_ARGTYPES_05>(),
2766 myDeclval<t_ARGTYPES_06>(),
2767 myDeclval<t_ARGTYPES_07>())))),
2768 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
2769 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2770 myDeclval<t_ARGTYPES_02>(),
2771 myDeclval<t_ARGTYPES_03>(),
2772 myDeclval<t_ARGTYPES_04>(),
2773 myDeclval<t_ARGTYPES_05>(),
2774 myDeclval<t_ARGTYPES_06>(),
2775 myDeclval<t_ARGTYPES_07>())))),
2776 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
2777 (int)InvokeResult_Index::e_OTHER)
2778 };
2779
2780 typedef typename bsl::conditional<
2781 ! k_CANT_DEDUCE_TYPE,
2782 typename InvokeResult_Type<k_TARGET_INDEX>::type,
2783 typename ResultType<F,InvokeResultDeductionFailed>::type
2784 >::type UnqualTargetType;
2785
2786 typedef typename
2787 InvokeResult_AddCVRef<UnqualTargetType,
2788 static_cast<bool>(k_IS_CONST_TARGET)
2789 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2790 static_cast<bool>(k_IS_VOLATILE_TARGET)
2791 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2792 false>::type CVQualTargetType;
2793
2794 typedef typename
2795 bsl::conditional<static_cast<bool>(k_IS_POINTER)
2796 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2797 typename bsl::add_pointer<CVQualTargetType>::type,
2798 CVQualTargetType>::type UnqualType;
2799
2800 typedef typename
2801 InvokeResult_AddCVRef<
2802 UnqualType,
2803 static_cast<bool>(k_IS_CONST_PTR)
2804 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2805 static_cast<bool>(k_IS_VOLATILE_PTR)
2806 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2807 static_cast<bool>(k_IS_LVALUE)
2808 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
2809
2810 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
2811 typename bsl::remove_cv<Qtype>::type>::type type;
2812};
2813#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 7
2814
2815#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 8
2816template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
2817 class t_ARGTYPES_02,
2818 class t_ARGTYPES_03,
2819 class t_ARGTYPES_04,
2820 class t_ARGTYPES_05,
2821 class t_ARGTYPES_06,
2822 class t_ARGTYPES_07,
2823 class t_ARGTYPES_08>
2824struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
2825 t_ARGTYPES_02,
2826 t_ARGTYPES_03,
2827 t_ARGTYPES_04,
2828 t_ARGTYPES_05,
2829 t_ARGTYPES_06,
2830 t_ARGTYPES_07,
2831 t_ARGTYPES_08
2832 > : InvokeResult_ImpUtils {
2833
2834 typedef typename bsl::decay<t_FN>::type F;
2835
2836 enum {
2837
2838 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2839 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2840 myDeclval<t_ARGTYPES_02>(),
2841 myDeclval<t_ARGTYPES_03>(),
2842 myDeclval<t_ARGTYPES_04>(),
2843 myDeclval<t_ARGTYPES_05>(),
2844 myDeclval<t_ARGTYPES_06>(),
2845 myDeclval<t_ARGTYPES_07>(),
2846 myDeclval<t_ARGTYPES_08>())))),
2847 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2848 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2849 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2850 myDeclval<t_ARGTYPES_02>(),
2851 myDeclval<t_ARGTYPES_03>(),
2852 myDeclval<t_ARGTYPES_04>(),
2853 myDeclval<t_ARGTYPES_05>(),
2854 myDeclval<t_ARGTYPES_06>(),
2855 myDeclval<t_ARGTYPES_07>(),
2856 myDeclval<t_ARGTYPES_08>()), 0)),
2857 k_IS_CONST_PTR = k_IS_POINTER &&
2858 BSLMF_TAG_TO_INT(checkConst(
2859 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2860 myDeclval<t_ARGTYPES_02>(),
2861 myDeclval<t_ARGTYPES_03>(),
2862 myDeclval<t_ARGTYPES_04>(),
2863 myDeclval<t_ARGTYPES_05>(),
2864 myDeclval<t_ARGTYPES_06>(),
2865 myDeclval<t_ARGTYPES_07>(),
2866 myDeclval<t_ARGTYPES_08>()))),
2867 k_IS_VOLATILE_PTR = k_IS_POINTER &&
2868 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
2869 myDeclval<t_ARGTYPES_01>(),
2870 myDeclval<t_ARGTYPES_02>(),
2871 myDeclval<t_ARGTYPES_03>(),
2872 myDeclval<t_ARGTYPES_04>(),
2873 myDeclval<t_ARGTYPES_05>(),
2874 myDeclval<t_ARGTYPES_06>(),
2875 myDeclval<t_ARGTYPES_07>(),
2876 myDeclval<t_ARGTYPES_08>()))),
2877 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2878 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2879 myDeclval<t_ARGTYPES_02>(),
2880 myDeclval<t_ARGTYPES_03>(),
2881 myDeclval<t_ARGTYPES_04>(),
2882 myDeclval<t_ARGTYPES_05>(),
2883 myDeclval<t_ARGTYPES_06>(),
2884 myDeclval<t_ARGTYPES_07>(),
2885 myDeclval<t_ARGTYPES_08>()))))),
2886 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
2887 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2888 myDeclval<t_ARGTYPES_02>(),
2889 myDeclval<t_ARGTYPES_03>(),
2890 myDeclval<t_ARGTYPES_04>(),
2891 myDeclval<t_ARGTYPES_05>(),
2892 myDeclval<t_ARGTYPES_06>(),
2893 myDeclval<t_ARGTYPES_07>(),
2894 myDeclval<t_ARGTYPES_08>())))),
2895 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
2896 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2897 myDeclval<t_ARGTYPES_02>(),
2898 myDeclval<t_ARGTYPES_03>(),
2899 myDeclval<t_ARGTYPES_04>(),
2900 myDeclval<t_ARGTYPES_05>(),
2901 myDeclval<t_ARGTYPES_06>(),
2902 myDeclval<t_ARGTYPES_07>(),
2903 myDeclval<t_ARGTYPES_08>())))),
2904 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
2905 (int)InvokeResult_Index::e_OTHER)
2906 };
2907
2908 typedef typename bsl::conditional<
2909 ! k_CANT_DEDUCE_TYPE,
2910 typename InvokeResult_Type<k_TARGET_INDEX>::type,
2911 typename ResultType<F,InvokeResultDeductionFailed>::type
2912 >::type UnqualTargetType;
2913
2914 typedef typename
2915 InvokeResult_AddCVRef<UnqualTargetType,
2916 static_cast<bool>(k_IS_CONST_TARGET)
2917 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2918 static_cast<bool>(k_IS_VOLATILE_TARGET)
2919 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2920 false>::type CVQualTargetType;
2921
2922 typedef typename
2923 bsl::conditional<static_cast<bool>(k_IS_POINTER)
2924 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2925 typename bsl::add_pointer<CVQualTargetType>::type,
2926 CVQualTargetType>::type UnqualType;
2927
2928 typedef typename
2929 InvokeResult_AddCVRef<
2930 UnqualType,
2931 static_cast<bool>(k_IS_CONST_PTR)
2932 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2933 static_cast<bool>(k_IS_VOLATILE_PTR)
2934 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
2935 static_cast<bool>(k_IS_LVALUE)
2936 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
2937
2938 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
2939 typename bsl::remove_cv<Qtype>::type>::type type;
2940};
2941#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 8
2942
2943#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 9
2944template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
2945 class t_ARGTYPES_02,
2946 class t_ARGTYPES_03,
2947 class t_ARGTYPES_04,
2948 class t_ARGTYPES_05,
2949 class t_ARGTYPES_06,
2950 class t_ARGTYPES_07,
2951 class t_ARGTYPES_08,
2952 class t_ARGTYPES_09>
2953struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
2954 t_ARGTYPES_02,
2955 t_ARGTYPES_03,
2956 t_ARGTYPES_04,
2957 t_ARGTYPES_05,
2958 t_ARGTYPES_06,
2959 t_ARGTYPES_07,
2960 t_ARGTYPES_08,
2961 t_ARGTYPES_09
2962 > : InvokeResult_ImpUtils {
2963
2964 typedef typename bsl::decay<t_FN>::type F;
2965
2966 enum {
2967
2968 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
2969 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2970 myDeclval<t_ARGTYPES_02>(),
2971 myDeclval<t_ARGTYPES_03>(),
2972 myDeclval<t_ARGTYPES_04>(),
2973 myDeclval<t_ARGTYPES_05>(),
2974 myDeclval<t_ARGTYPES_06>(),
2975 myDeclval<t_ARGTYPES_07>(),
2976 myDeclval<t_ARGTYPES_08>(),
2977 myDeclval<t_ARGTYPES_09>())))),
2978 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
2979 k_IS_LVALUE = BSLMF_TAG_TO_INT(
2980 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2981 myDeclval<t_ARGTYPES_02>(),
2982 myDeclval<t_ARGTYPES_03>(),
2983 myDeclval<t_ARGTYPES_04>(),
2984 myDeclval<t_ARGTYPES_05>(),
2985 myDeclval<t_ARGTYPES_06>(),
2986 myDeclval<t_ARGTYPES_07>(),
2987 myDeclval<t_ARGTYPES_08>(),
2988 myDeclval<t_ARGTYPES_09>()), 0)),
2989 k_IS_CONST_PTR = k_IS_POINTER &&
2990 BSLMF_TAG_TO_INT(checkConst(
2991 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
2992 myDeclval<t_ARGTYPES_02>(),
2993 myDeclval<t_ARGTYPES_03>(),
2994 myDeclval<t_ARGTYPES_04>(),
2995 myDeclval<t_ARGTYPES_05>(),
2996 myDeclval<t_ARGTYPES_06>(),
2997 myDeclval<t_ARGTYPES_07>(),
2998 myDeclval<t_ARGTYPES_08>(),
2999 myDeclval<t_ARGTYPES_09>()))),
3000 k_IS_VOLATILE_PTR = k_IS_POINTER &&
3001 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
3002 myDeclval<t_ARGTYPES_01>(),
3003 myDeclval<t_ARGTYPES_02>(),
3004 myDeclval<t_ARGTYPES_03>(),
3005 myDeclval<t_ARGTYPES_04>(),
3006 myDeclval<t_ARGTYPES_05>(),
3007 myDeclval<t_ARGTYPES_06>(),
3008 myDeclval<t_ARGTYPES_07>(),
3009 myDeclval<t_ARGTYPES_08>(),
3010 myDeclval<t_ARGTYPES_09>()))),
3011 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
3012 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3013 myDeclval<t_ARGTYPES_02>(),
3014 myDeclval<t_ARGTYPES_03>(),
3015 myDeclval<t_ARGTYPES_04>(),
3016 myDeclval<t_ARGTYPES_05>(),
3017 myDeclval<t_ARGTYPES_06>(),
3018 myDeclval<t_ARGTYPES_07>(),
3019 myDeclval<t_ARGTYPES_08>(),
3020 myDeclval<t_ARGTYPES_09>()))))),
3021 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
3022 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3023 myDeclval<t_ARGTYPES_02>(),
3024 myDeclval<t_ARGTYPES_03>(),
3025 myDeclval<t_ARGTYPES_04>(),
3026 myDeclval<t_ARGTYPES_05>(),
3027 myDeclval<t_ARGTYPES_06>(),
3028 myDeclval<t_ARGTYPES_07>(),
3029 myDeclval<t_ARGTYPES_08>(),
3030 myDeclval<t_ARGTYPES_09>())))),
3031 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
3032 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3033 myDeclval<t_ARGTYPES_02>(),
3034 myDeclval<t_ARGTYPES_03>(),
3035 myDeclval<t_ARGTYPES_04>(),
3036 myDeclval<t_ARGTYPES_05>(),
3037 myDeclval<t_ARGTYPES_06>(),
3038 myDeclval<t_ARGTYPES_07>(),
3039 myDeclval<t_ARGTYPES_08>(),
3040 myDeclval<t_ARGTYPES_09>())))),
3041 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
3042 (int)InvokeResult_Index::e_OTHER)
3043 };
3044
3045 typedef typename bsl::conditional<
3046 ! k_CANT_DEDUCE_TYPE,
3047 typename InvokeResult_Type<k_TARGET_INDEX>::type,
3048 typename ResultType<F,InvokeResultDeductionFailed>::type
3049 >::type UnqualTargetType;
3050
3051 typedef typename
3052 InvokeResult_AddCVRef<UnqualTargetType,
3053 static_cast<bool>(k_IS_CONST_TARGET)
3054 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3055 static_cast<bool>(k_IS_VOLATILE_TARGET)
3056 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3057 false>::type CVQualTargetType;
3058
3059 typedef typename
3060 bsl::conditional<static_cast<bool>(k_IS_POINTER)
3061 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3062 typename bsl::add_pointer<CVQualTargetType>::type,
3063 CVQualTargetType>::type UnqualType;
3064
3065 typedef typename
3066 InvokeResult_AddCVRef<
3067 UnqualType,
3068 static_cast<bool>(k_IS_CONST_PTR)
3069 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3070 static_cast<bool>(k_IS_VOLATILE_PTR)
3071 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3072 static_cast<bool>(k_IS_LVALUE)
3073 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
3074
3075 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
3076 typename bsl::remove_cv<Qtype>::type>::type type;
3077};
3078#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 9
3079
3080#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 10
3081template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
3082 class t_ARGTYPES_02,
3083 class t_ARGTYPES_03,
3084 class t_ARGTYPES_04,
3085 class t_ARGTYPES_05,
3086 class t_ARGTYPES_06,
3087 class t_ARGTYPES_07,
3088 class t_ARGTYPES_08,
3089 class t_ARGTYPES_09,
3090 class t_ARGTYPES_10>
3091struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
3092 t_ARGTYPES_02,
3093 t_ARGTYPES_03,
3094 t_ARGTYPES_04,
3095 t_ARGTYPES_05,
3096 t_ARGTYPES_06,
3097 t_ARGTYPES_07,
3098 t_ARGTYPES_08,
3099 t_ARGTYPES_09,
3100 t_ARGTYPES_10
3101 > : InvokeResult_ImpUtils {
3102
3103 typedef typename bsl::decay<t_FN>::type F;
3104
3105 enum {
3106
3107 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
3108 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3109 myDeclval<t_ARGTYPES_02>(),
3110 myDeclval<t_ARGTYPES_03>(),
3111 myDeclval<t_ARGTYPES_04>(),
3112 myDeclval<t_ARGTYPES_05>(),
3113 myDeclval<t_ARGTYPES_06>(),
3114 myDeclval<t_ARGTYPES_07>(),
3115 myDeclval<t_ARGTYPES_08>(),
3116 myDeclval<t_ARGTYPES_09>(),
3117 myDeclval<t_ARGTYPES_10>())))),
3118 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
3119 k_IS_LVALUE = BSLMF_TAG_TO_INT(
3120 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3121 myDeclval<t_ARGTYPES_02>(),
3122 myDeclval<t_ARGTYPES_03>(),
3123 myDeclval<t_ARGTYPES_04>(),
3124 myDeclval<t_ARGTYPES_05>(),
3125 myDeclval<t_ARGTYPES_06>(),
3126 myDeclval<t_ARGTYPES_07>(),
3127 myDeclval<t_ARGTYPES_08>(),
3128 myDeclval<t_ARGTYPES_09>(),
3129 myDeclval<t_ARGTYPES_10>()), 0)),
3130 k_IS_CONST_PTR = k_IS_POINTER &&
3131 BSLMF_TAG_TO_INT(checkConst(
3132 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3133 myDeclval<t_ARGTYPES_02>(),
3134 myDeclval<t_ARGTYPES_03>(),
3135 myDeclval<t_ARGTYPES_04>(),
3136 myDeclval<t_ARGTYPES_05>(),
3137 myDeclval<t_ARGTYPES_06>(),
3138 myDeclval<t_ARGTYPES_07>(),
3139 myDeclval<t_ARGTYPES_08>(),
3140 myDeclval<t_ARGTYPES_09>(),
3141 myDeclval<t_ARGTYPES_10>()))),
3142 k_IS_VOLATILE_PTR = k_IS_POINTER &&
3143 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
3144 myDeclval<t_ARGTYPES_01>(),
3145 myDeclval<t_ARGTYPES_02>(),
3146 myDeclval<t_ARGTYPES_03>(),
3147 myDeclval<t_ARGTYPES_04>(),
3148 myDeclval<t_ARGTYPES_05>(),
3149 myDeclval<t_ARGTYPES_06>(),
3150 myDeclval<t_ARGTYPES_07>(),
3151 myDeclval<t_ARGTYPES_08>(),
3152 myDeclval<t_ARGTYPES_09>(),
3153 myDeclval<t_ARGTYPES_10>()))),
3154 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
3155 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3156 myDeclval<t_ARGTYPES_02>(),
3157 myDeclval<t_ARGTYPES_03>(),
3158 myDeclval<t_ARGTYPES_04>(),
3159 myDeclval<t_ARGTYPES_05>(),
3160 myDeclval<t_ARGTYPES_06>(),
3161 myDeclval<t_ARGTYPES_07>(),
3162 myDeclval<t_ARGTYPES_08>(),
3163 myDeclval<t_ARGTYPES_09>(),
3164 myDeclval<t_ARGTYPES_10>()))))),
3165 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
3166 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3167 myDeclval<t_ARGTYPES_02>(),
3168 myDeclval<t_ARGTYPES_03>(),
3169 myDeclval<t_ARGTYPES_04>(),
3170 myDeclval<t_ARGTYPES_05>(),
3171 myDeclval<t_ARGTYPES_06>(),
3172 myDeclval<t_ARGTYPES_07>(),
3173 myDeclval<t_ARGTYPES_08>(),
3174 myDeclval<t_ARGTYPES_09>(),
3175 myDeclval<t_ARGTYPES_10>())))),
3176 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
3177 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3178 myDeclval<t_ARGTYPES_02>(),
3179 myDeclval<t_ARGTYPES_03>(),
3180 myDeclval<t_ARGTYPES_04>(),
3181 myDeclval<t_ARGTYPES_05>(),
3182 myDeclval<t_ARGTYPES_06>(),
3183 myDeclval<t_ARGTYPES_07>(),
3184 myDeclval<t_ARGTYPES_08>(),
3185 myDeclval<t_ARGTYPES_09>(),
3186 myDeclval<t_ARGTYPES_10>())))),
3187 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
3188 (int)InvokeResult_Index::e_OTHER)
3189 };
3190
3191 typedef typename bsl::conditional<
3192 ! k_CANT_DEDUCE_TYPE,
3193 typename InvokeResult_Type<k_TARGET_INDEX>::type,
3194 typename ResultType<F,InvokeResultDeductionFailed>::type
3195 >::type UnqualTargetType;
3196
3197 typedef typename
3198 InvokeResult_AddCVRef<UnqualTargetType,
3199 static_cast<bool>(k_IS_CONST_TARGET)
3200 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3201 static_cast<bool>(k_IS_VOLATILE_TARGET)
3202 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3203 false>::type CVQualTargetType;
3204
3205 typedef typename
3206 bsl::conditional<static_cast<bool>(k_IS_POINTER)
3207 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3208 typename bsl::add_pointer<CVQualTargetType>::type,
3209 CVQualTargetType>::type UnqualType;
3210
3211 typedef typename
3212 InvokeResult_AddCVRef<
3213 UnqualType,
3214 static_cast<bool>(k_IS_CONST_PTR)
3215 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3216 static_cast<bool>(k_IS_VOLATILE_PTR)
3217 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3218 static_cast<bool>(k_IS_LVALUE)
3219 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
3220
3221 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
3222 typename bsl::remove_cv<Qtype>::type>::type type;
3223};
3224#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 10
3225
3226#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 11
3227template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
3228 class t_ARGTYPES_02,
3229 class t_ARGTYPES_03,
3230 class t_ARGTYPES_04,
3231 class t_ARGTYPES_05,
3232 class t_ARGTYPES_06,
3233 class t_ARGTYPES_07,
3234 class t_ARGTYPES_08,
3235 class t_ARGTYPES_09,
3236 class t_ARGTYPES_10,
3237 class t_ARGTYPES_11>
3238struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
3239 t_ARGTYPES_02,
3240 t_ARGTYPES_03,
3241 t_ARGTYPES_04,
3242 t_ARGTYPES_05,
3243 t_ARGTYPES_06,
3244 t_ARGTYPES_07,
3245 t_ARGTYPES_08,
3246 t_ARGTYPES_09,
3247 t_ARGTYPES_10,
3248 t_ARGTYPES_11
3249 > : InvokeResult_ImpUtils {
3250
3251 typedef typename bsl::decay<t_FN>::type F;
3252
3253 enum {
3254
3255 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
3256 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3257 myDeclval<t_ARGTYPES_02>(),
3258 myDeclval<t_ARGTYPES_03>(),
3259 myDeclval<t_ARGTYPES_04>(),
3260 myDeclval<t_ARGTYPES_05>(),
3261 myDeclval<t_ARGTYPES_06>(),
3262 myDeclval<t_ARGTYPES_07>(),
3263 myDeclval<t_ARGTYPES_08>(),
3264 myDeclval<t_ARGTYPES_09>(),
3265 myDeclval<t_ARGTYPES_10>(),
3266 myDeclval<t_ARGTYPES_11>())))),
3267 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
3268 k_IS_LVALUE = BSLMF_TAG_TO_INT(
3269 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3270 myDeclval<t_ARGTYPES_02>(),
3271 myDeclval<t_ARGTYPES_03>(),
3272 myDeclval<t_ARGTYPES_04>(),
3273 myDeclval<t_ARGTYPES_05>(),
3274 myDeclval<t_ARGTYPES_06>(),
3275 myDeclval<t_ARGTYPES_07>(),
3276 myDeclval<t_ARGTYPES_08>(),
3277 myDeclval<t_ARGTYPES_09>(),
3278 myDeclval<t_ARGTYPES_10>(),
3279 myDeclval<t_ARGTYPES_11>()), 0)),
3280 k_IS_CONST_PTR = k_IS_POINTER &&
3281 BSLMF_TAG_TO_INT(checkConst(
3282 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3283 myDeclval<t_ARGTYPES_02>(),
3284 myDeclval<t_ARGTYPES_03>(),
3285 myDeclval<t_ARGTYPES_04>(),
3286 myDeclval<t_ARGTYPES_05>(),
3287 myDeclval<t_ARGTYPES_06>(),
3288 myDeclval<t_ARGTYPES_07>(),
3289 myDeclval<t_ARGTYPES_08>(),
3290 myDeclval<t_ARGTYPES_09>(),
3291 myDeclval<t_ARGTYPES_10>(),
3292 myDeclval<t_ARGTYPES_11>()))),
3293 k_IS_VOLATILE_PTR = k_IS_POINTER &&
3294 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
3295 myDeclval<t_ARGTYPES_01>(),
3296 myDeclval<t_ARGTYPES_02>(),
3297 myDeclval<t_ARGTYPES_03>(),
3298 myDeclval<t_ARGTYPES_04>(),
3299 myDeclval<t_ARGTYPES_05>(),
3300 myDeclval<t_ARGTYPES_06>(),
3301 myDeclval<t_ARGTYPES_07>(),
3302 myDeclval<t_ARGTYPES_08>(),
3303 myDeclval<t_ARGTYPES_09>(),
3304 myDeclval<t_ARGTYPES_10>(),
3305 myDeclval<t_ARGTYPES_11>()))),
3306 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
3307 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3308 myDeclval<t_ARGTYPES_02>(),
3309 myDeclval<t_ARGTYPES_03>(),
3310 myDeclval<t_ARGTYPES_04>(),
3311 myDeclval<t_ARGTYPES_05>(),
3312 myDeclval<t_ARGTYPES_06>(),
3313 myDeclval<t_ARGTYPES_07>(),
3314 myDeclval<t_ARGTYPES_08>(),
3315 myDeclval<t_ARGTYPES_09>(),
3316 myDeclval<t_ARGTYPES_10>(),
3317 myDeclval<t_ARGTYPES_11>()))))),
3318 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
3319 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3320 myDeclval<t_ARGTYPES_02>(),
3321 myDeclval<t_ARGTYPES_03>(),
3322 myDeclval<t_ARGTYPES_04>(),
3323 myDeclval<t_ARGTYPES_05>(),
3324 myDeclval<t_ARGTYPES_06>(),
3325 myDeclval<t_ARGTYPES_07>(),
3326 myDeclval<t_ARGTYPES_08>(),
3327 myDeclval<t_ARGTYPES_09>(),
3328 myDeclval<t_ARGTYPES_10>(),
3329 myDeclval<t_ARGTYPES_11>())))),
3330 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
3331 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3332 myDeclval<t_ARGTYPES_02>(),
3333 myDeclval<t_ARGTYPES_03>(),
3334 myDeclval<t_ARGTYPES_04>(),
3335 myDeclval<t_ARGTYPES_05>(),
3336 myDeclval<t_ARGTYPES_06>(),
3337 myDeclval<t_ARGTYPES_07>(),
3338 myDeclval<t_ARGTYPES_08>(),
3339 myDeclval<t_ARGTYPES_09>(),
3340 myDeclval<t_ARGTYPES_10>(),
3341 myDeclval<t_ARGTYPES_11>())))),
3342 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
3343 (int)InvokeResult_Index::e_OTHER)
3344 };
3345
3346 typedef typename bsl::conditional<
3347 ! k_CANT_DEDUCE_TYPE,
3348 typename InvokeResult_Type<k_TARGET_INDEX>::type,
3349 typename ResultType<F,InvokeResultDeductionFailed>::type
3350 >::type UnqualTargetType;
3351
3352 typedef typename
3353 InvokeResult_AddCVRef<UnqualTargetType,
3354 static_cast<bool>(k_IS_CONST_TARGET)
3355 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3356 static_cast<bool>(k_IS_VOLATILE_TARGET)
3357 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3358 false>::type CVQualTargetType;
3359
3360 typedef typename
3361 bsl::conditional<static_cast<bool>(k_IS_POINTER)
3362 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3363 typename bsl::add_pointer<CVQualTargetType>::type,
3364 CVQualTargetType>::type UnqualType;
3365
3366 typedef typename
3367 InvokeResult_AddCVRef<
3368 UnqualType,
3369 static_cast<bool>(k_IS_CONST_PTR)
3370 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3371 static_cast<bool>(k_IS_VOLATILE_PTR)
3372 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3373 static_cast<bool>(k_IS_LVALUE)
3374 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
3375
3376 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
3377 typename bsl::remove_cv<Qtype>::type>::type type;
3378};
3379#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 11
3380
3381#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 12
3382template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
3383 class t_ARGTYPES_02,
3384 class t_ARGTYPES_03,
3385 class t_ARGTYPES_04,
3386 class t_ARGTYPES_05,
3387 class t_ARGTYPES_06,
3388 class t_ARGTYPES_07,
3389 class t_ARGTYPES_08,
3390 class t_ARGTYPES_09,
3391 class t_ARGTYPES_10,
3392 class t_ARGTYPES_11,
3393 class t_ARGTYPES_12>
3394struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
3395 t_ARGTYPES_02,
3396 t_ARGTYPES_03,
3397 t_ARGTYPES_04,
3398 t_ARGTYPES_05,
3399 t_ARGTYPES_06,
3400 t_ARGTYPES_07,
3401 t_ARGTYPES_08,
3402 t_ARGTYPES_09,
3403 t_ARGTYPES_10,
3404 t_ARGTYPES_11,
3405 t_ARGTYPES_12
3406 > : InvokeResult_ImpUtils {
3407
3408 typedef typename bsl::decay<t_FN>::type F;
3409
3410 enum {
3411
3412 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
3413 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3414 myDeclval<t_ARGTYPES_02>(),
3415 myDeclval<t_ARGTYPES_03>(),
3416 myDeclval<t_ARGTYPES_04>(),
3417 myDeclval<t_ARGTYPES_05>(),
3418 myDeclval<t_ARGTYPES_06>(),
3419 myDeclval<t_ARGTYPES_07>(),
3420 myDeclval<t_ARGTYPES_08>(),
3421 myDeclval<t_ARGTYPES_09>(),
3422 myDeclval<t_ARGTYPES_10>(),
3423 myDeclval<t_ARGTYPES_11>(),
3424 myDeclval<t_ARGTYPES_12>())))),
3425 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
3426 k_IS_LVALUE = BSLMF_TAG_TO_INT(
3427 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3428 myDeclval<t_ARGTYPES_02>(),
3429 myDeclval<t_ARGTYPES_03>(),
3430 myDeclval<t_ARGTYPES_04>(),
3431 myDeclval<t_ARGTYPES_05>(),
3432 myDeclval<t_ARGTYPES_06>(),
3433 myDeclval<t_ARGTYPES_07>(),
3434 myDeclval<t_ARGTYPES_08>(),
3435 myDeclval<t_ARGTYPES_09>(),
3436 myDeclval<t_ARGTYPES_10>(),
3437 myDeclval<t_ARGTYPES_11>(),
3438 myDeclval<t_ARGTYPES_12>()), 0)),
3439 k_IS_CONST_PTR = k_IS_POINTER &&
3440 BSLMF_TAG_TO_INT(checkConst(
3441 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3442 myDeclval<t_ARGTYPES_02>(),
3443 myDeclval<t_ARGTYPES_03>(),
3444 myDeclval<t_ARGTYPES_04>(),
3445 myDeclval<t_ARGTYPES_05>(),
3446 myDeclval<t_ARGTYPES_06>(),
3447 myDeclval<t_ARGTYPES_07>(),
3448 myDeclval<t_ARGTYPES_08>(),
3449 myDeclval<t_ARGTYPES_09>(),
3450 myDeclval<t_ARGTYPES_10>(),
3451 myDeclval<t_ARGTYPES_11>(),
3452 myDeclval<t_ARGTYPES_12>()))),
3453 k_IS_VOLATILE_PTR = k_IS_POINTER &&
3454 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
3455 myDeclval<t_ARGTYPES_01>(),
3456 myDeclval<t_ARGTYPES_02>(),
3457 myDeclval<t_ARGTYPES_03>(),
3458 myDeclval<t_ARGTYPES_04>(),
3459 myDeclval<t_ARGTYPES_05>(),
3460 myDeclval<t_ARGTYPES_06>(),
3461 myDeclval<t_ARGTYPES_07>(),
3462 myDeclval<t_ARGTYPES_08>(),
3463 myDeclval<t_ARGTYPES_09>(),
3464 myDeclval<t_ARGTYPES_10>(),
3465 myDeclval<t_ARGTYPES_11>(),
3466 myDeclval<t_ARGTYPES_12>()))),
3467 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
3468 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3469 myDeclval<t_ARGTYPES_02>(),
3470 myDeclval<t_ARGTYPES_03>(),
3471 myDeclval<t_ARGTYPES_04>(),
3472 myDeclval<t_ARGTYPES_05>(),
3473 myDeclval<t_ARGTYPES_06>(),
3474 myDeclval<t_ARGTYPES_07>(),
3475 myDeclval<t_ARGTYPES_08>(),
3476 myDeclval<t_ARGTYPES_09>(),
3477 myDeclval<t_ARGTYPES_10>(),
3478 myDeclval<t_ARGTYPES_11>(),
3479 myDeclval<t_ARGTYPES_12>()))))),
3480 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
3481 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3482 myDeclval<t_ARGTYPES_02>(),
3483 myDeclval<t_ARGTYPES_03>(),
3484 myDeclval<t_ARGTYPES_04>(),
3485 myDeclval<t_ARGTYPES_05>(),
3486 myDeclval<t_ARGTYPES_06>(),
3487 myDeclval<t_ARGTYPES_07>(),
3488 myDeclval<t_ARGTYPES_08>(),
3489 myDeclval<t_ARGTYPES_09>(),
3490 myDeclval<t_ARGTYPES_10>(),
3491 myDeclval<t_ARGTYPES_11>(),
3492 myDeclval<t_ARGTYPES_12>())))),
3493 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
3494 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3495 myDeclval<t_ARGTYPES_02>(),
3496 myDeclval<t_ARGTYPES_03>(),
3497 myDeclval<t_ARGTYPES_04>(),
3498 myDeclval<t_ARGTYPES_05>(),
3499 myDeclval<t_ARGTYPES_06>(),
3500 myDeclval<t_ARGTYPES_07>(),
3501 myDeclval<t_ARGTYPES_08>(),
3502 myDeclval<t_ARGTYPES_09>(),
3503 myDeclval<t_ARGTYPES_10>(),
3504 myDeclval<t_ARGTYPES_11>(),
3505 myDeclval<t_ARGTYPES_12>())))),
3506 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
3507 (int)InvokeResult_Index::e_OTHER)
3508 };
3509
3510 typedef typename bsl::conditional<
3511 ! k_CANT_DEDUCE_TYPE,
3512 typename InvokeResult_Type<k_TARGET_INDEX>::type,
3513 typename ResultType<F,InvokeResultDeductionFailed>::type
3514 >::type UnqualTargetType;
3515
3516 typedef typename
3517 InvokeResult_AddCVRef<UnqualTargetType,
3518 static_cast<bool>(k_IS_CONST_TARGET)
3519 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3520 static_cast<bool>(k_IS_VOLATILE_TARGET)
3521 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3522 false>::type CVQualTargetType;
3523
3524 typedef typename
3525 bsl::conditional<static_cast<bool>(k_IS_POINTER)
3526 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3527 typename bsl::add_pointer<CVQualTargetType>::type,
3528 CVQualTargetType>::type UnqualType;
3529
3530 typedef typename
3531 InvokeResult_AddCVRef<
3532 UnqualType,
3533 static_cast<bool>(k_IS_CONST_PTR)
3534 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3535 static_cast<bool>(k_IS_VOLATILE_PTR)
3536 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3537 static_cast<bool>(k_IS_LVALUE)
3538 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
3539
3540 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
3541 typename bsl::remove_cv<Qtype>::type>::type type;
3542};
3543#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 12
3544
3545#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 13
3546template <bool __Param__0, class t_FN, class t_ARGTYPES_01,
3547 class t_ARGTYPES_02,
3548 class t_ARGTYPES_03,
3549 class t_ARGTYPES_04,
3550 class t_ARGTYPES_05,
3551 class t_ARGTYPES_06,
3552 class t_ARGTYPES_07,
3553 class t_ARGTYPES_08,
3554 class t_ARGTYPES_09,
3555 class t_ARGTYPES_10,
3556 class t_ARGTYPES_11,
3557 class t_ARGTYPES_12,
3558 class t_ARGTYPES_13>
3559struct InvokeResult_FunctorDeduction<__Param__0, t_FN, t_ARGTYPES_01,
3560 t_ARGTYPES_02,
3561 t_ARGTYPES_03,
3562 t_ARGTYPES_04,
3563 t_ARGTYPES_05,
3564 t_ARGTYPES_06,
3565 t_ARGTYPES_07,
3566 t_ARGTYPES_08,
3567 t_ARGTYPES_09,
3568 t_ARGTYPES_10,
3569 t_ARGTYPES_11,
3570 t_ARGTYPES_12,
3571 t_ARGTYPES_13
3572 > : InvokeResult_ImpUtils {
3573
3574 typedef typename bsl::decay<t_FN>::type F;
3575
3576 enum {
3577
3578 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
3579 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3580 myDeclval<t_ARGTYPES_02>(),
3581 myDeclval<t_ARGTYPES_03>(),
3582 myDeclval<t_ARGTYPES_04>(),
3583 myDeclval<t_ARGTYPES_05>(),
3584 myDeclval<t_ARGTYPES_06>(),
3585 myDeclval<t_ARGTYPES_07>(),
3586 myDeclval<t_ARGTYPES_08>(),
3587 myDeclval<t_ARGTYPES_09>(),
3588 myDeclval<t_ARGTYPES_10>(),
3589 myDeclval<t_ARGTYPES_11>(),
3590 myDeclval<t_ARGTYPES_12>(),
3591 myDeclval<t_ARGTYPES_13>())))),
3592 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
3593 k_IS_LVALUE = BSLMF_TAG_TO_INT(
3594 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3595 myDeclval<t_ARGTYPES_02>(),
3596 myDeclval<t_ARGTYPES_03>(),
3597 myDeclval<t_ARGTYPES_04>(),
3598 myDeclval<t_ARGTYPES_05>(),
3599 myDeclval<t_ARGTYPES_06>(),
3600 myDeclval<t_ARGTYPES_07>(),
3601 myDeclval<t_ARGTYPES_08>(),
3602 myDeclval<t_ARGTYPES_09>(),
3603 myDeclval<t_ARGTYPES_10>(),
3604 myDeclval<t_ARGTYPES_11>(),
3605 myDeclval<t_ARGTYPES_12>(),
3606 myDeclval<t_ARGTYPES_13>()), 0)),
3607 k_IS_CONST_PTR = k_IS_POINTER &&
3608 BSLMF_TAG_TO_INT(checkConst(
3609 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3610 myDeclval<t_ARGTYPES_02>(),
3611 myDeclval<t_ARGTYPES_03>(),
3612 myDeclval<t_ARGTYPES_04>(),
3613 myDeclval<t_ARGTYPES_05>(),
3614 myDeclval<t_ARGTYPES_06>(),
3615 myDeclval<t_ARGTYPES_07>(),
3616 myDeclval<t_ARGTYPES_08>(),
3617 myDeclval<t_ARGTYPES_09>(),
3618 myDeclval<t_ARGTYPES_10>(),
3619 myDeclval<t_ARGTYPES_11>(),
3620 myDeclval<t_ARGTYPES_12>(),
3621 myDeclval<t_ARGTYPES_13>()))),
3622 k_IS_VOLATILE_PTR = k_IS_POINTER &&
3623 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
3624 myDeclval<t_ARGTYPES_01>(),
3625 myDeclval<t_ARGTYPES_02>(),
3626 myDeclval<t_ARGTYPES_03>(),
3627 myDeclval<t_ARGTYPES_04>(),
3628 myDeclval<t_ARGTYPES_05>(),
3629 myDeclval<t_ARGTYPES_06>(),
3630 myDeclval<t_ARGTYPES_07>(),
3631 myDeclval<t_ARGTYPES_08>(),
3632 myDeclval<t_ARGTYPES_09>(),
3633 myDeclval<t_ARGTYPES_10>(),
3634 myDeclval<t_ARGTYPES_11>(),
3635 myDeclval<t_ARGTYPES_12>(),
3636 myDeclval<t_ARGTYPES_13>()))),
3637 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
3638 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3639 myDeclval<t_ARGTYPES_02>(),
3640 myDeclval<t_ARGTYPES_03>(),
3641 myDeclval<t_ARGTYPES_04>(),
3642 myDeclval<t_ARGTYPES_05>(),
3643 myDeclval<t_ARGTYPES_06>(),
3644 myDeclval<t_ARGTYPES_07>(),
3645 myDeclval<t_ARGTYPES_08>(),
3646 myDeclval<t_ARGTYPES_09>(),
3647 myDeclval<t_ARGTYPES_10>(),
3648 myDeclval<t_ARGTYPES_11>(),
3649 myDeclval<t_ARGTYPES_12>(),
3650 myDeclval<t_ARGTYPES_13>()))))),
3651 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
3652 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3653 myDeclval<t_ARGTYPES_02>(),
3654 myDeclval<t_ARGTYPES_03>(),
3655 myDeclval<t_ARGTYPES_04>(),
3656 myDeclval<t_ARGTYPES_05>(),
3657 myDeclval<t_ARGTYPES_06>(),
3658 myDeclval<t_ARGTYPES_07>(),
3659 myDeclval<t_ARGTYPES_08>(),
3660 myDeclval<t_ARGTYPES_09>(),
3661 myDeclval<t_ARGTYPES_10>(),
3662 myDeclval<t_ARGTYPES_11>(),
3663 myDeclval<t_ARGTYPES_12>(),
3664 myDeclval<t_ARGTYPES_13>())))),
3665 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
3666 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
3667 myDeclval<t_ARGTYPES_02>(),
3668 myDeclval<t_ARGTYPES_03>(),
3669 myDeclval<t_ARGTYPES_04>(),
3670 myDeclval<t_ARGTYPES_05>(),
3671 myDeclval<t_ARGTYPES_06>(),
3672 myDeclval<t_ARGTYPES_07>(),
3673 myDeclval<t_ARGTYPES_08>(),
3674 myDeclval<t_ARGTYPES_09>(),
3675 myDeclval<t_ARGTYPES_10>(),
3676 myDeclval<t_ARGTYPES_11>(),
3677 myDeclval<t_ARGTYPES_12>(),
3678 myDeclval<t_ARGTYPES_13>())))),
3679 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
3680 (int)InvokeResult_Index::e_OTHER)
3681 };
3682
3683 typedef typename bsl::conditional<
3684 ! k_CANT_DEDUCE_TYPE,
3685 typename InvokeResult_Type<k_TARGET_INDEX>::type,
3686 typename ResultType<F,InvokeResultDeductionFailed>::type
3687 >::type UnqualTargetType;
3688
3689 typedef typename
3690 InvokeResult_AddCVRef<UnqualTargetType,
3691 static_cast<bool>(k_IS_CONST_TARGET)
3692 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3693 static_cast<bool>(k_IS_VOLATILE_TARGET)
3694 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3695 false>::type CVQualTargetType;
3696
3697 typedef typename
3698 bsl::conditional<static_cast<bool>(k_IS_POINTER)
3699 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3700 typename bsl::add_pointer<CVQualTargetType>::type,
3701 CVQualTargetType>::type UnqualType;
3702
3703 typedef typename
3704 InvokeResult_AddCVRef<
3705 UnqualType,
3706 static_cast<bool>(k_IS_CONST_PTR)
3707 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3708 static_cast<bool>(k_IS_VOLATILE_PTR)
3709 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
3710 static_cast<bool>(k_IS_LVALUE)
3711 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
3712
3713 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
3714 typename bsl::remove_cv<Qtype>::type>::type type;
3715};
3716#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 13
3717
3718
3719#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 0
3720template <class t_FN>
3721struct InvokeResult_FunctorDeduction<true , t_FN> {
3722
3723 typedef void type;
3724};
3725#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 0
3726
3727#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 1
3728template <class t_FN, class t_ARGTYPES_01>
3729struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01> {
3730
3731 typedef void type;
3732};
3733#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 1
3734
3735#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 2
3736template <class t_FN, class t_ARGTYPES_01,
3737 class t_ARGTYPES_02>
3738struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3739 t_ARGTYPES_02> {
3740
3741 typedef void type;
3742};
3743#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 2
3744
3745#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 3
3746template <class t_FN, class t_ARGTYPES_01,
3747 class t_ARGTYPES_02,
3748 class t_ARGTYPES_03>
3749struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3750 t_ARGTYPES_02,
3751 t_ARGTYPES_03> {
3752
3753 typedef void type;
3754};
3755#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 3
3756
3757#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 4
3758template <class t_FN, class t_ARGTYPES_01,
3759 class t_ARGTYPES_02,
3760 class t_ARGTYPES_03,
3761 class t_ARGTYPES_04>
3762struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3763 t_ARGTYPES_02,
3764 t_ARGTYPES_03,
3765 t_ARGTYPES_04> {
3766
3767 typedef void type;
3768};
3769#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 4
3770
3771#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 5
3772template <class t_FN, class t_ARGTYPES_01,
3773 class t_ARGTYPES_02,
3774 class t_ARGTYPES_03,
3775 class t_ARGTYPES_04,
3776 class t_ARGTYPES_05>
3777struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3778 t_ARGTYPES_02,
3779 t_ARGTYPES_03,
3780 t_ARGTYPES_04,
3781 t_ARGTYPES_05> {
3782
3783 typedef void type;
3784};
3785#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 5
3786
3787#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 6
3788template <class t_FN, class t_ARGTYPES_01,
3789 class t_ARGTYPES_02,
3790 class t_ARGTYPES_03,
3791 class t_ARGTYPES_04,
3792 class t_ARGTYPES_05,
3793 class t_ARGTYPES_06>
3794struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3795 t_ARGTYPES_02,
3796 t_ARGTYPES_03,
3797 t_ARGTYPES_04,
3798 t_ARGTYPES_05,
3799 t_ARGTYPES_06> {
3800
3801 typedef void type;
3802};
3803#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 6
3804
3805#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 7
3806template <class t_FN, class t_ARGTYPES_01,
3807 class t_ARGTYPES_02,
3808 class t_ARGTYPES_03,
3809 class t_ARGTYPES_04,
3810 class t_ARGTYPES_05,
3811 class t_ARGTYPES_06,
3812 class t_ARGTYPES_07>
3813struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3814 t_ARGTYPES_02,
3815 t_ARGTYPES_03,
3816 t_ARGTYPES_04,
3817 t_ARGTYPES_05,
3818 t_ARGTYPES_06,
3819 t_ARGTYPES_07> {
3820
3821 typedef void type;
3822};
3823#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 7
3824
3825#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 8
3826template <class t_FN, class t_ARGTYPES_01,
3827 class t_ARGTYPES_02,
3828 class t_ARGTYPES_03,
3829 class t_ARGTYPES_04,
3830 class t_ARGTYPES_05,
3831 class t_ARGTYPES_06,
3832 class t_ARGTYPES_07,
3833 class t_ARGTYPES_08>
3834struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3835 t_ARGTYPES_02,
3836 t_ARGTYPES_03,
3837 t_ARGTYPES_04,
3838 t_ARGTYPES_05,
3839 t_ARGTYPES_06,
3840 t_ARGTYPES_07,
3841 t_ARGTYPES_08> {
3842
3843 typedef void type;
3844};
3845#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 8
3846
3847#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 9
3848template <class t_FN, class t_ARGTYPES_01,
3849 class t_ARGTYPES_02,
3850 class t_ARGTYPES_03,
3851 class t_ARGTYPES_04,
3852 class t_ARGTYPES_05,
3853 class t_ARGTYPES_06,
3854 class t_ARGTYPES_07,
3855 class t_ARGTYPES_08,
3856 class t_ARGTYPES_09>
3857struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3858 t_ARGTYPES_02,
3859 t_ARGTYPES_03,
3860 t_ARGTYPES_04,
3861 t_ARGTYPES_05,
3862 t_ARGTYPES_06,
3863 t_ARGTYPES_07,
3864 t_ARGTYPES_08,
3865 t_ARGTYPES_09> {
3866
3867 typedef void type;
3868};
3869#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 9
3870
3871#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 10
3872template <class t_FN, class t_ARGTYPES_01,
3873 class t_ARGTYPES_02,
3874 class t_ARGTYPES_03,
3875 class t_ARGTYPES_04,
3876 class t_ARGTYPES_05,
3877 class t_ARGTYPES_06,
3878 class t_ARGTYPES_07,
3879 class t_ARGTYPES_08,
3880 class t_ARGTYPES_09,
3881 class t_ARGTYPES_10>
3882struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3883 t_ARGTYPES_02,
3884 t_ARGTYPES_03,
3885 t_ARGTYPES_04,
3886 t_ARGTYPES_05,
3887 t_ARGTYPES_06,
3888 t_ARGTYPES_07,
3889 t_ARGTYPES_08,
3890 t_ARGTYPES_09,
3891 t_ARGTYPES_10> {
3892
3893 typedef void type;
3894};
3895#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 10
3896
3897#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 11
3898template <class t_FN, class t_ARGTYPES_01,
3899 class t_ARGTYPES_02,
3900 class t_ARGTYPES_03,
3901 class t_ARGTYPES_04,
3902 class t_ARGTYPES_05,
3903 class t_ARGTYPES_06,
3904 class t_ARGTYPES_07,
3905 class t_ARGTYPES_08,
3906 class t_ARGTYPES_09,
3907 class t_ARGTYPES_10,
3908 class t_ARGTYPES_11>
3909struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3910 t_ARGTYPES_02,
3911 t_ARGTYPES_03,
3912 t_ARGTYPES_04,
3913 t_ARGTYPES_05,
3914 t_ARGTYPES_06,
3915 t_ARGTYPES_07,
3916 t_ARGTYPES_08,
3917 t_ARGTYPES_09,
3918 t_ARGTYPES_10,
3919 t_ARGTYPES_11> {
3920
3921 typedef void type;
3922};
3923#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 11
3924
3925#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 12
3926template <class t_FN, class t_ARGTYPES_01,
3927 class t_ARGTYPES_02,
3928 class t_ARGTYPES_03,
3929 class t_ARGTYPES_04,
3930 class t_ARGTYPES_05,
3931 class t_ARGTYPES_06,
3932 class t_ARGTYPES_07,
3933 class t_ARGTYPES_08,
3934 class t_ARGTYPES_09,
3935 class t_ARGTYPES_10,
3936 class t_ARGTYPES_11,
3937 class t_ARGTYPES_12>
3938struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3939 t_ARGTYPES_02,
3940 t_ARGTYPES_03,
3941 t_ARGTYPES_04,
3942 t_ARGTYPES_05,
3943 t_ARGTYPES_06,
3944 t_ARGTYPES_07,
3945 t_ARGTYPES_08,
3946 t_ARGTYPES_09,
3947 t_ARGTYPES_10,
3948 t_ARGTYPES_11,
3949 t_ARGTYPES_12> {
3950
3951 typedef void type;
3952};
3953#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 12
3954
3955#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 13
3956template <class t_FN, class t_ARGTYPES_01,
3957 class t_ARGTYPES_02,
3958 class t_ARGTYPES_03,
3959 class t_ARGTYPES_04,
3960 class t_ARGTYPES_05,
3961 class t_ARGTYPES_06,
3962 class t_ARGTYPES_07,
3963 class t_ARGTYPES_08,
3964 class t_ARGTYPES_09,
3965 class t_ARGTYPES_10,
3966 class t_ARGTYPES_11,
3967 class t_ARGTYPES_12,
3968 class t_ARGTYPES_13>
3969struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES_01,
3970 t_ARGTYPES_02,
3971 t_ARGTYPES_03,
3972 t_ARGTYPES_04,
3973 t_ARGTYPES_05,
3974 t_ARGTYPES_06,
3975 t_ARGTYPES_07,
3976 t_ARGTYPES_08,
3977 t_ARGTYPES_09,
3978 t_ARGTYPES_10,
3979 t_ARGTYPES_11,
3980 t_ARGTYPES_12,
3981 t_ARGTYPES_13> {
3982
3983 typedef void type;
3984};
3985#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_D >= 13
3986
3987#endif
3988#else
3989// The generated code below is a workaround for the absence of perfect
3990// forwarding in some compilers.
3991
3992#ifndef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
3993template <bool , class t_FN, class... t_ARGTYPES>
3994struct InvokeResult_FunctorDeduction : InvokeResult_ImpUtils {
3995
3996 typedef typename bsl::decay<t_FN>::type F;
3997
3998 enum {
3999
4000 k_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
4001 uncv(myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...)))),
4002 k_IS_POINTER = (k_INDEX == InvokeResult_Index::e_POINTER),
4003 k_IS_LVALUE = BSLMF_TAG_TO_INT(
4004 checkLvalue(myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...), 0)),
4005 k_IS_CONST_PTR = k_IS_POINTER &&
4006 BSLMF_TAG_TO_INT(checkConst(
4007 myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...))),
4008 k_IS_VOLATILE_PTR = k_IS_POINTER &&
4009 BSLMF_TAG_TO_INT(checkVolatile(myDeclval<t_FN>()(
4010 myDeclval<t_ARGTYPES>()...))),
4011 k_TARGET_INDEX = BSLMF_TAG_TO_INT(InvokeResult_Index::fromVal(
4012 uncv(unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...))))),
4013 k_IS_CONST_TARGET = BSLMF_TAG_TO_INT(checkConst(
4014 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...)))),
4015 k_IS_VOLATILE_TARGET = BSLMF_TAG_TO_INT(checkVolatile(
4016 unpoint(myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...)))),
4017 k_CANT_DEDUCE_TYPE = (k_TARGET_INDEX ==
4018 (int)InvokeResult_Index::e_OTHER)
4019 };
4020
4021 typedef typename bsl::conditional<
4022 ! k_CANT_DEDUCE_TYPE,
4023 typename InvokeResult_Type<k_TARGET_INDEX>::type,
4024 typename ResultType<F,InvokeResultDeductionFailed>::type
4025 >::type UnqualTargetType;
4026
4027 typedef typename
4028 InvokeResult_AddCVRef<UnqualTargetType,
4029 static_cast<bool>(k_IS_CONST_TARGET)
4030 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
4031 static_cast<bool>(k_IS_VOLATILE_TARGET)
4032 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
4033 false>::type CVQualTargetType;
4034
4035 typedef typename
4036 bsl::conditional<static_cast<bool>(k_IS_POINTER)
4037 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
4038 typename bsl::add_pointer<CVQualTargetType>::type,
4039 CVQualTargetType>::type UnqualType;
4040
4041 typedef typename
4042 InvokeResult_AddCVRef<
4043 UnqualType,
4044 static_cast<bool>(k_IS_CONST_PTR)
4045 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
4046 static_cast<bool>(k_IS_VOLATILE_PTR)
4047 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE),
4048 static_cast<bool>(k_IS_LVALUE)
4049 && ! static_cast<bool>(k_CANT_DEDUCE_TYPE)>::type Qtype;
4050
4051 typedef typename bsl::conditional<static_cast<bool>(k_IS_LVALUE), Qtype,
4052 typename bsl::remove_cv<Qtype>::type>::type type;
4053};
4054
4055template <class t_FN, class... t_ARGTYPES>
4056struct InvokeResult_FunctorDeduction<true , t_FN, t_ARGTYPES...> {
4057
4058 typedef void type;
4059};
4060#endif
4061
4062// }}} END GENERATED CODE
4063#endif
4064
4065/// This metafunction determines which cv qualifiers and reference
4066/// qualifiers should be propagated from the first argument of
4067/// @ref invoke_result . This primary template is instantiated when
4068/// `t_ARG_TYPE` is the same or is derived from `t_MEMOF_CLASS`. The
4069/// constant `k_IS_LVALUE` is true iff `t_ARG_TYPE` is an lvalue reference;
4070/// the constant `k_IS_CONST` is true iff `t_ARG_TYPE` is const-qualified;
4071/// and the constant `k_IS_VOLATILE` is true iff `t_ARG_TYPE` is
4072/// volatile-qualified.
4073template <class t_MEMOF_CLASS,
4074 class t_ARG_TYPE,
4075 bool t_IS_DERIVED = bsl::is_convertible<
4076 typename bsl::decay<t_ARG_TYPE>::type *,
4077 typename bsl::decay<t_MEMOF_CLASS>::type *>::value>
4078struct InvokeResult_MemPtrArgQualifiers {
4079
4080 // TYPES
4081 enum {
4082 k_IS_LVALUE = bsl::is_lvalue_reference<t_ARG_TYPE>::value,
4083 k_IS_CONST = bsl::is_const<
4084 typename bsl::remove_reference<t_ARG_TYPE>::type>::value,
4085 k_IS_VOLATILE = bsl::is_volatile<
4086 typename bsl::remove_reference<t_ARG_TYPE>::type>::value
4087 };
4088};
4089
4090/// This metafunction determines which cv qualifiers and reference
4091/// qualifiers should be propagated from the first argument of
4092/// @ref invoke_result .
4093///
4094/// This specialization is instantiated when `t_ARG_TYPE` is not derived
4095/// from `t_MEMOF_CLASS` and is assumed to be a pointer or smart pointer
4096/// type. If type `A` is the result of dereferencing an object of type
4097/// `t_ARG_TYPE`, then the constant `k_IS_LVALUE` is true iff `A` is an
4098/// lvalue reference; the constant `k_IS_CONST` is true iff `A` is a
4099/// const-qualified reference; and the constant `k_IS_VOLATILE` is true iff
4100/// `A` is a volatile-qualified reference.
4101template <class t_MEMOF_CLASS, class t_ARG_TYPE>
4102struct InvokeResult_MemPtrArgQualifiers<t_MEMOF_CLASS, t_ARG_TYPE, false>
4103: InvokeResult_ImpUtils {
4104
4105#ifdef BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES
4106 private:
4107 // CLASS METHODS
4108
4109 /// (Declared but not defined.) Return an lvalue reference
4110 /// corresponding of the specified `t_TP` type, which is deduced from
4111 /// the specified unnamed argument. If the argument is an lvalue, the
4112 /// return type is identical to the argument type. If the argument is
4113 /// an rvalue, the return type is an lvalue to the argument type with
4114 /// the same cv qualifiers. This function is useful for avoiding too
4115 /// many redundant overloads in metafunctions that determine cv
4116 /// qualifications, etc.
4117 template <class t_TP>
4118 static t_TP& tolvalue(t_TP&&);
4119
4120 public:
4121 // TYPES
4122 enum {k_IS_LVALUE = BSLMF_TAG_TO_INT(checkLvalue(*myDeclval<t_ARG_TYPE>(),
4123 0)),
4124 k_IS_CONST =
4125 BSLMF_TAG_TO_INT(checkConst(tolvalue(*myDeclval<t_ARG_TYPE>()))),
4126 k_IS_VOLATILE = BSLMF_TAG_TO_INT(
4127 checkVolatile(tolvalue(*myDeclval<t_ARG_TYPE>())))};
4128#else
4129 public:
4130 // TYPES
4131 enum {
4132 k_IS_LVALUE = BSLMF_TAG_TO_INT(checkLvalue(*myDeclval<t_ARG_TYPE>(),
4133 0)),
4134 // In C++03, cv qualifiers are discarded from rvalues.
4135 k_IS_CONST = k_IS_LVALUE &&
4136 BSLMF_TAG_TO_INT(checkConst(*myDeclval<t_ARG_TYPE>())),
4137 k_IS_VOLATILE = k_IS_LVALUE && BSLMF_TAG_TO_INT(checkVolatile(
4138 *myDeclval<t_ARG_TYPE>()))
4139 };
4140#endif // BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES
4141};
4142
4143#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
4144// {{{ BEGIN GENERATED CODE
4145// Command line: sim_cpp11_features.pl bslmf_invokeresult.h
4146#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT
4147#define BSLMF_INVOKERESULT_VARIADIC_LIMIT 13
4148#endif
4149#ifndef BSLMF_INVOKERESULT_VARIADIC_LIMIT_E
4150#define BSLMF_INVOKERESULT_VARIADIC_LIMIT_E BSLMF_INVOKERESULT_VARIADIC_LIMIT
4151#endif
4152
4153template <class t_VOID_TYPE,
4154 class t_FN
4155#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4156 , class t_ARGTYPES_0 = BSLS_COMPILERFEATURES_NILT
4157#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4158
4159#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4160 , class t_ARGTYPES_1 = BSLS_COMPILERFEATURES_NILT
4161#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4162
4163#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4164 , class t_ARGTYPES_2 = BSLS_COMPILERFEATURES_NILT
4165#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4166
4167#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4168 , class t_ARGTYPES_3 = BSLS_COMPILERFEATURES_NILT
4169#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4170
4171#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4172 , class t_ARGTYPES_4 = BSLS_COMPILERFEATURES_NILT
4173#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4174
4175#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4176 , class t_ARGTYPES_5 = BSLS_COMPILERFEATURES_NILT
4177#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4178
4179#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4180 , class t_ARGTYPES_6 = BSLS_COMPILERFEATURES_NILT
4181#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4182
4183#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4184 , class t_ARGTYPES_7 = BSLS_COMPILERFEATURES_NILT
4185#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4186
4187#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4188 , class t_ARGTYPES_8 = BSLS_COMPILERFEATURES_NILT
4189#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4190
4191#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4192 , class t_ARGTYPES_9 = BSLS_COMPILERFEATURES_NILT
4193#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4194
4195#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4196 , class t_ARGTYPES_10 = BSLS_COMPILERFEATURES_NILT
4197#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4198
4199#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4200 , class t_ARGTYPES_11 = BSLS_COMPILERFEATURES_NILT
4201#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4202
4203#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4204 , class t_ARGTYPES_12 = BSLS_COMPILERFEATURES_NILT
4205#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4206 , class = BSLS_COMPILERFEATURES_NILT>
4207struct InvokeResult_FunctorImp;
4208
4209
4210template <class t_VOID_TYPE,
4211 class t_FN
4212#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4213 , class t_ARGTYPES_0 = BSLS_COMPILERFEATURES_NILT
4214#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4215
4216#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4217 , class t_ARGTYPES_1 = BSLS_COMPILERFEATURES_NILT
4218#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4219
4220#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4221 , class t_ARGTYPES_2 = BSLS_COMPILERFEATURES_NILT
4222#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4223
4224#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4225 , class t_ARGTYPES_3 = BSLS_COMPILERFEATURES_NILT
4226#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4227
4228#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4229 , class t_ARGTYPES_4 = BSLS_COMPILERFEATURES_NILT
4230#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4231
4232#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4233 , class t_ARGTYPES_5 = BSLS_COMPILERFEATURES_NILT
4234#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4235
4236#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4237 , class t_ARGTYPES_6 = BSLS_COMPILERFEATURES_NILT
4238#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4239
4240#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4241 , class t_ARGTYPES_7 = BSLS_COMPILERFEATURES_NILT
4242#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4243
4244#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4245 , class t_ARGTYPES_8 = BSLS_COMPILERFEATURES_NILT
4246#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4247
4248#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4249 , class t_ARGTYPES_9 = BSLS_COMPILERFEATURES_NILT
4250#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4251
4252#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4253 , class t_ARGTYPES_10 = BSLS_COMPILERFEATURES_NILT
4254#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4255
4256#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4257 , class t_ARGTYPES_11 = BSLS_COMPILERFEATURES_NILT
4258#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4259
4260#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4261 , class t_ARGTYPES_12 = BSLS_COMPILERFEATURES_NILT
4262#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4263 , class = BSLS_COMPILERFEATURES_NILT>
4264struct InvokeResult_FuncPtrImp;
4265
4266
4267template <class t_FN
4268#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4269 , class t_ARGTYPES_0 = BSLS_COMPILERFEATURES_NILT
4270#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4271
4272#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4273 , class t_ARGTYPES_1 = BSLS_COMPILERFEATURES_NILT
4274#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4275
4276#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4277 , class t_ARGTYPES_2 = BSLS_COMPILERFEATURES_NILT
4278#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4279
4280#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4281 , class t_ARGTYPES_3 = BSLS_COMPILERFEATURES_NILT
4282#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4283
4284#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4285 , class t_ARGTYPES_4 = BSLS_COMPILERFEATURES_NILT
4286#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4287
4288#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4289 , class t_ARGTYPES_5 = BSLS_COMPILERFEATURES_NILT
4290#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4291
4292#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4293 , class t_ARGTYPES_6 = BSLS_COMPILERFEATURES_NILT
4294#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4295
4296#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4297 , class t_ARGTYPES_7 = BSLS_COMPILERFEATURES_NILT
4298#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4299
4300#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4301 , class t_ARGTYPES_8 = BSLS_COMPILERFEATURES_NILT
4302#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4303
4304#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4305 , class t_ARGTYPES_9 = BSLS_COMPILERFEATURES_NILT
4306#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4307
4308#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4309 , class t_ARGTYPES_10 = BSLS_COMPILERFEATURES_NILT
4310#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4311
4312#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4313 , class t_ARGTYPES_11 = BSLS_COMPILERFEATURES_NILT
4314#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4315
4316#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4317 , class t_ARGTYPES_12 = BSLS_COMPILERFEATURES_NILT
4318#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4319 , class = BSLS_COMPILERFEATURES_NILT>
4320struct InvokeResult_MemFuncPtrImp;
4321
4322
4323template <class t_FN
4324#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4325 , class t_ARGTYPES_0 = BSLS_COMPILERFEATURES_NILT
4326#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4327
4328#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4329 , class t_ARGTYPES_1 = BSLS_COMPILERFEATURES_NILT
4330#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4331
4332#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4333 , class t_ARGTYPES_2 = BSLS_COMPILERFEATURES_NILT
4334#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4335
4336#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4337 , class t_ARGTYPES_3 = BSLS_COMPILERFEATURES_NILT
4338#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4339
4340#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4341 , class t_ARGTYPES_4 = BSLS_COMPILERFEATURES_NILT
4342#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4343
4344#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4345 , class t_ARGTYPES_5 = BSLS_COMPILERFEATURES_NILT
4346#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4347
4348#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4349 , class t_ARGTYPES_6 = BSLS_COMPILERFEATURES_NILT
4350#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4351
4352#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4353 , class t_ARGTYPES_7 = BSLS_COMPILERFEATURES_NILT
4354#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4355
4356#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4357 , class t_ARGTYPES_8 = BSLS_COMPILERFEATURES_NILT
4358#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4359
4360#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4361 , class t_ARGTYPES_9 = BSLS_COMPILERFEATURES_NILT
4362#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4363
4364#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4365 , class t_ARGTYPES_10 = BSLS_COMPILERFEATURES_NILT
4366#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4367
4368#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4369 , class t_ARGTYPES_11 = BSLS_COMPILERFEATURES_NILT
4370#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4371
4372#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4373 , class t_ARGTYPES_12 = BSLS_COMPILERFEATURES_NILT
4374#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4375 , class = BSLS_COMPILERFEATURES_NILT>
4376struct InvokeResult_MemObjPtrImp;
4377
4378
4379
4380#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4381template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4382 class t_FN>
4383struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN
4384 > : InvokeResult_FunctorImp<void, t_FN> {
4385};
4386#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4387
4388#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4389template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4390 class t_FN, class t_ARGTYPES_01>
4391struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4392 t_ARGTYPES_01
4393 > : InvokeResult_FunctorImp<void, t_FN,
4394 t_ARGTYPES_01> {
4395};
4396#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4397
4398#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4399template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4400 class t_FN, class t_ARGTYPES_01,
4401 class t_ARGTYPES_02>
4402struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4403 t_ARGTYPES_01,
4404 t_ARGTYPES_02
4405 > : InvokeResult_FunctorImp<void, t_FN,
4406 t_ARGTYPES_01,
4407 t_ARGTYPES_02> {
4408};
4409#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4410
4411#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4412template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4413 class t_FN, class t_ARGTYPES_01,
4414 class t_ARGTYPES_02,
4415 class t_ARGTYPES_03>
4416struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4417 t_ARGTYPES_01,
4418 t_ARGTYPES_02,
4419 t_ARGTYPES_03
4420 > : InvokeResult_FunctorImp<void, t_FN,
4421 t_ARGTYPES_01,
4422 t_ARGTYPES_02,
4423 t_ARGTYPES_03> {
4424};
4425#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4426
4427#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4428template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4429 class t_FN, class t_ARGTYPES_01,
4430 class t_ARGTYPES_02,
4431 class t_ARGTYPES_03,
4432 class t_ARGTYPES_04>
4433struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4434 t_ARGTYPES_01,
4435 t_ARGTYPES_02,
4436 t_ARGTYPES_03,
4437 t_ARGTYPES_04
4438 > : InvokeResult_FunctorImp<void, t_FN,
4439 t_ARGTYPES_01,
4440 t_ARGTYPES_02,
4441 t_ARGTYPES_03,
4442 t_ARGTYPES_04> {
4443};
4444#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4445
4446#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4447template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4448 class t_FN, class t_ARGTYPES_01,
4449 class t_ARGTYPES_02,
4450 class t_ARGTYPES_03,
4451 class t_ARGTYPES_04,
4452 class t_ARGTYPES_05>
4453struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4454 t_ARGTYPES_01,
4455 t_ARGTYPES_02,
4456 t_ARGTYPES_03,
4457 t_ARGTYPES_04,
4458 t_ARGTYPES_05
4459 > : InvokeResult_FunctorImp<void, t_FN,
4460 t_ARGTYPES_01,
4461 t_ARGTYPES_02,
4462 t_ARGTYPES_03,
4463 t_ARGTYPES_04,
4464 t_ARGTYPES_05> {
4465};
4466#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4467
4468#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4469template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4470 class t_FN, class t_ARGTYPES_01,
4471 class t_ARGTYPES_02,
4472 class t_ARGTYPES_03,
4473 class t_ARGTYPES_04,
4474 class t_ARGTYPES_05,
4475 class t_ARGTYPES_06>
4476struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4477 t_ARGTYPES_01,
4478 t_ARGTYPES_02,
4479 t_ARGTYPES_03,
4480 t_ARGTYPES_04,
4481 t_ARGTYPES_05,
4482 t_ARGTYPES_06
4483 > : InvokeResult_FunctorImp<void, t_FN,
4484 t_ARGTYPES_01,
4485 t_ARGTYPES_02,
4486 t_ARGTYPES_03,
4487 t_ARGTYPES_04,
4488 t_ARGTYPES_05,
4489 t_ARGTYPES_06> {
4490};
4491#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4492
4493#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4494template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4495 class t_FN, class t_ARGTYPES_01,
4496 class t_ARGTYPES_02,
4497 class t_ARGTYPES_03,
4498 class t_ARGTYPES_04,
4499 class t_ARGTYPES_05,
4500 class t_ARGTYPES_06,
4501 class t_ARGTYPES_07>
4502struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4503 t_ARGTYPES_01,
4504 t_ARGTYPES_02,
4505 t_ARGTYPES_03,
4506 t_ARGTYPES_04,
4507 t_ARGTYPES_05,
4508 t_ARGTYPES_06,
4509 t_ARGTYPES_07
4510 > : InvokeResult_FunctorImp<void, t_FN,
4511 t_ARGTYPES_01,
4512 t_ARGTYPES_02,
4513 t_ARGTYPES_03,
4514 t_ARGTYPES_04,
4515 t_ARGTYPES_05,
4516 t_ARGTYPES_06,
4517 t_ARGTYPES_07> {
4518};
4519#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4520
4521#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4522template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4523 class t_FN, class t_ARGTYPES_01,
4524 class t_ARGTYPES_02,
4525 class t_ARGTYPES_03,
4526 class t_ARGTYPES_04,
4527 class t_ARGTYPES_05,
4528 class t_ARGTYPES_06,
4529 class t_ARGTYPES_07,
4530 class t_ARGTYPES_08>
4531struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4532 t_ARGTYPES_01,
4533 t_ARGTYPES_02,
4534 t_ARGTYPES_03,
4535 t_ARGTYPES_04,
4536 t_ARGTYPES_05,
4537 t_ARGTYPES_06,
4538 t_ARGTYPES_07,
4539 t_ARGTYPES_08
4540 > : InvokeResult_FunctorImp<void, t_FN,
4541 t_ARGTYPES_01,
4542 t_ARGTYPES_02,
4543 t_ARGTYPES_03,
4544 t_ARGTYPES_04,
4545 t_ARGTYPES_05,
4546 t_ARGTYPES_06,
4547 t_ARGTYPES_07,
4548 t_ARGTYPES_08> {
4549};
4550#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4551
4552#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4553template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4554 class t_FN, class t_ARGTYPES_01,
4555 class t_ARGTYPES_02,
4556 class t_ARGTYPES_03,
4557 class t_ARGTYPES_04,
4558 class t_ARGTYPES_05,
4559 class t_ARGTYPES_06,
4560 class t_ARGTYPES_07,
4561 class t_ARGTYPES_08,
4562 class t_ARGTYPES_09>
4563struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4564 t_ARGTYPES_01,
4565 t_ARGTYPES_02,
4566 t_ARGTYPES_03,
4567 t_ARGTYPES_04,
4568 t_ARGTYPES_05,
4569 t_ARGTYPES_06,
4570 t_ARGTYPES_07,
4571 t_ARGTYPES_08,
4572 t_ARGTYPES_09
4573 > : InvokeResult_FunctorImp<void, t_FN,
4574 t_ARGTYPES_01,
4575 t_ARGTYPES_02,
4576 t_ARGTYPES_03,
4577 t_ARGTYPES_04,
4578 t_ARGTYPES_05,
4579 t_ARGTYPES_06,
4580 t_ARGTYPES_07,
4581 t_ARGTYPES_08,
4582 t_ARGTYPES_09> {
4583};
4584#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4585
4586#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4587template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4588 class t_FN, class t_ARGTYPES_01,
4589 class t_ARGTYPES_02,
4590 class t_ARGTYPES_03,
4591 class t_ARGTYPES_04,
4592 class t_ARGTYPES_05,
4593 class t_ARGTYPES_06,
4594 class t_ARGTYPES_07,
4595 class t_ARGTYPES_08,
4596 class t_ARGTYPES_09,
4597 class t_ARGTYPES_10>
4598struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4599 t_ARGTYPES_01,
4600 t_ARGTYPES_02,
4601 t_ARGTYPES_03,
4602 t_ARGTYPES_04,
4603 t_ARGTYPES_05,
4604 t_ARGTYPES_06,
4605 t_ARGTYPES_07,
4606 t_ARGTYPES_08,
4607 t_ARGTYPES_09,
4608 t_ARGTYPES_10
4609 > : InvokeResult_FunctorImp<void, t_FN,
4610 t_ARGTYPES_01,
4611 t_ARGTYPES_02,
4612 t_ARGTYPES_03,
4613 t_ARGTYPES_04,
4614 t_ARGTYPES_05,
4615 t_ARGTYPES_06,
4616 t_ARGTYPES_07,
4617 t_ARGTYPES_08,
4618 t_ARGTYPES_09,
4619 t_ARGTYPES_10> {
4620};
4621#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4622
4623#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4624template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4625 class t_FN, class t_ARGTYPES_01,
4626 class t_ARGTYPES_02,
4627 class t_ARGTYPES_03,
4628 class t_ARGTYPES_04,
4629 class t_ARGTYPES_05,
4630 class t_ARGTYPES_06,
4631 class t_ARGTYPES_07,
4632 class t_ARGTYPES_08,
4633 class t_ARGTYPES_09,
4634 class t_ARGTYPES_10,
4635 class t_ARGTYPES_11>
4636struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4637 t_ARGTYPES_01,
4638 t_ARGTYPES_02,
4639 t_ARGTYPES_03,
4640 t_ARGTYPES_04,
4641 t_ARGTYPES_05,
4642 t_ARGTYPES_06,
4643 t_ARGTYPES_07,
4644 t_ARGTYPES_08,
4645 t_ARGTYPES_09,
4646 t_ARGTYPES_10,
4647 t_ARGTYPES_11
4648 > : InvokeResult_FunctorImp<void, t_FN,
4649 t_ARGTYPES_01,
4650 t_ARGTYPES_02,
4651 t_ARGTYPES_03,
4652 t_ARGTYPES_04,
4653 t_ARGTYPES_05,
4654 t_ARGTYPES_06,
4655 t_ARGTYPES_07,
4656 t_ARGTYPES_08,
4657 t_ARGTYPES_09,
4658 t_ARGTYPES_10,
4659 t_ARGTYPES_11> {
4660};
4661#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
4662
4663#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4664template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4665 class t_FN, class t_ARGTYPES_01,
4666 class t_ARGTYPES_02,
4667 class t_ARGTYPES_03,
4668 class t_ARGTYPES_04,
4669 class t_ARGTYPES_05,
4670 class t_ARGTYPES_06,
4671 class t_ARGTYPES_07,
4672 class t_ARGTYPES_08,
4673 class t_ARGTYPES_09,
4674 class t_ARGTYPES_10,
4675 class t_ARGTYPES_11,
4676 class t_ARGTYPES_12>
4677struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4678 t_ARGTYPES_01,
4679 t_ARGTYPES_02,
4680 t_ARGTYPES_03,
4681 t_ARGTYPES_04,
4682 t_ARGTYPES_05,
4683 t_ARGTYPES_06,
4684 t_ARGTYPES_07,
4685 t_ARGTYPES_08,
4686 t_ARGTYPES_09,
4687 t_ARGTYPES_10,
4688 t_ARGTYPES_11,
4689 t_ARGTYPES_12
4690 > : InvokeResult_FunctorImp<void, t_FN,
4691 t_ARGTYPES_01,
4692 t_ARGTYPES_02,
4693 t_ARGTYPES_03,
4694 t_ARGTYPES_04,
4695 t_ARGTYPES_05,
4696 t_ARGTYPES_06,
4697 t_ARGTYPES_07,
4698 t_ARGTYPES_08,
4699 t_ARGTYPES_09,
4700 t_ARGTYPES_10,
4701 t_ARGTYPES_11,
4702 t_ARGTYPES_12> {
4703};
4704#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
4705
4706#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
4707template <bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR,
4708 class t_FN, class t_ARGTYPES_01,
4709 class t_ARGTYPES_02,
4710 class t_ARGTYPES_03,
4711 class t_ARGTYPES_04,
4712 class t_ARGTYPES_05,
4713 class t_ARGTYPES_06,
4714 class t_ARGTYPES_07,
4715 class t_ARGTYPES_08,
4716 class t_ARGTYPES_09,
4717 class t_ARGTYPES_10,
4718 class t_ARGTYPES_11,
4719 class t_ARGTYPES_12,
4720 class t_ARGTYPES_13>
4721struct InvokeResult_Imp<t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN,
4722 t_ARGTYPES_01,
4723 t_ARGTYPES_02,
4724 t_ARGTYPES_03,
4725 t_ARGTYPES_04,
4726 t_ARGTYPES_05,
4727 t_ARGTYPES_06,
4728 t_ARGTYPES_07,
4729 t_ARGTYPES_08,
4730 t_ARGTYPES_09,
4731 t_ARGTYPES_10,
4732 t_ARGTYPES_11,
4733 t_ARGTYPES_12,
4734 t_ARGTYPES_13
4735 > : InvokeResult_FunctorImp<void, t_FN,
4736 t_ARGTYPES_01,
4737 t_ARGTYPES_02,
4738 t_ARGTYPES_03,
4739 t_ARGTYPES_04,
4740 t_ARGTYPES_05,
4741 t_ARGTYPES_06,
4742 t_ARGTYPES_07,
4743 t_ARGTYPES_08,
4744 t_ARGTYPES_09,
4745 t_ARGTYPES_10,
4746 t_ARGTYPES_11,
4747 t_ARGTYPES_12,
4748 t_ARGTYPES_13> {
4749};
4750#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
4751
4752
4753#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4754template <class t_FN>
4755struct InvokeResult_Imp<true ,
4756 false,
4757 false,
4758 t_FN>
4759: InvokeResult_FuncPtrImp<void, t_FN> {
4760};
4761#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
4762
4763#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4764template <class t_FN, class t_ARGTYPES_01>
4765struct InvokeResult_Imp<true ,
4766 false,
4767 false,
4768 t_FN,
4769 t_ARGTYPES_01>
4770: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01> {
4771};
4772#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
4773
4774#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4775template <class t_FN, class t_ARGTYPES_01,
4776 class t_ARGTYPES_02>
4777struct InvokeResult_Imp<true ,
4778 false,
4779 false,
4780 t_FN,
4781 t_ARGTYPES_01,
4782 t_ARGTYPES_02>
4783: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
4784 t_ARGTYPES_02> {
4785};
4786#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
4787
4788#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4789template <class t_FN, class t_ARGTYPES_01,
4790 class t_ARGTYPES_02,
4791 class t_ARGTYPES_03>
4792struct InvokeResult_Imp<true ,
4793 false,
4794 false,
4795 t_FN,
4796 t_ARGTYPES_01,
4797 t_ARGTYPES_02,
4798 t_ARGTYPES_03>
4799: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
4800 t_ARGTYPES_02,
4801 t_ARGTYPES_03> {
4802};
4803#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
4804
4805#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4806template <class t_FN, class t_ARGTYPES_01,
4807 class t_ARGTYPES_02,
4808 class t_ARGTYPES_03,
4809 class t_ARGTYPES_04>
4810struct InvokeResult_Imp<true ,
4811 false,
4812 false,
4813 t_FN,
4814 t_ARGTYPES_01,
4815 t_ARGTYPES_02,
4816 t_ARGTYPES_03,
4817 t_ARGTYPES_04>
4818: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
4819 t_ARGTYPES_02,
4820 t_ARGTYPES_03,
4821 t_ARGTYPES_04> {
4822};
4823#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
4824
4825#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4826template <class t_FN, class t_ARGTYPES_01,
4827 class t_ARGTYPES_02,
4828 class t_ARGTYPES_03,
4829 class t_ARGTYPES_04,
4830 class t_ARGTYPES_05>
4831struct InvokeResult_Imp<true ,
4832 false,
4833 false,
4834 t_FN,
4835 t_ARGTYPES_01,
4836 t_ARGTYPES_02,
4837 t_ARGTYPES_03,
4838 t_ARGTYPES_04,
4839 t_ARGTYPES_05>
4840: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
4841 t_ARGTYPES_02,
4842 t_ARGTYPES_03,
4843 t_ARGTYPES_04,
4844 t_ARGTYPES_05> {
4845};
4846#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
4847
4848#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4849template <class t_FN, class t_ARGTYPES_01,
4850 class t_ARGTYPES_02,
4851 class t_ARGTYPES_03,
4852 class t_ARGTYPES_04,
4853 class t_ARGTYPES_05,
4854 class t_ARGTYPES_06>
4855struct InvokeResult_Imp<true ,
4856 false,
4857 false,
4858 t_FN,
4859 t_ARGTYPES_01,
4860 t_ARGTYPES_02,
4861 t_ARGTYPES_03,
4862 t_ARGTYPES_04,
4863 t_ARGTYPES_05,
4864 t_ARGTYPES_06>
4865: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
4866 t_ARGTYPES_02,
4867 t_ARGTYPES_03,
4868 t_ARGTYPES_04,
4869 t_ARGTYPES_05,
4870 t_ARGTYPES_06> {
4871};
4872#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
4873
4874#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4875template <class t_FN, class t_ARGTYPES_01,
4876 class t_ARGTYPES_02,
4877 class t_ARGTYPES_03,
4878 class t_ARGTYPES_04,
4879 class t_ARGTYPES_05,
4880 class t_ARGTYPES_06,
4881 class t_ARGTYPES_07>
4882struct InvokeResult_Imp<true ,
4883 false,
4884 false,
4885 t_FN,
4886 t_ARGTYPES_01,
4887 t_ARGTYPES_02,
4888 t_ARGTYPES_03,
4889 t_ARGTYPES_04,
4890 t_ARGTYPES_05,
4891 t_ARGTYPES_06,
4892 t_ARGTYPES_07>
4893: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
4894 t_ARGTYPES_02,
4895 t_ARGTYPES_03,
4896 t_ARGTYPES_04,
4897 t_ARGTYPES_05,
4898 t_ARGTYPES_06,
4899 t_ARGTYPES_07> {
4900};
4901#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
4902
4903#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4904template <class t_FN, class t_ARGTYPES_01,
4905 class t_ARGTYPES_02,
4906 class t_ARGTYPES_03,
4907 class t_ARGTYPES_04,
4908 class t_ARGTYPES_05,
4909 class t_ARGTYPES_06,
4910 class t_ARGTYPES_07,
4911 class t_ARGTYPES_08>
4912struct InvokeResult_Imp<true ,
4913 false,
4914 false,
4915 t_FN,
4916 t_ARGTYPES_01,
4917 t_ARGTYPES_02,
4918 t_ARGTYPES_03,
4919 t_ARGTYPES_04,
4920 t_ARGTYPES_05,
4921 t_ARGTYPES_06,
4922 t_ARGTYPES_07,
4923 t_ARGTYPES_08>
4924: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
4925 t_ARGTYPES_02,
4926 t_ARGTYPES_03,
4927 t_ARGTYPES_04,
4928 t_ARGTYPES_05,
4929 t_ARGTYPES_06,
4930 t_ARGTYPES_07,
4931 t_ARGTYPES_08> {
4932};
4933#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
4934
4935#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4936template <class t_FN, class t_ARGTYPES_01,
4937 class t_ARGTYPES_02,
4938 class t_ARGTYPES_03,
4939 class t_ARGTYPES_04,
4940 class t_ARGTYPES_05,
4941 class t_ARGTYPES_06,
4942 class t_ARGTYPES_07,
4943 class t_ARGTYPES_08,
4944 class t_ARGTYPES_09>
4945struct InvokeResult_Imp<true ,
4946 false,
4947 false,
4948 t_FN,
4949 t_ARGTYPES_01,
4950 t_ARGTYPES_02,
4951 t_ARGTYPES_03,
4952 t_ARGTYPES_04,
4953 t_ARGTYPES_05,
4954 t_ARGTYPES_06,
4955 t_ARGTYPES_07,
4956 t_ARGTYPES_08,
4957 t_ARGTYPES_09>
4958: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
4959 t_ARGTYPES_02,
4960 t_ARGTYPES_03,
4961 t_ARGTYPES_04,
4962 t_ARGTYPES_05,
4963 t_ARGTYPES_06,
4964 t_ARGTYPES_07,
4965 t_ARGTYPES_08,
4966 t_ARGTYPES_09> {
4967};
4968#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
4969
4970#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
4971template <class t_FN, class t_ARGTYPES_01,
4972 class t_ARGTYPES_02,
4973 class t_ARGTYPES_03,
4974 class t_ARGTYPES_04,
4975 class t_ARGTYPES_05,
4976 class t_ARGTYPES_06,
4977 class t_ARGTYPES_07,
4978 class t_ARGTYPES_08,
4979 class t_ARGTYPES_09,
4980 class t_ARGTYPES_10>
4981struct InvokeResult_Imp<true ,
4982 false,
4983 false,
4984 t_FN,
4985 t_ARGTYPES_01,
4986 t_ARGTYPES_02,
4987 t_ARGTYPES_03,
4988 t_ARGTYPES_04,
4989 t_ARGTYPES_05,
4990 t_ARGTYPES_06,
4991 t_ARGTYPES_07,
4992 t_ARGTYPES_08,
4993 t_ARGTYPES_09,
4994 t_ARGTYPES_10>
4995: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
4996 t_ARGTYPES_02,
4997 t_ARGTYPES_03,
4998 t_ARGTYPES_04,
4999 t_ARGTYPES_05,
5000 t_ARGTYPES_06,
5001 t_ARGTYPES_07,
5002 t_ARGTYPES_08,
5003 t_ARGTYPES_09,
5004 t_ARGTYPES_10> {
5005};
5006#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
5007
5008#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
5009template <class t_FN, class t_ARGTYPES_01,
5010 class t_ARGTYPES_02,
5011 class t_ARGTYPES_03,
5012 class t_ARGTYPES_04,
5013 class t_ARGTYPES_05,
5014 class t_ARGTYPES_06,
5015 class t_ARGTYPES_07,
5016 class t_ARGTYPES_08,
5017 class t_ARGTYPES_09,
5018 class t_ARGTYPES_10,
5019 class t_ARGTYPES_11>
5020struct InvokeResult_Imp<true ,
5021 false,
5022 false,
5023 t_FN,
5024 t_ARGTYPES_01,
5025 t_ARGTYPES_02,
5026 t_ARGTYPES_03,
5027 t_ARGTYPES_04,
5028 t_ARGTYPES_05,
5029 t_ARGTYPES_06,
5030 t_ARGTYPES_07,
5031 t_ARGTYPES_08,
5032 t_ARGTYPES_09,
5033 t_ARGTYPES_10,
5034 t_ARGTYPES_11>
5035: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
5036 t_ARGTYPES_02,
5037 t_ARGTYPES_03,
5038 t_ARGTYPES_04,
5039 t_ARGTYPES_05,
5040 t_ARGTYPES_06,
5041 t_ARGTYPES_07,
5042 t_ARGTYPES_08,
5043 t_ARGTYPES_09,
5044 t_ARGTYPES_10,
5045 t_ARGTYPES_11> {
5046};
5047#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
5048
5049#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
5050template <class t_FN, class t_ARGTYPES_01,
5051 class t_ARGTYPES_02,
5052 class t_ARGTYPES_03,
5053 class t_ARGTYPES_04,
5054 class t_ARGTYPES_05,
5055 class t_ARGTYPES_06,
5056 class t_ARGTYPES_07,
5057 class t_ARGTYPES_08,
5058 class t_ARGTYPES_09,
5059 class t_ARGTYPES_10,
5060 class t_ARGTYPES_11,
5061 class t_ARGTYPES_12>
5062struct InvokeResult_Imp<true ,
5063 false,
5064 false,
5065 t_FN,
5066 t_ARGTYPES_01,
5067 t_ARGTYPES_02,
5068 t_ARGTYPES_03,
5069 t_ARGTYPES_04,
5070 t_ARGTYPES_05,
5071 t_ARGTYPES_06,
5072 t_ARGTYPES_07,
5073 t_ARGTYPES_08,
5074 t_ARGTYPES_09,
5075 t_ARGTYPES_10,
5076 t_ARGTYPES_11,
5077 t_ARGTYPES_12>
5078: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
5079 t_ARGTYPES_02,
5080 t_ARGTYPES_03,
5081 t_ARGTYPES_04,
5082 t_ARGTYPES_05,
5083 t_ARGTYPES_06,
5084 t_ARGTYPES_07,
5085 t_ARGTYPES_08,
5086 t_ARGTYPES_09,
5087 t_ARGTYPES_10,
5088 t_ARGTYPES_11,
5089 t_ARGTYPES_12> {
5090};
5091#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
5092
5093#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
5094template <class t_FN, class t_ARGTYPES_01,
5095 class t_ARGTYPES_02,
5096 class t_ARGTYPES_03,
5097 class t_ARGTYPES_04,
5098 class t_ARGTYPES_05,
5099 class t_ARGTYPES_06,
5100 class t_ARGTYPES_07,
5101 class t_ARGTYPES_08,
5102 class t_ARGTYPES_09,
5103 class t_ARGTYPES_10,
5104 class t_ARGTYPES_11,
5105 class t_ARGTYPES_12,
5106 class t_ARGTYPES_13>
5107struct InvokeResult_Imp<true ,
5108 false,
5109 false,
5110 t_FN,
5111 t_ARGTYPES_01,
5112 t_ARGTYPES_02,
5113 t_ARGTYPES_03,
5114 t_ARGTYPES_04,
5115 t_ARGTYPES_05,
5116 t_ARGTYPES_06,
5117 t_ARGTYPES_07,
5118 t_ARGTYPES_08,
5119 t_ARGTYPES_09,
5120 t_ARGTYPES_10,
5121 t_ARGTYPES_11,
5122 t_ARGTYPES_12,
5123 t_ARGTYPES_13>
5124: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES_01,
5125 t_ARGTYPES_02,
5126 t_ARGTYPES_03,
5127 t_ARGTYPES_04,
5128 t_ARGTYPES_05,
5129 t_ARGTYPES_06,
5130 t_ARGTYPES_07,
5131 t_ARGTYPES_08,
5132 t_ARGTYPES_09,
5133 t_ARGTYPES_10,
5134 t_ARGTYPES_11,
5135 t_ARGTYPES_12,
5136 t_ARGTYPES_13> {
5137};
5138#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
5139
5140
5141#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
5142template <class t_FN>
5143struct InvokeResult_Imp<false,
5144 true ,
5145 false,
5146 t_FN>
5147: InvokeResult_MemFuncPtrImp<t_FN> {
5148};
5149#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
5150
5151#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
5152template <class t_FN, class t_ARGTYPES_01>
5153struct InvokeResult_Imp<false,
5154 true ,
5155 false,
5156 t_FN,
5157 t_ARGTYPES_01>
5158: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01> {
5159};
5160#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
5161
5162#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
5163template <class t_FN, class t_ARGTYPES_01,
5164 class t_ARGTYPES_02>
5165struct InvokeResult_Imp<false,
5166 true ,
5167 false,
5168 t_FN,
5169 t_ARGTYPES_01,
5170 t_ARGTYPES_02>
5171: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5172 t_ARGTYPES_02> {
5173};
5174#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
5175
5176#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
5177template <class t_FN, class t_ARGTYPES_01,
5178 class t_ARGTYPES_02,
5179 class t_ARGTYPES_03>
5180struct InvokeResult_Imp<false,
5181 true ,
5182 false,
5183 t_FN,
5184 t_ARGTYPES_01,
5185 t_ARGTYPES_02,
5186 t_ARGTYPES_03>
5187: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5188 t_ARGTYPES_02,
5189 t_ARGTYPES_03> {
5190};
5191#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
5192
5193#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
5194template <class t_FN, class t_ARGTYPES_01,
5195 class t_ARGTYPES_02,
5196 class t_ARGTYPES_03,
5197 class t_ARGTYPES_04>
5198struct InvokeResult_Imp<false,
5199 true ,
5200 false,
5201 t_FN,
5202 t_ARGTYPES_01,
5203 t_ARGTYPES_02,
5204 t_ARGTYPES_03,
5205 t_ARGTYPES_04>
5206: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5207 t_ARGTYPES_02,
5208 t_ARGTYPES_03,
5209 t_ARGTYPES_04> {
5210};
5211#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
5212
5213#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
5214template <class t_FN, class t_ARGTYPES_01,
5215 class t_ARGTYPES_02,
5216 class t_ARGTYPES_03,
5217 class t_ARGTYPES_04,
5218 class t_ARGTYPES_05>
5219struct InvokeResult_Imp<false,
5220 true ,
5221 false,
5222 t_FN,
5223 t_ARGTYPES_01,
5224 t_ARGTYPES_02,
5225 t_ARGTYPES_03,
5226 t_ARGTYPES_04,
5227 t_ARGTYPES_05>
5228: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5229 t_ARGTYPES_02,
5230 t_ARGTYPES_03,
5231 t_ARGTYPES_04,
5232 t_ARGTYPES_05> {
5233};
5234#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
5235
5236#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
5237template <class t_FN, class t_ARGTYPES_01,
5238 class t_ARGTYPES_02,
5239 class t_ARGTYPES_03,
5240 class t_ARGTYPES_04,
5241 class t_ARGTYPES_05,
5242 class t_ARGTYPES_06>
5243struct InvokeResult_Imp<false,
5244 true ,
5245 false,
5246 t_FN,
5247 t_ARGTYPES_01,
5248 t_ARGTYPES_02,
5249 t_ARGTYPES_03,
5250 t_ARGTYPES_04,
5251 t_ARGTYPES_05,
5252 t_ARGTYPES_06>
5253: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5254 t_ARGTYPES_02,
5255 t_ARGTYPES_03,
5256 t_ARGTYPES_04,
5257 t_ARGTYPES_05,
5258 t_ARGTYPES_06> {
5259};
5260#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
5261
5262#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
5263template <class t_FN, class t_ARGTYPES_01,
5264 class t_ARGTYPES_02,
5265 class t_ARGTYPES_03,
5266 class t_ARGTYPES_04,
5267 class t_ARGTYPES_05,
5268 class t_ARGTYPES_06,
5269 class t_ARGTYPES_07>
5270struct InvokeResult_Imp<false,
5271 true ,
5272 false,
5273 t_FN,
5274 t_ARGTYPES_01,
5275 t_ARGTYPES_02,
5276 t_ARGTYPES_03,
5277 t_ARGTYPES_04,
5278 t_ARGTYPES_05,
5279 t_ARGTYPES_06,
5280 t_ARGTYPES_07>
5281: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5282 t_ARGTYPES_02,
5283 t_ARGTYPES_03,
5284 t_ARGTYPES_04,
5285 t_ARGTYPES_05,
5286 t_ARGTYPES_06,
5287 t_ARGTYPES_07> {
5288};
5289#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
5290
5291#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
5292template <class t_FN, class t_ARGTYPES_01,
5293 class t_ARGTYPES_02,
5294 class t_ARGTYPES_03,
5295 class t_ARGTYPES_04,
5296 class t_ARGTYPES_05,
5297 class t_ARGTYPES_06,
5298 class t_ARGTYPES_07,
5299 class t_ARGTYPES_08>
5300struct InvokeResult_Imp<false,
5301 true ,
5302 false,
5303 t_FN,
5304 t_ARGTYPES_01,
5305 t_ARGTYPES_02,
5306 t_ARGTYPES_03,
5307 t_ARGTYPES_04,
5308 t_ARGTYPES_05,
5309 t_ARGTYPES_06,
5310 t_ARGTYPES_07,
5311 t_ARGTYPES_08>
5312: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5313 t_ARGTYPES_02,
5314 t_ARGTYPES_03,
5315 t_ARGTYPES_04,
5316 t_ARGTYPES_05,
5317 t_ARGTYPES_06,
5318 t_ARGTYPES_07,
5319 t_ARGTYPES_08> {
5320};
5321#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
5322
5323#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
5324template <class t_FN, class t_ARGTYPES_01,
5325 class t_ARGTYPES_02,
5326 class t_ARGTYPES_03,
5327 class t_ARGTYPES_04,
5328 class t_ARGTYPES_05,
5329 class t_ARGTYPES_06,
5330 class t_ARGTYPES_07,
5331 class t_ARGTYPES_08,
5332 class t_ARGTYPES_09>
5333struct InvokeResult_Imp<false,
5334 true ,
5335 false,
5336 t_FN,
5337 t_ARGTYPES_01,
5338 t_ARGTYPES_02,
5339 t_ARGTYPES_03,
5340 t_ARGTYPES_04,
5341 t_ARGTYPES_05,
5342 t_ARGTYPES_06,
5343 t_ARGTYPES_07,
5344 t_ARGTYPES_08,
5345 t_ARGTYPES_09>
5346: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5347 t_ARGTYPES_02,
5348 t_ARGTYPES_03,
5349 t_ARGTYPES_04,
5350 t_ARGTYPES_05,
5351 t_ARGTYPES_06,
5352 t_ARGTYPES_07,
5353 t_ARGTYPES_08,
5354 t_ARGTYPES_09> {
5355};
5356#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
5357
5358#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
5359template <class t_FN, class t_ARGTYPES_01,
5360 class t_ARGTYPES_02,
5361 class t_ARGTYPES_03,
5362 class t_ARGTYPES_04,
5363 class t_ARGTYPES_05,
5364 class t_ARGTYPES_06,
5365 class t_ARGTYPES_07,
5366 class t_ARGTYPES_08,
5367 class t_ARGTYPES_09,
5368 class t_ARGTYPES_10>
5369struct InvokeResult_Imp<false,
5370 true ,
5371 false,
5372 t_FN,
5373 t_ARGTYPES_01,
5374 t_ARGTYPES_02,
5375 t_ARGTYPES_03,
5376 t_ARGTYPES_04,
5377 t_ARGTYPES_05,
5378 t_ARGTYPES_06,
5379 t_ARGTYPES_07,
5380 t_ARGTYPES_08,
5381 t_ARGTYPES_09,
5382 t_ARGTYPES_10>
5383: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5384 t_ARGTYPES_02,
5385 t_ARGTYPES_03,
5386 t_ARGTYPES_04,
5387 t_ARGTYPES_05,
5388 t_ARGTYPES_06,
5389 t_ARGTYPES_07,
5390 t_ARGTYPES_08,
5391 t_ARGTYPES_09,
5392 t_ARGTYPES_10> {
5393};
5394#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
5395
5396#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
5397template <class t_FN, class t_ARGTYPES_01,
5398 class t_ARGTYPES_02,
5399 class t_ARGTYPES_03,
5400 class t_ARGTYPES_04,
5401 class t_ARGTYPES_05,
5402 class t_ARGTYPES_06,
5403 class t_ARGTYPES_07,
5404 class t_ARGTYPES_08,
5405 class t_ARGTYPES_09,
5406 class t_ARGTYPES_10,
5407 class t_ARGTYPES_11>
5408struct InvokeResult_Imp<false,
5409 true ,
5410 false,
5411 t_FN,
5412 t_ARGTYPES_01,
5413 t_ARGTYPES_02,
5414 t_ARGTYPES_03,
5415 t_ARGTYPES_04,
5416 t_ARGTYPES_05,
5417 t_ARGTYPES_06,
5418 t_ARGTYPES_07,
5419 t_ARGTYPES_08,
5420 t_ARGTYPES_09,
5421 t_ARGTYPES_10,
5422 t_ARGTYPES_11>
5423: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5424 t_ARGTYPES_02,
5425 t_ARGTYPES_03,
5426 t_ARGTYPES_04,
5427 t_ARGTYPES_05,
5428 t_ARGTYPES_06,
5429 t_ARGTYPES_07,
5430 t_ARGTYPES_08,
5431 t_ARGTYPES_09,
5432 t_ARGTYPES_10,
5433 t_ARGTYPES_11> {
5434};
5435#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
5436
5437#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
5438template <class t_FN, class t_ARGTYPES_01,
5439 class t_ARGTYPES_02,
5440 class t_ARGTYPES_03,
5441 class t_ARGTYPES_04,
5442 class t_ARGTYPES_05,
5443 class t_ARGTYPES_06,
5444 class t_ARGTYPES_07,
5445 class t_ARGTYPES_08,
5446 class t_ARGTYPES_09,
5447 class t_ARGTYPES_10,
5448 class t_ARGTYPES_11,
5449 class t_ARGTYPES_12>
5450struct InvokeResult_Imp<false,
5451 true ,
5452 false,
5453 t_FN,
5454 t_ARGTYPES_01,
5455 t_ARGTYPES_02,
5456 t_ARGTYPES_03,
5457 t_ARGTYPES_04,
5458 t_ARGTYPES_05,
5459 t_ARGTYPES_06,
5460 t_ARGTYPES_07,
5461 t_ARGTYPES_08,
5462 t_ARGTYPES_09,
5463 t_ARGTYPES_10,
5464 t_ARGTYPES_11,
5465 t_ARGTYPES_12>
5466: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5467 t_ARGTYPES_02,
5468 t_ARGTYPES_03,
5469 t_ARGTYPES_04,
5470 t_ARGTYPES_05,
5471 t_ARGTYPES_06,
5472 t_ARGTYPES_07,
5473 t_ARGTYPES_08,
5474 t_ARGTYPES_09,
5475 t_ARGTYPES_10,
5476 t_ARGTYPES_11,
5477 t_ARGTYPES_12> {
5478};
5479#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
5480
5481#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
5482template <class t_FN, class t_ARGTYPES_01,
5483 class t_ARGTYPES_02,
5484 class t_ARGTYPES_03,
5485 class t_ARGTYPES_04,
5486 class t_ARGTYPES_05,
5487 class t_ARGTYPES_06,
5488 class t_ARGTYPES_07,
5489 class t_ARGTYPES_08,
5490 class t_ARGTYPES_09,
5491 class t_ARGTYPES_10,
5492 class t_ARGTYPES_11,
5493 class t_ARGTYPES_12,
5494 class t_ARGTYPES_13>
5495struct InvokeResult_Imp<false,
5496 true ,
5497 false,
5498 t_FN,
5499 t_ARGTYPES_01,
5500 t_ARGTYPES_02,
5501 t_ARGTYPES_03,
5502 t_ARGTYPES_04,
5503 t_ARGTYPES_05,
5504 t_ARGTYPES_06,
5505 t_ARGTYPES_07,
5506 t_ARGTYPES_08,
5507 t_ARGTYPES_09,
5508 t_ARGTYPES_10,
5509 t_ARGTYPES_11,
5510 t_ARGTYPES_12,
5511 t_ARGTYPES_13>
5512: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
5513 t_ARGTYPES_02,
5514 t_ARGTYPES_03,
5515 t_ARGTYPES_04,
5516 t_ARGTYPES_05,
5517 t_ARGTYPES_06,
5518 t_ARGTYPES_07,
5519 t_ARGTYPES_08,
5520 t_ARGTYPES_09,
5521 t_ARGTYPES_10,
5522 t_ARGTYPES_11,
5523 t_ARGTYPES_12,
5524 t_ARGTYPES_13> {
5525};
5526#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
5527
5528
5529#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
5530template <class t_FN>
5531struct InvokeResult_Imp<false,
5532 false,
5533 true ,
5534 t_FN>
5535: InvokeResult_MemObjPtrImp<t_FN> {
5536};
5537#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
5538
5539#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
5540template <class t_FN, class t_ARGTYPES_01>
5541struct InvokeResult_Imp<false,
5542 false,
5543 true ,
5544 t_FN,
5545 t_ARGTYPES_01>
5546: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01> {
5547};
5548#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
5549
5550#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
5551template <class t_FN, class t_ARGTYPES_01,
5552 class t_ARGTYPES_02>
5553struct InvokeResult_Imp<false,
5554 false,
5555 true ,
5556 t_FN,
5557 t_ARGTYPES_01,
5558 t_ARGTYPES_02>
5559: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5560 t_ARGTYPES_02> {
5561};
5562#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
5563
5564#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
5565template <class t_FN, class t_ARGTYPES_01,
5566 class t_ARGTYPES_02,
5567 class t_ARGTYPES_03>
5568struct InvokeResult_Imp<false,
5569 false,
5570 true ,
5571 t_FN,
5572 t_ARGTYPES_01,
5573 t_ARGTYPES_02,
5574 t_ARGTYPES_03>
5575: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5576 t_ARGTYPES_02,
5577 t_ARGTYPES_03> {
5578};
5579#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
5580
5581#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
5582template <class t_FN, class t_ARGTYPES_01,
5583 class t_ARGTYPES_02,
5584 class t_ARGTYPES_03,
5585 class t_ARGTYPES_04>
5586struct InvokeResult_Imp<false,
5587 false,
5588 true ,
5589 t_FN,
5590 t_ARGTYPES_01,
5591 t_ARGTYPES_02,
5592 t_ARGTYPES_03,
5593 t_ARGTYPES_04>
5594: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5595 t_ARGTYPES_02,
5596 t_ARGTYPES_03,
5597 t_ARGTYPES_04> {
5598};
5599#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
5600
5601#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
5602template <class t_FN, class t_ARGTYPES_01,
5603 class t_ARGTYPES_02,
5604 class t_ARGTYPES_03,
5605 class t_ARGTYPES_04,
5606 class t_ARGTYPES_05>
5607struct InvokeResult_Imp<false,
5608 false,
5609 true ,
5610 t_FN,
5611 t_ARGTYPES_01,
5612 t_ARGTYPES_02,
5613 t_ARGTYPES_03,
5614 t_ARGTYPES_04,
5615 t_ARGTYPES_05>
5616: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5617 t_ARGTYPES_02,
5618 t_ARGTYPES_03,
5619 t_ARGTYPES_04,
5620 t_ARGTYPES_05> {
5621};
5622#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
5623
5624#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
5625template <class t_FN, class t_ARGTYPES_01,
5626 class t_ARGTYPES_02,
5627 class t_ARGTYPES_03,
5628 class t_ARGTYPES_04,
5629 class t_ARGTYPES_05,
5630 class t_ARGTYPES_06>
5631struct InvokeResult_Imp<false,
5632 false,
5633 true ,
5634 t_FN,
5635 t_ARGTYPES_01,
5636 t_ARGTYPES_02,
5637 t_ARGTYPES_03,
5638 t_ARGTYPES_04,
5639 t_ARGTYPES_05,
5640 t_ARGTYPES_06>
5641: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5642 t_ARGTYPES_02,
5643 t_ARGTYPES_03,
5644 t_ARGTYPES_04,
5645 t_ARGTYPES_05,
5646 t_ARGTYPES_06> {
5647};
5648#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
5649
5650#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
5651template <class t_FN, class t_ARGTYPES_01,
5652 class t_ARGTYPES_02,
5653 class t_ARGTYPES_03,
5654 class t_ARGTYPES_04,
5655 class t_ARGTYPES_05,
5656 class t_ARGTYPES_06,
5657 class t_ARGTYPES_07>
5658struct InvokeResult_Imp<false,
5659 false,
5660 true ,
5661 t_FN,
5662 t_ARGTYPES_01,
5663 t_ARGTYPES_02,
5664 t_ARGTYPES_03,
5665 t_ARGTYPES_04,
5666 t_ARGTYPES_05,
5667 t_ARGTYPES_06,
5668 t_ARGTYPES_07>
5669: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5670 t_ARGTYPES_02,
5671 t_ARGTYPES_03,
5672 t_ARGTYPES_04,
5673 t_ARGTYPES_05,
5674 t_ARGTYPES_06,
5675 t_ARGTYPES_07> {
5676};
5677#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
5678
5679#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
5680template <class t_FN, class t_ARGTYPES_01,
5681 class t_ARGTYPES_02,
5682 class t_ARGTYPES_03,
5683 class t_ARGTYPES_04,
5684 class t_ARGTYPES_05,
5685 class t_ARGTYPES_06,
5686 class t_ARGTYPES_07,
5687 class t_ARGTYPES_08>
5688struct InvokeResult_Imp<false,
5689 false,
5690 true ,
5691 t_FN,
5692 t_ARGTYPES_01,
5693 t_ARGTYPES_02,
5694 t_ARGTYPES_03,
5695 t_ARGTYPES_04,
5696 t_ARGTYPES_05,
5697 t_ARGTYPES_06,
5698 t_ARGTYPES_07,
5699 t_ARGTYPES_08>
5700: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5701 t_ARGTYPES_02,
5702 t_ARGTYPES_03,
5703 t_ARGTYPES_04,
5704 t_ARGTYPES_05,
5705 t_ARGTYPES_06,
5706 t_ARGTYPES_07,
5707 t_ARGTYPES_08> {
5708};
5709#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
5710
5711#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
5712template <class t_FN, class t_ARGTYPES_01,
5713 class t_ARGTYPES_02,
5714 class t_ARGTYPES_03,
5715 class t_ARGTYPES_04,
5716 class t_ARGTYPES_05,
5717 class t_ARGTYPES_06,
5718 class t_ARGTYPES_07,
5719 class t_ARGTYPES_08,
5720 class t_ARGTYPES_09>
5721struct InvokeResult_Imp<false,
5722 false,
5723 true ,
5724 t_FN,
5725 t_ARGTYPES_01,
5726 t_ARGTYPES_02,
5727 t_ARGTYPES_03,
5728 t_ARGTYPES_04,
5729 t_ARGTYPES_05,
5730 t_ARGTYPES_06,
5731 t_ARGTYPES_07,
5732 t_ARGTYPES_08,
5733 t_ARGTYPES_09>
5734: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5735 t_ARGTYPES_02,
5736 t_ARGTYPES_03,
5737 t_ARGTYPES_04,
5738 t_ARGTYPES_05,
5739 t_ARGTYPES_06,
5740 t_ARGTYPES_07,
5741 t_ARGTYPES_08,
5742 t_ARGTYPES_09> {
5743};
5744#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
5745
5746#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
5747template <class t_FN, class t_ARGTYPES_01,
5748 class t_ARGTYPES_02,
5749 class t_ARGTYPES_03,
5750 class t_ARGTYPES_04,
5751 class t_ARGTYPES_05,
5752 class t_ARGTYPES_06,
5753 class t_ARGTYPES_07,
5754 class t_ARGTYPES_08,
5755 class t_ARGTYPES_09,
5756 class t_ARGTYPES_10>
5757struct InvokeResult_Imp<false,
5758 false,
5759 true ,
5760 t_FN,
5761 t_ARGTYPES_01,
5762 t_ARGTYPES_02,
5763 t_ARGTYPES_03,
5764 t_ARGTYPES_04,
5765 t_ARGTYPES_05,
5766 t_ARGTYPES_06,
5767 t_ARGTYPES_07,
5768 t_ARGTYPES_08,
5769 t_ARGTYPES_09,
5770 t_ARGTYPES_10>
5771: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5772 t_ARGTYPES_02,
5773 t_ARGTYPES_03,
5774 t_ARGTYPES_04,
5775 t_ARGTYPES_05,
5776 t_ARGTYPES_06,
5777 t_ARGTYPES_07,
5778 t_ARGTYPES_08,
5779 t_ARGTYPES_09,
5780 t_ARGTYPES_10> {
5781};
5782#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
5783
5784#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
5785template <class t_FN, class t_ARGTYPES_01,
5786 class t_ARGTYPES_02,
5787 class t_ARGTYPES_03,
5788 class t_ARGTYPES_04,
5789 class t_ARGTYPES_05,
5790 class t_ARGTYPES_06,
5791 class t_ARGTYPES_07,
5792 class t_ARGTYPES_08,
5793 class t_ARGTYPES_09,
5794 class t_ARGTYPES_10,
5795 class t_ARGTYPES_11>
5796struct InvokeResult_Imp<false,
5797 false,
5798 true ,
5799 t_FN,
5800 t_ARGTYPES_01,
5801 t_ARGTYPES_02,
5802 t_ARGTYPES_03,
5803 t_ARGTYPES_04,
5804 t_ARGTYPES_05,
5805 t_ARGTYPES_06,
5806 t_ARGTYPES_07,
5807 t_ARGTYPES_08,
5808 t_ARGTYPES_09,
5809 t_ARGTYPES_10,
5810 t_ARGTYPES_11>
5811: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5812 t_ARGTYPES_02,
5813 t_ARGTYPES_03,
5814 t_ARGTYPES_04,
5815 t_ARGTYPES_05,
5816 t_ARGTYPES_06,
5817 t_ARGTYPES_07,
5818 t_ARGTYPES_08,
5819 t_ARGTYPES_09,
5820 t_ARGTYPES_10,
5821 t_ARGTYPES_11> {
5822};
5823#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
5824
5825#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
5826template <class t_FN, class t_ARGTYPES_01,
5827 class t_ARGTYPES_02,
5828 class t_ARGTYPES_03,
5829 class t_ARGTYPES_04,
5830 class t_ARGTYPES_05,
5831 class t_ARGTYPES_06,
5832 class t_ARGTYPES_07,
5833 class t_ARGTYPES_08,
5834 class t_ARGTYPES_09,
5835 class t_ARGTYPES_10,
5836 class t_ARGTYPES_11,
5837 class t_ARGTYPES_12>
5838struct InvokeResult_Imp<false,
5839 false,
5840 true ,
5841 t_FN,
5842 t_ARGTYPES_01,
5843 t_ARGTYPES_02,
5844 t_ARGTYPES_03,
5845 t_ARGTYPES_04,
5846 t_ARGTYPES_05,
5847 t_ARGTYPES_06,
5848 t_ARGTYPES_07,
5849 t_ARGTYPES_08,
5850 t_ARGTYPES_09,
5851 t_ARGTYPES_10,
5852 t_ARGTYPES_11,
5853 t_ARGTYPES_12>
5854: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5855 t_ARGTYPES_02,
5856 t_ARGTYPES_03,
5857 t_ARGTYPES_04,
5858 t_ARGTYPES_05,
5859 t_ARGTYPES_06,
5860 t_ARGTYPES_07,
5861 t_ARGTYPES_08,
5862 t_ARGTYPES_09,
5863 t_ARGTYPES_10,
5864 t_ARGTYPES_11,
5865 t_ARGTYPES_12> {
5866};
5867#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
5868
5869#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
5870template <class t_FN, class t_ARGTYPES_01,
5871 class t_ARGTYPES_02,
5872 class t_ARGTYPES_03,
5873 class t_ARGTYPES_04,
5874 class t_ARGTYPES_05,
5875 class t_ARGTYPES_06,
5876 class t_ARGTYPES_07,
5877 class t_ARGTYPES_08,
5878 class t_ARGTYPES_09,
5879 class t_ARGTYPES_10,
5880 class t_ARGTYPES_11,
5881 class t_ARGTYPES_12,
5882 class t_ARGTYPES_13>
5883struct InvokeResult_Imp<false,
5884 false,
5885 true ,
5886 t_FN,
5887 t_ARGTYPES_01,
5888 t_ARGTYPES_02,
5889 t_ARGTYPES_03,
5890 t_ARGTYPES_04,
5891 t_ARGTYPES_05,
5892 t_ARGTYPES_06,
5893 t_ARGTYPES_07,
5894 t_ARGTYPES_08,
5895 t_ARGTYPES_09,
5896 t_ARGTYPES_10,
5897 t_ARGTYPES_11,
5898 t_ARGTYPES_12,
5899 t_ARGTYPES_13>
5900: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
5901 t_ARGTYPES_02,
5902 t_ARGTYPES_03,
5903 t_ARGTYPES_04,
5904 t_ARGTYPES_05,
5905 t_ARGTYPES_06,
5906 t_ARGTYPES_07,
5907 t_ARGTYPES_08,
5908 t_ARGTYPES_09,
5909 t_ARGTYPES_10,
5910 t_ARGTYPES_11,
5911 t_ARGTYPES_12,
5912 t_ARGTYPES_13> {
5913};
5914#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
5915
5916
5917
5918#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
5919#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
5920template <class t_VOID_TYPE, class t_FN>
5921struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN> {
5922};
5923#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
5924
5925#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
5926template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01>
5927struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01> {
5928};
5929#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
5930
5931#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
5932template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
5933 class t_ARGTYPES_02>
5934struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
5935 t_ARGTYPES_02> {
5936};
5937#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
5938
5939#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
5940template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
5941 class t_ARGTYPES_02,
5942 class t_ARGTYPES_03>
5943struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
5944 t_ARGTYPES_02,
5945 t_ARGTYPES_03> {
5946};
5947#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
5948
5949#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
5950template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
5951 class t_ARGTYPES_02,
5952 class t_ARGTYPES_03,
5953 class t_ARGTYPES_04>
5954struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
5955 t_ARGTYPES_02,
5956 t_ARGTYPES_03,
5957 t_ARGTYPES_04> {
5958};
5959#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
5960
5961#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
5962template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
5963 class t_ARGTYPES_02,
5964 class t_ARGTYPES_03,
5965 class t_ARGTYPES_04,
5966 class t_ARGTYPES_05>
5967struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
5968 t_ARGTYPES_02,
5969 t_ARGTYPES_03,
5970 t_ARGTYPES_04,
5971 t_ARGTYPES_05> {
5972};
5973#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
5974
5975#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
5976template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
5977 class t_ARGTYPES_02,
5978 class t_ARGTYPES_03,
5979 class t_ARGTYPES_04,
5980 class t_ARGTYPES_05,
5981 class t_ARGTYPES_06>
5982struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
5983 t_ARGTYPES_02,
5984 t_ARGTYPES_03,
5985 t_ARGTYPES_04,
5986 t_ARGTYPES_05,
5987 t_ARGTYPES_06> {
5988};
5989#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
5990
5991#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
5992template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
5993 class t_ARGTYPES_02,
5994 class t_ARGTYPES_03,
5995 class t_ARGTYPES_04,
5996 class t_ARGTYPES_05,
5997 class t_ARGTYPES_06,
5998 class t_ARGTYPES_07>
5999struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6000 t_ARGTYPES_02,
6001 t_ARGTYPES_03,
6002 t_ARGTYPES_04,
6003 t_ARGTYPES_05,
6004 t_ARGTYPES_06,
6005 t_ARGTYPES_07> {
6006};
6007#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
6008
6009#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
6010template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6011 class t_ARGTYPES_02,
6012 class t_ARGTYPES_03,
6013 class t_ARGTYPES_04,
6014 class t_ARGTYPES_05,
6015 class t_ARGTYPES_06,
6016 class t_ARGTYPES_07,
6017 class t_ARGTYPES_08>
6018struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6019 t_ARGTYPES_02,
6020 t_ARGTYPES_03,
6021 t_ARGTYPES_04,
6022 t_ARGTYPES_05,
6023 t_ARGTYPES_06,
6024 t_ARGTYPES_07,
6025 t_ARGTYPES_08> {
6026};
6027#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
6028
6029#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
6030template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6031 class t_ARGTYPES_02,
6032 class t_ARGTYPES_03,
6033 class t_ARGTYPES_04,
6034 class t_ARGTYPES_05,
6035 class t_ARGTYPES_06,
6036 class t_ARGTYPES_07,
6037 class t_ARGTYPES_08,
6038 class t_ARGTYPES_09>
6039struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6040 t_ARGTYPES_02,
6041 t_ARGTYPES_03,
6042 t_ARGTYPES_04,
6043 t_ARGTYPES_05,
6044 t_ARGTYPES_06,
6045 t_ARGTYPES_07,
6046 t_ARGTYPES_08,
6047 t_ARGTYPES_09> {
6048};
6049#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
6050
6051#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
6052template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6053 class t_ARGTYPES_02,
6054 class t_ARGTYPES_03,
6055 class t_ARGTYPES_04,
6056 class t_ARGTYPES_05,
6057 class t_ARGTYPES_06,
6058 class t_ARGTYPES_07,
6059 class t_ARGTYPES_08,
6060 class t_ARGTYPES_09,
6061 class t_ARGTYPES_10>
6062struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6063 t_ARGTYPES_02,
6064 t_ARGTYPES_03,
6065 t_ARGTYPES_04,
6066 t_ARGTYPES_05,
6067 t_ARGTYPES_06,
6068 t_ARGTYPES_07,
6069 t_ARGTYPES_08,
6070 t_ARGTYPES_09,
6071 t_ARGTYPES_10> {
6072};
6073#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
6074
6075#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
6076template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6077 class t_ARGTYPES_02,
6078 class t_ARGTYPES_03,
6079 class t_ARGTYPES_04,
6080 class t_ARGTYPES_05,
6081 class t_ARGTYPES_06,
6082 class t_ARGTYPES_07,
6083 class t_ARGTYPES_08,
6084 class t_ARGTYPES_09,
6085 class t_ARGTYPES_10,
6086 class t_ARGTYPES_11>
6087struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6088 t_ARGTYPES_02,
6089 t_ARGTYPES_03,
6090 t_ARGTYPES_04,
6091 t_ARGTYPES_05,
6092 t_ARGTYPES_06,
6093 t_ARGTYPES_07,
6094 t_ARGTYPES_08,
6095 t_ARGTYPES_09,
6096 t_ARGTYPES_10,
6097 t_ARGTYPES_11> {
6098};
6099#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
6100
6101#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
6102template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6103 class t_ARGTYPES_02,
6104 class t_ARGTYPES_03,
6105 class t_ARGTYPES_04,
6106 class t_ARGTYPES_05,
6107 class t_ARGTYPES_06,
6108 class t_ARGTYPES_07,
6109 class t_ARGTYPES_08,
6110 class t_ARGTYPES_09,
6111 class t_ARGTYPES_10,
6112 class t_ARGTYPES_11,
6113 class t_ARGTYPES_12>
6114struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6115 t_ARGTYPES_02,
6116 t_ARGTYPES_03,
6117 t_ARGTYPES_04,
6118 t_ARGTYPES_05,
6119 t_ARGTYPES_06,
6120 t_ARGTYPES_07,
6121 t_ARGTYPES_08,
6122 t_ARGTYPES_09,
6123 t_ARGTYPES_10,
6124 t_ARGTYPES_11,
6125 t_ARGTYPES_12> {
6126};
6127#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
6128
6129#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
6130template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6131 class t_ARGTYPES_02,
6132 class t_ARGTYPES_03,
6133 class t_ARGTYPES_04,
6134 class t_ARGTYPES_05,
6135 class t_ARGTYPES_06,
6136 class t_ARGTYPES_07,
6137 class t_ARGTYPES_08,
6138 class t_ARGTYPES_09,
6139 class t_ARGTYPES_10,
6140 class t_ARGTYPES_11,
6141 class t_ARGTYPES_12,
6142 class t_ARGTYPES_13>
6143struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6144 t_ARGTYPES_02,
6145 t_ARGTYPES_03,
6146 t_ARGTYPES_04,
6147 t_ARGTYPES_05,
6148 t_ARGTYPES_06,
6149 t_ARGTYPES_07,
6150 t_ARGTYPES_08,
6151 t_ARGTYPES_09,
6152 t_ARGTYPES_10,
6153 t_ARGTYPES_11,
6154 t_ARGTYPES_12,
6155 t_ARGTYPES_13> {
6156};
6157#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
6158
6159
6160#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
6161template <class t_FN>
6162struct InvokeResult_FunctorImp<
6163 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6164 ))>::type,
6165 t_FN> : InvokeResult_ImpUtils {
6166
6167
6168 typedef decltype(myDeclval<t_FN>()()) type;
6169};
6170#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
6171
6172#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
6173template <class t_FN, class t_ARGTYPES_01>
6174struct InvokeResult_FunctorImp<
6175 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6176 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>()))>::type,
6177 t_FN,
6178 t_ARGTYPES_01> : InvokeResult_ImpUtils {
6179
6180
6181 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>())) type;
6182};
6183#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
6184
6185#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
6186template <class t_FN, class t_ARGTYPES_01,
6187 class t_ARGTYPES_02>
6188struct InvokeResult_FunctorImp<
6189 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6190 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6191 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>()))>::type,
6192 t_FN,
6193 t_ARGTYPES_01,
6194 t_ARGTYPES_02> : InvokeResult_ImpUtils {
6195
6196
6197 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6198 myDeclval<t_ARGTYPES_02>())) type;
6199};
6200#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
6201
6202#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
6203template <class t_FN, class t_ARGTYPES_01,
6204 class t_ARGTYPES_02,
6205 class t_ARGTYPES_03>
6206struct InvokeResult_FunctorImp<
6207 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6208 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6209 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6210 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>()))>::type,
6211 t_FN,
6212 t_ARGTYPES_01,
6213 t_ARGTYPES_02,
6214 t_ARGTYPES_03> : InvokeResult_ImpUtils {
6215
6216
6217 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6218 myDeclval<t_ARGTYPES_02>(),
6219 myDeclval<t_ARGTYPES_03>())) type;
6220};
6221#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
6222
6223#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
6224template <class t_FN, class t_ARGTYPES_01,
6225 class t_ARGTYPES_02,
6226 class t_ARGTYPES_03,
6227 class t_ARGTYPES_04>
6228struct InvokeResult_FunctorImp<
6229 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6230 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6231 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6232 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6233 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>()))>::type,
6234 t_FN,
6235 t_ARGTYPES_01,
6236 t_ARGTYPES_02,
6237 t_ARGTYPES_03,
6238 t_ARGTYPES_04> : InvokeResult_ImpUtils {
6239
6240
6241 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6242 myDeclval<t_ARGTYPES_02>(),
6243 myDeclval<t_ARGTYPES_03>(),
6244 myDeclval<t_ARGTYPES_04>())) type;
6245};
6246#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
6247
6248#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
6249template <class t_FN, class t_ARGTYPES_01,
6250 class t_ARGTYPES_02,
6251 class t_ARGTYPES_03,
6252 class t_ARGTYPES_04,
6253 class t_ARGTYPES_05>
6254struct InvokeResult_FunctorImp<
6255 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6256 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6257 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6258 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6259 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
6260 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>()))>::type,
6261 t_FN,
6262 t_ARGTYPES_01,
6263 t_ARGTYPES_02,
6264 t_ARGTYPES_03,
6265 t_ARGTYPES_04,
6266 t_ARGTYPES_05> : InvokeResult_ImpUtils {
6267
6268
6269 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6270 myDeclval<t_ARGTYPES_02>(),
6271 myDeclval<t_ARGTYPES_03>(),
6272 myDeclval<t_ARGTYPES_04>(),
6273 myDeclval<t_ARGTYPES_05>())) type;
6274};
6275#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
6276
6277#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
6278template <class t_FN, class t_ARGTYPES_01,
6279 class t_ARGTYPES_02,
6280 class t_ARGTYPES_03,
6281 class t_ARGTYPES_04,
6282 class t_ARGTYPES_05,
6283 class t_ARGTYPES_06>
6284struct InvokeResult_FunctorImp<
6285 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6286 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6287 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6288 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6289 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
6290 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
6291 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>()))>::type,
6292 t_FN,
6293 t_ARGTYPES_01,
6294 t_ARGTYPES_02,
6295 t_ARGTYPES_03,
6296 t_ARGTYPES_04,
6297 t_ARGTYPES_05,
6298 t_ARGTYPES_06> : InvokeResult_ImpUtils {
6299
6300
6301 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6302 myDeclval<t_ARGTYPES_02>(),
6303 myDeclval<t_ARGTYPES_03>(),
6304 myDeclval<t_ARGTYPES_04>(),
6305 myDeclval<t_ARGTYPES_05>(),
6306 myDeclval<t_ARGTYPES_06>())) type;
6307};
6308#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
6309
6310#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
6311template <class t_FN, class t_ARGTYPES_01,
6312 class t_ARGTYPES_02,
6313 class t_ARGTYPES_03,
6314 class t_ARGTYPES_04,
6315 class t_ARGTYPES_05,
6316 class t_ARGTYPES_06,
6317 class t_ARGTYPES_07>
6318struct InvokeResult_FunctorImp<
6319 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6320 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6321 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6322 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6323 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
6324 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
6325 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
6326 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>()))>::type,
6327 t_FN,
6328 t_ARGTYPES_01,
6329 t_ARGTYPES_02,
6330 t_ARGTYPES_03,
6331 t_ARGTYPES_04,
6332 t_ARGTYPES_05,
6333 t_ARGTYPES_06,
6334 t_ARGTYPES_07> : InvokeResult_ImpUtils {
6335
6336
6337 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6338 myDeclval<t_ARGTYPES_02>(),
6339 myDeclval<t_ARGTYPES_03>(),
6340 myDeclval<t_ARGTYPES_04>(),
6341 myDeclval<t_ARGTYPES_05>(),
6342 myDeclval<t_ARGTYPES_06>(),
6343 myDeclval<t_ARGTYPES_07>())) type;
6344};
6345#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
6346
6347#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
6348template <class t_FN, class t_ARGTYPES_01,
6349 class t_ARGTYPES_02,
6350 class t_ARGTYPES_03,
6351 class t_ARGTYPES_04,
6352 class t_ARGTYPES_05,
6353 class t_ARGTYPES_06,
6354 class t_ARGTYPES_07,
6355 class t_ARGTYPES_08>
6356struct InvokeResult_FunctorImp<
6357 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6358 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6359 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6360 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6361 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
6362 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
6363 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
6364 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
6365 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>()))>::type,
6366 t_FN,
6367 t_ARGTYPES_01,
6368 t_ARGTYPES_02,
6369 t_ARGTYPES_03,
6370 t_ARGTYPES_04,
6371 t_ARGTYPES_05,
6372 t_ARGTYPES_06,
6373 t_ARGTYPES_07,
6374 t_ARGTYPES_08> : InvokeResult_ImpUtils {
6375
6376
6377 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6378 myDeclval<t_ARGTYPES_02>(),
6379 myDeclval<t_ARGTYPES_03>(),
6380 myDeclval<t_ARGTYPES_04>(),
6381 myDeclval<t_ARGTYPES_05>(),
6382 myDeclval<t_ARGTYPES_06>(),
6383 myDeclval<t_ARGTYPES_07>(),
6384 myDeclval<t_ARGTYPES_08>())) type;
6385};
6386#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
6387
6388#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
6389template <class t_FN, class t_ARGTYPES_01,
6390 class t_ARGTYPES_02,
6391 class t_ARGTYPES_03,
6392 class t_ARGTYPES_04,
6393 class t_ARGTYPES_05,
6394 class t_ARGTYPES_06,
6395 class t_ARGTYPES_07,
6396 class t_ARGTYPES_08,
6397 class t_ARGTYPES_09>
6398struct InvokeResult_FunctorImp<
6399 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6400 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6401 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6402 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6403 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
6404 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
6405 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
6406 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
6407 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
6408 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>()))>::type,
6409 t_FN,
6410 t_ARGTYPES_01,
6411 t_ARGTYPES_02,
6412 t_ARGTYPES_03,
6413 t_ARGTYPES_04,
6414 t_ARGTYPES_05,
6415 t_ARGTYPES_06,
6416 t_ARGTYPES_07,
6417 t_ARGTYPES_08,
6418 t_ARGTYPES_09> : InvokeResult_ImpUtils {
6419
6420
6421 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6422 myDeclval<t_ARGTYPES_02>(),
6423 myDeclval<t_ARGTYPES_03>(),
6424 myDeclval<t_ARGTYPES_04>(),
6425 myDeclval<t_ARGTYPES_05>(),
6426 myDeclval<t_ARGTYPES_06>(),
6427 myDeclval<t_ARGTYPES_07>(),
6428 myDeclval<t_ARGTYPES_08>(),
6429 myDeclval<t_ARGTYPES_09>())) type;
6430};
6431#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
6432
6433#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
6434template <class t_FN, class t_ARGTYPES_01,
6435 class t_ARGTYPES_02,
6436 class t_ARGTYPES_03,
6437 class t_ARGTYPES_04,
6438 class t_ARGTYPES_05,
6439 class t_ARGTYPES_06,
6440 class t_ARGTYPES_07,
6441 class t_ARGTYPES_08,
6442 class t_ARGTYPES_09,
6443 class t_ARGTYPES_10>
6444struct InvokeResult_FunctorImp<
6445 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6446 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6447 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6448 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6449 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
6450 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
6451 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
6452 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
6453 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
6454 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
6455 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>()))>::type,
6456 t_FN,
6457 t_ARGTYPES_01,
6458 t_ARGTYPES_02,
6459 t_ARGTYPES_03,
6460 t_ARGTYPES_04,
6461 t_ARGTYPES_05,
6462 t_ARGTYPES_06,
6463 t_ARGTYPES_07,
6464 t_ARGTYPES_08,
6465 t_ARGTYPES_09,
6466 t_ARGTYPES_10> : InvokeResult_ImpUtils {
6467
6468
6469 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6470 myDeclval<t_ARGTYPES_02>(),
6471 myDeclval<t_ARGTYPES_03>(),
6472 myDeclval<t_ARGTYPES_04>(),
6473 myDeclval<t_ARGTYPES_05>(),
6474 myDeclval<t_ARGTYPES_06>(),
6475 myDeclval<t_ARGTYPES_07>(),
6476 myDeclval<t_ARGTYPES_08>(),
6477 myDeclval<t_ARGTYPES_09>(),
6478 myDeclval<t_ARGTYPES_10>())) type;
6479};
6480#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
6481
6482#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
6483template <class t_FN, class t_ARGTYPES_01,
6484 class t_ARGTYPES_02,
6485 class t_ARGTYPES_03,
6486 class t_ARGTYPES_04,
6487 class t_ARGTYPES_05,
6488 class t_ARGTYPES_06,
6489 class t_ARGTYPES_07,
6490 class t_ARGTYPES_08,
6491 class t_ARGTYPES_09,
6492 class t_ARGTYPES_10,
6493 class t_ARGTYPES_11>
6494struct InvokeResult_FunctorImp<
6495 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6496 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6497 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6498 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6499 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
6500 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
6501 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
6502 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
6503 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
6504 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
6505 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
6506 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>()))>::type,
6507 t_FN,
6508 t_ARGTYPES_01,
6509 t_ARGTYPES_02,
6510 t_ARGTYPES_03,
6511 t_ARGTYPES_04,
6512 t_ARGTYPES_05,
6513 t_ARGTYPES_06,
6514 t_ARGTYPES_07,
6515 t_ARGTYPES_08,
6516 t_ARGTYPES_09,
6517 t_ARGTYPES_10,
6518 t_ARGTYPES_11> : InvokeResult_ImpUtils {
6519
6520
6521 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6522 myDeclval<t_ARGTYPES_02>(),
6523 myDeclval<t_ARGTYPES_03>(),
6524 myDeclval<t_ARGTYPES_04>(),
6525 myDeclval<t_ARGTYPES_05>(),
6526 myDeclval<t_ARGTYPES_06>(),
6527 myDeclval<t_ARGTYPES_07>(),
6528 myDeclval<t_ARGTYPES_08>(),
6529 myDeclval<t_ARGTYPES_09>(),
6530 myDeclval<t_ARGTYPES_10>(),
6531 myDeclval<t_ARGTYPES_11>())) type;
6532};
6533#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
6534
6535#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
6536template <class t_FN, class t_ARGTYPES_01,
6537 class t_ARGTYPES_02,
6538 class t_ARGTYPES_03,
6539 class t_ARGTYPES_04,
6540 class t_ARGTYPES_05,
6541 class t_ARGTYPES_06,
6542 class t_ARGTYPES_07,
6543 class t_ARGTYPES_08,
6544 class t_ARGTYPES_09,
6545 class t_ARGTYPES_10,
6546 class t_ARGTYPES_11,
6547 class t_ARGTYPES_12>
6548struct InvokeResult_FunctorImp<
6549 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6550 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6551 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6552 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6553 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
6554 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
6555 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
6556 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
6557 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
6558 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
6559 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
6560 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
6561 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>()))>::type,
6562 t_FN,
6563 t_ARGTYPES_01,
6564 t_ARGTYPES_02,
6565 t_ARGTYPES_03,
6566 t_ARGTYPES_04,
6567 t_ARGTYPES_05,
6568 t_ARGTYPES_06,
6569 t_ARGTYPES_07,
6570 t_ARGTYPES_08,
6571 t_ARGTYPES_09,
6572 t_ARGTYPES_10,
6573 t_ARGTYPES_11,
6574 t_ARGTYPES_12> : InvokeResult_ImpUtils {
6575
6576
6577 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6578 myDeclval<t_ARGTYPES_02>(),
6579 myDeclval<t_ARGTYPES_03>(),
6580 myDeclval<t_ARGTYPES_04>(),
6581 myDeclval<t_ARGTYPES_05>(),
6582 myDeclval<t_ARGTYPES_06>(),
6583 myDeclval<t_ARGTYPES_07>(),
6584 myDeclval<t_ARGTYPES_08>(),
6585 myDeclval<t_ARGTYPES_09>(),
6586 myDeclval<t_ARGTYPES_10>(),
6587 myDeclval<t_ARGTYPES_11>(),
6588 myDeclval<t_ARGTYPES_12>())) type;
6589};
6590#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
6591
6592#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
6593template <class t_FN, class t_ARGTYPES_01,
6594 class t_ARGTYPES_02,
6595 class t_ARGTYPES_03,
6596 class t_ARGTYPES_04,
6597 class t_ARGTYPES_05,
6598 class t_ARGTYPES_06,
6599 class t_ARGTYPES_07,
6600 class t_ARGTYPES_08,
6601 class t_ARGTYPES_09,
6602 class t_ARGTYPES_10,
6603 class t_ARGTYPES_11,
6604 class t_ARGTYPES_12,
6605 class t_ARGTYPES_13>
6606struct InvokeResult_FunctorImp<
6607 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
6608 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
6609 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
6610 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
6611 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
6612 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
6613 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
6614 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
6615 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
6616 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
6617 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
6618 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
6619 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>(),
6620 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_13>()))>::type,
6621 t_FN,
6622 t_ARGTYPES_01,
6623 t_ARGTYPES_02,
6624 t_ARGTYPES_03,
6625 t_ARGTYPES_04,
6626 t_ARGTYPES_05,
6627 t_ARGTYPES_06,
6628 t_ARGTYPES_07,
6629 t_ARGTYPES_08,
6630 t_ARGTYPES_09,
6631 t_ARGTYPES_10,
6632 t_ARGTYPES_11,
6633 t_ARGTYPES_12,
6634 t_ARGTYPES_13> : InvokeResult_ImpUtils {
6635
6636
6637 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6638 myDeclval<t_ARGTYPES_02>(),
6639 myDeclval<t_ARGTYPES_03>(),
6640 myDeclval<t_ARGTYPES_04>(),
6641 myDeclval<t_ARGTYPES_05>(),
6642 myDeclval<t_ARGTYPES_06>(),
6643 myDeclval<t_ARGTYPES_07>(),
6644 myDeclval<t_ARGTYPES_08>(),
6645 myDeclval<t_ARGTYPES_09>(),
6646 myDeclval<t_ARGTYPES_10>(),
6647 myDeclval<t_ARGTYPES_11>(),
6648 myDeclval<t_ARGTYPES_12>(),
6649 myDeclval<t_ARGTYPES_13>())) type;
6650};
6651#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
6652
6653#else
6654#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
6655template <class t_VOID_TYPE, class t_FN>
6656struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN> : InvokeResult_ImpUtils {
6657
6658 enum {
6659 k_IS_VOID = BSLMF_TAG_TO_INT((
6660 myDeclval<t_FN>()(),
6661 InvokeResult_VoidChecker()))
6662 };
6663
6664 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6665 t_FN>::type type;
6666};
6667#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
6668
6669#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
6670template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01>
6671struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01
6672 > : InvokeResult_ImpUtils {
6673
6674 enum {
6675 k_IS_VOID = BSLMF_TAG_TO_INT((
6676 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>()),
6677 InvokeResult_VoidChecker()))
6678 };
6679
6680 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6681 t_FN,
6682 t_ARGTYPES_01>::type type;
6683};
6684#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
6685
6686#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
6687template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6688 class t_ARGTYPES_02>
6689struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6690 t_ARGTYPES_02
6691 > : InvokeResult_ImpUtils {
6692
6693 enum {
6694 k_IS_VOID = BSLMF_TAG_TO_INT((
6695 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6696 myDeclval<t_ARGTYPES_02>()),
6697 InvokeResult_VoidChecker()))
6698 };
6699
6700 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6701 t_FN,
6702 t_ARGTYPES_01,
6703 t_ARGTYPES_02>::type type;
6704};
6705#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
6706
6707#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
6708template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6709 class t_ARGTYPES_02,
6710 class t_ARGTYPES_03>
6711struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6712 t_ARGTYPES_02,
6713 t_ARGTYPES_03
6714 > : InvokeResult_ImpUtils {
6715
6716 enum {
6717 k_IS_VOID = BSLMF_TAG_TO_INT((
6718 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6719 myDeclval<t_ARGTYPES_02>(),
6720 myDeclval<t_ARGTYPES_03>()),
6721 InvokeResult_VoidChecker()))
6722 };
6723
6724 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6725 t_FN,
6726 t_ARGTYPES_01,
6727 t_ARGTYPES_02,
6728 t_ARGTYPES_03>::type type;
6729};
6730#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
6731
6732#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
6733template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6734 class t_ARGTYPES_02,
6735 class t_ARGTYPES_03,
6736 class t_ARGTYPES_04>
6737struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6738 t_ARGTYPES_02,
6739 t_ARGTYPES_03,
6740 t_ARGTYPES_04
6741 > : InvokeResult_ImpUtils {
6742
6743 enum {
6744 k_IS_VOID = BSLMF_TAG_TO_INT((
6745 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6746 myDeclval<t_ARGTYPES_02>(),
6747 myDeclval<t_ARGTYPES_03>(),
6748 myDeclval<t_ARGTYPES_04>()),
6749 InvokeResult_VoidChecker()))
6750 };
6751
6752 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6753 t_FN,
6754 t_ARGTYPES_01,
6755 t_ARGTYPES_02,
6756 t_ARGTYPES_03,
6757 t_ARGTYPES_04>::type type;
6758};
6759#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
6760
6761#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
6762template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6763 class t_ARGTYPES_02,
6764 class t_ARGTYPES_03,
6765 class t_ARGTYPES_04,
6766 class t_ARGTYPES_05>
6767struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6768 t_ARGTYPES_02,
6769 t_ARGTYPES_03,
6770 t_ARGTYPES_04,
6771 t_ARGTYPES_05
6772 > : InvokeResult_ImpUtils {
6773
6774 enum {
6775 k_IS_VOID = BSLMF_TAG_TO_INT((
6776 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6777 myDeclval<t_ARGTYPES_02>(),
6778 myDeclval<t_ARGTYPES_03>(),
6779 myDeclval<t_ARGTYPES_04>(),
6780 myDeclval<t_ARGTYPES_05>()),
6781 InvokeResult_VoidChecker()))
6782 };
6783
6784 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6785 t_FN,
6786 t_ARGTYPES_01,
6787 t_ARGTYPES_02,
6788 t_ARGTYPES_03,
6789 t_ARGTYPES_04,
6790 t_ARGTYPES_05>::type type;
6791};
6792#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
6793
6794#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
6795template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6796 class t_ARGTYPES_02,
6797 class t_ARGTYPES_03,
6798 class t_ARGTYPES_04,
6799 class t_ARGTYPES_05,
6800 class t_ARGTYPES_06>
6801struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6802 t_ARGTYPES_02,
6803 t_ARGTYPES_03,
6804 t_ARGTYPES_04,
6805 t_ARGTYPES_05,
6806 t_ARGTYPES_06
6807 > : InvokeResult_ImpUtils {
6808
6809 enum {
6810 k_IS_VOID = BSLMF_TAG_TO_INT((
6811 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6812 myDeclval<t_ARGTYPES_02>(),
6813 myDeclval<t_ARGTYPES_03>(),
6814 myDeclval<t_ARGTYPES_04>(),
6815 myDeclval<t_ARGTYPES_05>(),
6816 myDeclval<t_ARGTYPES_06>()),
6817 InvokeResult_VoidChecker()))
6818 };
6819
6820 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6821 t_FN,
6822 t_ARGTYPES_01,
6823 t_ARGTYPES_02,
6824 t_ARGTYPES_03,
6825 t_ARGTYPES_04,
6826 t_ARGTYPES_05,
6827 t_ARGTYPES_06>::type type;
6828};
6829#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
6830
6831#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
6832template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6833 class t_ARGTYPES_02,
6834 class t_ARGTYPES_03,
6835 class t_ARGTYPES_04,
6836 class t_ARGTYPES_05,
6837 class t_ARGTYPES_06,
6838 class t_ARGTYPES_07>
6839struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6840 t_ARGTYPES_02,
6841 t_ARGTYPES_03,
6842 t_ARGTYPES_04,
6843 t_ARGTYPES_05,
6844 t_ARGTYPES_06,
6845 t_ARGTYPES_07
6846 > : InvokeResult_ImpUtils {
6847
6848 enum {
6849 k_IS_VOID = BSLMF_TAG_TO_INT((
6850 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6851 myDeclval<t_ARGTYPES_02>(),
6852 myDeclval<t_ARGTYPES_03>(),
6853 myDeclval<t_ARGTYPES_04>(),
6854 myDeclval<t_ARGTYPES_05>(),
6855 myDeclval<t_ARGTYPES_06>(),
6856 myDeclval<t_ARGTYPES_07>()),
6857 InvokeResult_VoidChecker()))
6858 };
6859
6860 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6861 t_FN,
6862 t_ARGTYPES_01,
6863 t_ARGTYPES_02,
6864 t_ARGTYPES_03,
6865 t_ARGTYPES_04,
6866 t_ARGTYPES_05,
6867 t_ARGTYPES_06,
6868 t_ARGTYPES_07>::type type;
6869};
6870#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
6871
6872#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
6873template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6874 class t_ARGTYPES_02,
6875 class t_ARGTYPES_03,
6876 class t_ARGTYPES_04,
6877 class t_ARGTYPES_05,
6878 class t_ARGTYPES_06,
6879 class t_ARGTYPES_07,
6880 class t_ARGTYPES_08>
6881struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6882 t_ARGTYPES_02,
6883 t_ARGTYPES_03,
6884 t_ARGTYPES_04,
6885 t_ARGTYPES_05,
6886 t_ARGTYPES_06,
6887 t_ARGTYPES_07,
6888 t_ARGTYPES_08
6889 > : InvokeResult_ImpUtils {
6890
6891 enum {
6892 k_IS_VOID = BSLMF_TAG_TO_INT((
6893 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6894 myDeclval<t_ARGTYPES_02>(),
6895 myDeclval<t_ARGTYPES_03>(),
6896 myDeclval<t_ARGTYPES_04>(),
6897 myDeclval<t_ARGTYPES_05>(),
6898 myDeclval<t_ARGTYPES_06>(),
6899 myDeclval<t_ARGTYPES_07>(),
6900 myDeclval<t_ARGTYPES_08>()),
6901 InvokeResult_VoidChecker()))
6902 };
6903
6904 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6905 t_FN,
6906 t_ARGTYPES_01,
6907 t_ARGTYPES_02,
6908 t_ARGTYPES_03,
6909 t_ARGTYPES_04,
6910 t_ARGTYPES_05,
6911 t_ARGTYPES_06,
6912 t_ARGTYPES_07,
6913 t_ARGTYPES_08>::type type;
6914};
6915#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
6916
6917#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
6918template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6919 class t_ARGTYPES_02,
6920 class t_ARGTYPES_03,
6921 class t_ARGTYPES_04,
6922 class t_ARGTYPES_05,
6923 class t_ARGTYPES_06,
6924 class t_ARGTYPES_07,
6925 class t_ARGTYPES_08,
6926 class t_ARGTYPES_09>
6927struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6928 t_ARGTYPES_02,
6929 t_ARGTYPES_03,
6930 t_ARGTYPES_04,
6931 t_ARGTYPES_05,
6932 t_ARGTYPES_06,
6933 t_ARGTYPES_07,
6934 t_ARGTYPES_08,
6935 t_ARGTYPES_09
6936 > : InvokeResult_ImpUtils {
6937
6938 enum {
6939 k_IS_VOID = BSLMF_TAG_TO_INT((
6940 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6941 myDeclval<t_ARGTYPES_02>(),
6942 myDeclval<t_ARGTYPES_03>(),
6943 myDeclval<t_ARGTYPES_04>(),
6944 myDeclval<t_ARGTYPES_05>(),
6945 myDeclval<t_ARGTYPES_06>(),
6946 myDeclval<t_ARGTYPES_07>(),
6947 myDeclval<t_ARGTYPES_08>(),
6948 myDeclval<t_ARGTYPES_09>()),
6949 InvokeResult_VoidChecker()))
6950 };
6951
6952 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
6953 t_FN,
6954 t_ARGTYPES_01,
6955 t_ARGTYPES_02,
6956 t_ARGTYPES_03,
6957 t_ARGTYPES_04,
6958 t_ARGTYPES_05,
6959 t_ARGTYPES_06,
6960 t_ARGTYPES_07,
6961 t_ARGTYPES_08,
6962 t_ARGTYPES_09>::type type;
6963};
6964#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
6965
6966#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
6967template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
6968 class t_ARGTYPES_02,
6969 class t_ARGTYPES_03,
6970 class t_ARGTYPES_04,
6971 class t_ARGTYPES_05,
6972 class t_ARGTYPES_06,
6973 class t_ARGTYPES_07,
6974 class t_ARGTYPES_08,
6975 class t_ARGTYPES_09,
6976 class t_ARGTYPES_10>
6977struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
6978 t_ARGTYPES_02,
6979 t_ARGTYPES_03,
6980 t_ARGTYPES_04,
6981 t_ARGTYPES_05,
6982 t_ARGTYPES_06,
6983 t_ARGTYPES_07,
6984 t_ARGTYPES_08,
6985 t_ARGTYPES_09,
6986 t_ARGTYPES_10
6987 > : InvokeResult_ImpUtils {
6988
6989 enum {
6990 k_IS_VOID = BSLMF_TAG_TO_INT((
6991 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
6992 myDeclval<t_ARGTYPES_02>(),
6993 myDeclval<t_ARGTYPES_03>(),
6994 myDeclval<t_ARGTYPES_04>(),
6995 myDeclval<t_ARGTYPES_05>(),
6996 myDeclval<t_ARGTYPES_06>(),
6997 myDeclval<t_ARGTYPES_07>(),
6998 myDeclval<t_ARGTYPES_08>(),
6999 myDeclval<t_ARGTYPES_09>(),
7000 myDeclval<t_ARGTYPES_10>()),
7001 InvokeResult_VoidChecker()))
7002 };
7003
7004 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
7005 t_FN,
7006 t_ARGTYPES_01,
7007 t_ARGTYPES_02,
7008 t_ARGTYPES_03,
7009 t_ARGTYPES_04,
7010 t_ARGTYPES_05,
7011 t_ARGTYPES_06,
7012 t_ARGTYPES_07,
7013 t_ARGTYPES_08,
7014 t_ARGTYPES_09,
7015 t_ARGTYPES_10>::type type;
7016};
7017#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
7018
7019#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
7020template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7021 class t_ARGTYPES_02,
7022 class t_ARGTYPES_03,
7023 class t_ARGTYPES_04,
7024 class t_ARGTYPES_05,
7025 class t_ARGTYPES_06,
7026 class t_ARGTYPES_07,
7027 class t_ARGTYPES_08,
7028 class t_ARGTYPES_09,
7029 class t_ARGTYPES_10,
7030 class t_ARGTYPES_11>
7031struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7032 t_ARGTYPES_02,
7033 t_ARGTYPES_03,
7034 t_ARGTYPES_04,
7035 t_ARGTYPES_05,
7036 t_ARGTYPES_06,
7037 t_ARGTYPES_07,
7038 t_ARGTYPES_08,
7039 t_ARGTYPES_09,
7040 t_ARGTYPES_10,
7041 t_ARGTYPES_11
7042 > : InvokeResult_ImpUtils {
7043
7044 enum {
7045 k_IS_VOID = BSLMF_TAG_TO_INT((
7046 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7047 myDeclval<t_ARGTYPES_02>(),
7048 myDeclval<t_ARGTYPES_03>(),
7049 myDeclval<t_ARGTYPES_04>(),
7050 myDeclval<t_ARGTYPES_05>(),
7051 myDeclval<t_ARGTYPES_06>(),
7052 myDeclval<t_ARGTYPES_07>(),
7053 myDeclval<t_ARGTYPES_08>(),
7054 myDeclval<t_ARGTYPES_09>(),
7055 myDeclval<t_ARGTYPES_10>(),
7056 myDeclval<t_ARGTYPES_11>()),
7057 InvokeResult_VoidChecker()))
7058 };
7059
7060 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
7061 t_FN,
7062 t_ARGTYPES_01,
7063 t_ARGTYPES_02,
7064 t_ARGTYPES_03,
7065 t_ARGTYPES_04,
7066 t_ARGTYPES_05,
7067 t_ARGTYPES_06,
7068 t_ARGTYPES_07,
7069 t_ARGTYPES_08,
7070 t_ARGTYPES_09,
7071 t_ARGTYPES_10,
7072 t_ARGTYPES_11>::type type;
7073};
7074#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
7075
7076#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
7077template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7078 class t_ARGTYPES_02,
7079 class t_ARGTYPES_03,
7080 class t_ARGTYPES_04,
7081 class t_ARGTYPES_05,
7082 class t_ARGTYPES_06,
7083 class t_ARGTYPES_07,
7084 class t_ARGTYPES_08,
7085 class t_ARGTYPES_09,
7086 class t_ARGTYPES_10,
7087 class t_ARGTYPES_11,
7088 class t_ARGTYPES_12>
7089struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7090 t_ARGTYPES_02,
7091 t_ARGTYPES_03,
7092 t_ARGTYPES_04,
7093 t_ARGTYPES_05,
7094 t_ARGTYPES_06,
7095 t_ARGTYPES_07,
7096 t_ARGTYPES_08,
7097 t_ARGTYPES_09,
7098 t_ARGTYPES_10,
7099 t_ARGTYPES_11,
7100 t_ARGTYPES_12
7101 > : InvokeResult_ImpUtils {
7102
7103 enum {
7104 k_IS_VOID = BSLMF_TAG_TO_INT((
7105 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7106 myDeclval<t_ARGTYPES_02>(),
7107 myDeclval<t_ARGTYPES_03>(),
7108 myDeclval<t_ARGTYPES_04>(),
7109 myDeclval<t_ARGTYPES_05>(),
7110 myDeclval<t_ARGTYPES_06>(),
7111 myDeclval<t_ARGTYPES_07>(),
7112 myDeclval<t_ARGTYPES_08>(),
7113 myDeclval<t_ARGTYPES_09>(),
7114 myDeclval<t_ARGTYPES_10>(),
7115 myDeclval<t_ARGTYPES_11>(),
7116 myDeclval<t_ARGTYPES_12>()),
7117 InvokeResult_VoidChecker()))
7118 };
7119
7120 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
7121 t_FN,
7122 t_ARGTYPES_01,
7123 t_ARGTYPES_02,
7124 t_ARGTYPES_03,
7125 t_ARGTYPES_04,
7126 t_ARGTYPES_05,
7127 t_ARGTYPES_06,
7128 t_ARGTYPES_07,
7129 t_ARGTYPES_08,
7130 t_ARGTYPES_09,
7131 t_ARGTYPES_10,
7132 t_ARGTYPES_11,
7133 t_ARGTYPES_12>::type type;
7134};
7135#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
7136
7137#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
7138template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7139 class t_ARGTYPES_02,
7140 class t_ARGTYPES_03,
7141 class t_ARGTYPES_04,
7142 class t_ARGTYPES_05,
7143 class t_ARGTYPES_06,
7144 class t_ARGTYPES_07,
7145 class t_ARGTYPES_08,
7146 class t_ARGTYPES_09,
7147 class t_ARGTYPES_10,
7148 class t_ARGTYPES_11,
7149 class t_ARGTYPES_12,
7150 class t_ARGTYPES_13>
7151struct InvokeResult_FunctorImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7152 t_ARGTYPES_02,
7153 t_ARGTYPES_03,
7154 t_ARGTYPES_04,
7155 t_ARGTYPES_05,
7156 t_ARGTYPES_06,
7157 t_ARGTYPES_07,
7158 t_ARGTYPES_08,
7159 t_ARGTYPES_09,
7160 t_ARGTYPES_10,
7161 t_ARGTYPES_11,
7162 t_ARGTYPES_12,
7163 t_ARGTYPES_13
7164 > : InvokeResult_ImpUtils {
7165
7166 enum {
7167 k_IS_VOID = BSLMF_TAG_TO_INT((
7168 myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7169 myDeclval<t_ARGTYPES_02>(),
7170 myDeclval<t_ARGTYPES_03>(),
7171 myDeclval<t_ARGTYPES_04>(),
7172 myDeclval<t_ARGTYPES_05>(),
7173 myDeclval<t_ARGTYPES_06>(),
7174 myDeclval<t_ARGTYPES_07>(),
7175 myDeclval<t_ARGTYPES_08>(),
7176 myDeclval<t_ARGTYPES_09>(),
7177 myDeclval<t_ARGTYPES_10>(),
7178 myDeclval<t_ARGTYPES_11>(),
7179 myDeclval<t_ARGTYPES_12>(),
7180 myDeclval<t_ARGTYPES_13>()),
7181 InvokeResult_VoidChecker()))
7182 };
7183
7184 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
7185 t_FN,
7186 t_ARGTYPES_01,
7187 t_ARGTYPES_02,
7188 t_ARGTYPES_03,
7189 t_ARGTYPES_04,
7190 t_ARGTYPES_05,
7191 t_ARGTYPES_06,
7192 t_ARGTYPES_07,
7193 t_ARGTYPES_08,
7194 t_ARGTYPES_09,
7195 t_ARGTYPES_10,
7196 t_ARGTYPES_11,
7197 t_ARGTYPES_12,
7198 t_ARGTYPES_13>::type type;
7199};
7200#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
7201
7202#endif
7203
7204
7205#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
7206#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
7207template <class t_VOID_TYPE, class t_FN>
7208struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN> {
7209};
7210#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
7211
7212#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
7213template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01>
7214struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01> {
7215};
7216#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
7217
7218#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
7219template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7220 class t_ARGTYPES_02>
7221struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7222 t_ARGTYPES_02> {
7223};
7224#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
7225
7226#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
7227template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7228 class t_ARGTYPES_02,
7229 class t_ARGTYPES_03>
7230struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7231 t_ARGTYPES_02,
7232 t_ARGTYPES_03> {
7233};
7234#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
7235
7236#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
7237template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7238 class t_ARGTYPES_02,
7239 class t_ARGTYPES_03,
7240 class t_ARGTYPES_04>
7241struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7242 t_ARGTYPES_02,
7243 t_ARGTYPES_03,
7244 t_ARGTYPES_04> {
7245};
7246#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
7247
7248#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
7249template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7250 class t_ARGTYPES_02,
7251 class t_ARGTYPES_03,
7252 class t_ARGTYPES_04,
7253 class t_ARGTYPES_05>
7254struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7255 t_ARGTYPES_02,
7256 t_ARGTYPES_03,
7257 t_ARGTYPES_04,
7258 t_ARGTYPES_05> {
7259};
7260#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
7261
7262#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
7263template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7264 class t_ARGTYPES_02,
7265 class t_ARGTYPES_03,
7266 class t_ARGTYPES_04,
7267 class t_ARGTYPES_05,
7268 class t_ARGTYPES_06>
7269struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7270 t_ARGTYPES_02,
7271 t_ARGTYPES_03,
7272 t_ARGTYPES_04,
7273 t_ARGTYPES_05,
7274 t_ARGTYPES_06> {
7275};
7276#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
7277
7278#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
7279template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7280 class t_ARGTYPES_02,
7281 class t_ARGTYPES_03,
7282 class t_ARGTYPES_04,
7283 class t_ARGTYPES_05,
7284 class t_ARGTYPES_06,
7285 class t_ARGTYPES_07>
7286struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7287 t_ARGTYPES_02,
7288 t_ARGTYPES_03,
7289 t_ARGTYPES_04,
7290 t_ARGTYPES_05,
7291 t_ARGTYPES_06,
7292 t_ARGTYPES_07> {
7293};
7294#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
7295
7296#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
7297template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7298 class t_ARGTYPES_02,
7299 class t_ARGTYPES_03,
7300 class t_ARGTYPES_04,
7301 class t_ARGTYPES_05,
7302 class t_ARGTYPES_06,
7303 class t_ARGTYPES_07,
7304 class t_ARGTYPES_08>
7305struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7306 t_ARGTYPES_02,
7307 t_ARGTYPES_03,
7308 t_ARGTYPES_04,
7309 t_ARGTYPES_05,
7310 t_ARGTYPES_06,
7311 t_ARGTYPES_07,
7312 t_ARGTYPES_08> {
7313};
7314#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
7315
7316#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
7317template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7318 class t_ARGTYPES_02,
7319 class t_ARGTYPES_03,
7320 class t_ARGTYPES_04,
7321 class t_ARGTYPES_05,
7322 class t_ARGTYPES_06,
7323 class t_ARGTYPES_07,
7324 class t_ARGTYPES_08,
7325 class t_ARGTYPES_09>
7326struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7327 t_ARGTYPES_02,
7328 t_ARGTYPES_03,
7329 t_ARGTYPES_04,
7330 t_ARGTYPES_05,
7331 t_ARGTYPES_06,
7332 t_ARGTYPES_07,
7333 t_ARGTYPES_08,
7334 t_ARGTYPES_09> {
7335};
7336#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
7337
7338#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
7339template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7340 class t_ARGTYPES_02,
7341 class t_ARGTYPES_03,
7342 class t_ARGTYPES_04,
7343 class t_ARGTYPES_05,
7344 class t_ARGTYPES_06,
7345 class t_ARGTYPES_07,
7346 class t_ARGTYPES_08,
7347 class t_ARGTYPES_09,
7348 class t_ARGTYPES_10>
7349struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7350 t_ARGTYPES_02,
7351 t_ARGTYPES_03,
7352 t_ARGTYPES_04,
7353 t_ARGTYPES_05,
7354 t_ARGTYPES_06,
7355 t_ARGTYPES_07,
7356 t_ARGTYPES_08,
7357 t_ARGTYPES_09,
7358 t_ARGTYPES_10> {
7359};
7360#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
7361
7362#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
7363template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7364 class t_ARGTYPES_02,
7365 class t_ARGTYPES_03,
7366 class t_ARGTYPES_04,
7367 class t_ARGTYPES_05,
7368 class t_ARGTYPES_06,
7369 class t_ARGTYPES_07,
7370 class t_ARGTYPES_08,
7371 class t_ARGTYPES_09,
7372 class t_ARGTYPES_10,
7373 class t_ARGTYPES_11>
7374struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7375 t_ARGTYPES_02,
7376 t_ARGTYPES_03,
7377 t_ARGTYPES_04,
7378 t_ARGTYPES_05,
7379 t_ARGTYPES_06,
7380 t_ARGTYPES_07,
7381 t_ARGTYPES_08,
7382 t_ARGTYPES_09,
7383 t_ARGTYPES_10,
7384 t_ARGTYPES_11> {
7385};
7386#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
7387
7388#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
7389template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7390 class t_ARGTYPES_02,
7391 class t_ARGTYPES_03,
7392 class t_ARGTYPES_04,
7393 class t_ARGTYPES_05,
7394 class t_ARGTYPES_06,
7395 class t_ARGTYPES_07,
7396 class t_ARGTYPES_08,
7397 class t_ARGTYPES_09,
7398 class t_ARGTYPES_10,
7399 class t_ARGTYPES_11,
7400 class t_ARGTYPES_12>
7401struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7402 t_ARGTYPES_02,
7403 t_ARGTYPES_03,
7404 t_ARGTYPES_04,
7405 t_ARGTYPES_05,
7406 t_ARGTYPES_06,
7407 t_ARGTYPES_07,
7408 t_ARGTYPES_08,
7409 t_ARGTYPES_09,
7410 t_ARGTYPES_10,
7411 t_ARGTYPES_11,
7412 t_ARGTYPES_12> {
7413};
7414#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
7415
7416#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
7417template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7418 class t_ARGTYPES_02,
7419 class t_ARGTYPES_03,
7420 class t_ARGTYPES_04,
7421 class t_ARGTYPES_05,
7422 class t_ARGTYPES_06,
7423 class t_ARGTYPES_07,
7424 class t_ARGTYPES_08,
7425 class t_ARGTYPES_09,
7426 class t_ARGTYPES_10,
7427 class t_ARGTYPES_11,
7428 class t_ARGTYPES_12,
7429 class t_ARGTYPES_13>
7430struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7431 t_ARGTYPES_02,
7432 t_ARGTYPES_03,
7433 t_ARGTYPES_04,
7434 t_ARGTYPES_05,
7435 t_ARGTYPES_06,
7436 t_ARGTYPES_07,
7437 t_ARGTYPES_08,
7438 t_ARGTYPES_09,
7439 t_ARGTYPES_10,
7440 t_ARGTYPES_11,
7441 t_ARGTYPES_12,
7442 t_ARGTYPES_13> {
7443};
7444#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
7445
7446
7447#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
7448template <class t_FN>
7449struct InvokeResult_FuncPtrImp<
7450 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7451 ))>::type,
7452 t_FN> : InvokeResult_ImpUtils {
7453
7454
7455 typedef decltype(myDeclval<t_FN>()()) type;
7456};
7457#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
7458
7459#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
7460template <class t_FN, class t_ARGTYPES_01>
7461struct InvokeResult_FuncPtrImp<
7462 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7463 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>()))>::type,
7464 t_FN,
7465 t_ARGTYPES_01> : InvokeResult_ImpUtils {
7466
7467
7468 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>())) type;
7469};
7470#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
7471
7472#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
7473template <class t_FN, class t_ARGTYPES_01,
7474 class t_ARGTYPES_02>
7475struct InvokeResult_FuncPtrImp<
7476 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7477 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7478 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>()))>::type,
7479 t_FN,
7480 t_ARGTYPES_01,
7481 t_ARGTYPES_02> : InvokeResult_ImpUtils {
7482
7483
7484 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7485 myDeclval<t_ARGTYPES_02>())) type;
7486};
7487#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
7488
7489#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
7490template <class t_FN, class t_ARGTYPES_01,
7491 class t_ARGTYPES_02,
7492 class t_ARGTYPES_03>
7493struct InvokeResult_FuncPtrImp<
7494 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7495 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7496 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7497 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>()))>::type,
7498 t_FN,
7499 t_ARGTYPES_01,
7500 t_ARGTYPES_02,
7501 t_ARGTYPES_03> : InvokeResult_ImpUtils {
7502
7503
7504 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7505 myDeclval<t_ARGTYPES_02>(),
7506 myDeclval<t_ARGTYPES_03>())) type;
7507};
7508#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
7509
7510#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
7511template <class t_FN, class t_ARGTYPES_01,
7512 class t_ARGTYPES_02,
7513 class t_ARGTYPES_03,
7514 class t_ARGTYPES_04>
7515struct InvokeResult_FuncPtrImp<
7516 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7517 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7518 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7519 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7520 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>()))>::type,
7521 t_FN,
7522 t_ARGTYPES_01,
7523 t_ARGTYPES_02,
7524 t_ARGTYPES_03,
7525 t_ARGTYPES_04> : InvokeResult_ImpUtils {
7526
7527
7528 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7529 myDeclval<t_ARGTYPES_02>(),
7530 myDeclval<t_ARGTYPES_03>(),
7531 myDeclval<t_ARGTYPES_04>())) type;
7532};
7533#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
7534
7535#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
7536template <class t_FN, class t_ARGTYPES_01,
7537 class t_ARGTYPES_02,
7538 class t_ARGTYPES_03,
7539 class t_ARGTYPES_04,
7540 class t_ARGTYPES_05>
7541struct InvokeResult_FuncPtrImp<
7542 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7543 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7544 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7545 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7546 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
7547 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>()))>::type,
7548 t_FN,
7549 t_ARGTYPES_01,
7550 t_ARGTYPES_02,
7551 t_ARGTYPES_03,
7552 t_ARGTYPES_04,
7553 t_ARGTYPES_05> : InvokeResult_ImpUtils {
7554
7555
7556 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7557 myDeclval<t_ARGTYPES_02>(),
7558 myDeclval<t_ARGTYPES_03>(),
7559 myDeclval<t_ARGTYPES_04>(),
7560 myDeclval<t_ARGTYPES_05>())) type;
7561};
7562#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
7563
7564#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
7565template <class t_FN, class t_ARGTYPES_01,
7566 class t_ARGTYPES_02,
7567 class t_ARGTYPES_03,
7568 class t_ARGTYPES_04,
7569 class t_ARGTYPES_05,
7570 class t_ARGTYPES_06>
7571struct InvokeResult_FuncPtrImp<
7572 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7573 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7574 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7575 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7576 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
7577 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
7578 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>()))>::type,
7579 t_FN,
7580 t_ARGTYPES_01,
7581 t_ARGTYPES_02,
7582 t_ARGTYPES_03,
7583 t_ARGTYPES_04,
7584 t_ARGTYPES_05,
7585 t_ARGTYPES_06> : InvokeResult_ImpUtils {
7586
7587
7588 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7589 myDeclval<t_ARGTYPES_02>(),
7590 myDeclval<t_ARGTYPES_03>(),
7591 myDeclval<t_ARGTYPES_04>(),
7592 myDeclval<t_ARGTYPES_05>(),
7593 myDeclval<t_ARGTYPES_06>())) type;
7594};
7595#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
7596
7597#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
7598template <class t_FN, class t_ARGTYPES_01,
7599 class t_ARGTYPES_02,
7600 class t_ARGTYPES_03,
7601 class t_ARGTYPES_04,
7602 class t_ARGTYPES_05,
7603 class t_ARGTYPES_06,
7604 class t_ARGTYPES_07>
7605struct InvokeResult_FuncPtrImp<
7606 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7607 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7608 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7609 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7610 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
7611 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
7612 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
7613 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>()))>::type,
7614 t_FN,
7615 t_ARGTYPES_01,
7616 t_ARGTYPES_02,
7617 t_ARGTYPES_03,
7618 t_ARGTYPES_04,
7619 t_ARGTYPES_05,
7620 t_ARGTYPES_06,
7621 t_ARGTYPES_07> : InvokeResult_ImpUtils {
7622
7623
7624 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7625 myDeclval<t_ARGTYPES_02>(),
7626 myDeclval<t_ARGTYPES_03>(),
7627 myDeclval<t_ARGTYPES_04>(),
7628 myDeclval<t_ARGTYPES_05>(),
7629 myDeclval<t_ARGTYPES_06>(),
7630 myDeclval<t_ARGTYPES_07>())) type;
7631};
7632#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
7633
7634#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
7635template <class t_FN, class t_ARGTYPES_01,
7636 class t_ARGTYPES_02,
7637 class t_ARGTYPES_03,
7638 class t_ARGTYPES_04,
7639 class t_ARGTYPES_05,
7640 class t_ARGTYPES_06,
7641 class t_ARGTYPES_07,
7642 class t_ARGTYPES_08>
7643struct InvokeResult_FuncPtrImp<
7644 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7645 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7646 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7647 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7648 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
7649 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
7650 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
7651 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
7652 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>()))>::type,
7653 t_FN,
7654 t_ARGTYPES_01,
7655 t_ARGTYPES_02,
7656 t_ARGTYPES_03,
7657 t_ARGTYPES_04,
7658 t_ARGTYPES_05,
7659 t_ARGTYPES_06,
7660 t_ARGTYPES_07,
7661 t_ARGTYPES_08> : InvokeResult_ImpUtils {
7662
7663
7664 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7665 myDeclval<t_ARGTYPES_02>(),
7666 myDeclval<t_ARGTYPES_03>(),
7667 myDeclval<t_ARGTYPES_04>(),
7668 myDeclval<t_ARGTYPES_05>(),
7669 myDeclval<t_ARGTYPES_06>(),
7670 myDeclval<t_ARGTYPES_07>(),
7671 myDeclval<t_ARGTYPES_08>())) type;
7672};
7673#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
7674
7675#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
7676template <class t_FN, class t_ARGTYPES_01,
7677 class t_ARGTYPES_02,
7678 class t_ARGTYPES_03,
7679 class t_ARGTYPES_04,
7680 class t_ARGTYPES_05,
7681 class t_ARGTYPES_06,
7682 class t_ARGTYPES_07,
7683 class t_ARGTYPES_08,
7684 class t_ARGTYPES_09>
7685struct InvokeResult_FuncPtrImp<
7686 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7687 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7688 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7689 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7690 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
7691 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
7692 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
7693 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
7694 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
7695 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>()))>::type,
7696 t_FN,
7697 t_ARGTYPES_01,
7698 t_ARGTYPES_02,
7699 t_ARGTYPES_03,
7700 t_ARGTYPES_04,
7701 t_ARGTYPES_05,
7702 t_ARGTYPES_06,
7703 t_ARGTYPES_07,
7704 t_ARGTYPES_08,
7705 t_ARGTYPES_09> : InvokeResult_ImpUtils {
7706
7707
7708 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7709 myDeclval<t_ARGTYPES_02>(),
7710 myDeclval<t_ARGTYPES_03>(),
7711 myDeclval<t_ARGTYPES_04>(),
7712 myDeclval<t_ARGTYPES_05>(),
7713 myDeclval<t_ARGTYPES_06>(),
7714 myDeclval<t_ARGTYPES_07>(),
7715 myDeclval<t_ARGTYPES_08>(),
7716 myDeclval<t_ARGTYPES_09>())) type;
7717};
7718#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
7719
7720#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
7721template <class t_FN, class t_ARGTYPES_01,
7722 class t_ARGTYPES_02,
7723 class t_ARGTYPES_03,
7724 class t_ARGTYPES_04,
7725 class t_ARGTYPES_05,
7726 class t_ARGTYPES_06,
7727 class t_ARGTYPES_07,
7728 class t_ARGTYPES_08,
7729 class t_ARGTYPES_09,
7730 class t_ARGTYPES_10>
7731struct InvokeResult_FuncPtrImp<
7732 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7733 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7734 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7735 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7736 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
7737 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
7738 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
7739 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
7740 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
7741 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
7742 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>()))>::type,
7743 t_FN,
7744 t_ARGTYPES_01,
7745 t_ARGTYPES_02,
7746 t_ARGTYPES_03,
7747 t_ARGTYPES_04,
7748 t_ARGTYPES_05,
7749 t_ARGTYPES_06,
7750 t_ARGTYPES_07,
7751 t_ARGTYPES_08,
7752 t_ARGTYPES_09,
7753 t_ARGTYPES_10> : InvokeResult_ImpUtils {
7754
7755
7756 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7757 myDeclval<t_ARGTYPES_02>(),
7758 myDeclval<t_ARGTYPES_03>(),
7759 myDeclval<t_ARGTYPES_04>(),
7760 myDeclval<t_ARGTYPES_05>(),
7761 myDeclval<t_ARGTYPES_06>(),
7762 myDeclval<t_ARGTYPES_07>(),
7763 myDeclval<t_ARGTYPES_08>(),
7764 myDeclval<t_ARGTYPES_09>(),
7765 myDeclval<t_ARGTYPES_10>())) type;
7766};
7767#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
7768
7769#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
7770template <class t_FN, class t_ARGTYPES_01,
7771 class t_ARGTYPES_02,
7772 class t_ARGTYPES_03,
7773 class t_ARGTYPES_04,
7774 class t_ARGTYPES_05,
7775 class t_ARGTYPES_06,
7776 class t_ARGTYPES_07,
7777 class t_ARGTYPES_08,
7778 class t_ARGTYPES_09,
7779 class t_ARGTYPES_10,
7780 class t_ARGTYPES_11>
7781struct InvokeResult_FuncPtrImp<
7782 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7783 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7784 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7785 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7786 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
7787 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
7788 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
7789 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
7790 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
7791 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
7792 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
7793 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>()))>::type,
7794 t_FN,
7795 t_ARGTYPES_01,
7796 t_ARGTYPES_02,
7797 t_ARGTYPES_03,
7798 t_ARGTYPES_04,
7799 t_ARGTYPES_05,
7800 t_ARGTYPES_06,
7801 t_ARGTYPES_07,
7802 t_ARGTYPES_08,
7803 t_ARGTYPES_09,
7804 t_ARGTYPES_10,
7805 t_ARGTYPES_11> : InvokeResult_ImpUtils {
7806
7807
7808 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7809 myDeclval<t_ARGTYPES_02>(),
7810 myDeclval<t_ARGTYPES_03>(),
7811 myDeclval<t_ARGTYPES_04>(),
7812 myDeclval<t_ARGTYPES_05>(),
7813 myDeclval<t_ARGTYPES_06>(),
7814 myDeclval<t_ARGTYPES_07>(),
7815 myDeclval<t_ARGTYPES_08>(),
7816 myDeclval<t_ARGTYPES_09>(),
7817 myDeclval<t_ARGTYPES_10>(),
7818 myDeclval<t_ARGTYPES_11>())) type;
7819};
7820#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
7821
7822#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
7823template <class t_FN, class t_ARGTYPES_01,
7824 class t_ARGTYPES_02,
7825 class t_ARGTYPES_03,
7826 class t_ARGTYPES_04,
7827 class t_ARGTYPES_05,
7828 class t_ARGTYPES_06,
7829 class t_ARGTYPES_07,
7830 class t_ARGTYPES_08,
7831 class t_ARGTYPES_09,
7832 class t_ARGTYPES_10,
7833 class t_ARGTYPES_11,
7834 class t_ARGTYPES_12>
7835struct InvokeResult_FuncPtrImp<
7836 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7837 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7838 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7839 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7840 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
7841 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
7842 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
7843 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
7844 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
7845 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
7846 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
7847 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
7848 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>()))>::type,
7849 t_FN,
7850 t_ARGTYPES_01,
7851 t_ARGTYPES_02,
7852 t_ARGTYPES_03,
7853 t_ARGTYPES_04,
7854 t_ARGTYPES_05,
7855 t_ARGTYPES_06,
7856 t_ARGTYPES_07,
7857 t_ARGTYPES_08,
7858 t_ARGTYPES_09,
7859 t_ARGTYPES_10,
7860 t_ARGTYPES_11,
7861 t_ARGTYPES_12> : InvokeResult_ImpUtils {
7862
7863
7864 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7865 myDeclval<t_ARGTYPES_02>(),
7866 myDeclval<t_ARGTYPES_03>(),
7867 myDeclval<t_ARGTYPES_04>(),
7868 myDeclval<t_ARGTYPES_05>(),
7869 myDeclval<t_ARGTYPES_06>(),
7870 myDeclval<t_ARGTYPES_07>(),
7871 myDeclval<t_ARGTYPES_08>(),
7872 myDeclval<t_ARGTYPES_09>(),
7873 myDeclval<t_ARGTYPES_10>(),
7874 myDeclval<t_ARGTYPES_11>(),
7875 myDeclval<t_ARGTYPES_12>())) type;
7876};
7877#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
7878
7879#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
7880template <class t_FN, class t_ARGTYPES_01,
7881 class t_ARGTYPES_02,
7882 class t_ARGTYPES_03,
7883 class t_ARGTYPES_04,
7884 class t_ARGTYPES_05,
7885 class t_ARGTYPES_06,
7886 class t_ARGTYPES_07,
7887 class t_ARGTYPES_08,
7888 class t_ARGTYPES_09,
7889 class t_ARGTYPES_10,
7890 class t_ARGTYPES_11,
7891 class t_ARGTYPES_12,
7892 class t_ARGTYPES_13>
7893struct InvokeResult_FuncPtrImp<
7894 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
7895 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
7896 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
7897 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
7898 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
7899 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
7900 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
7901 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
7902 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
7903 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
7904 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
7905 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
7906 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>(),
7907 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_13>()))>::type,
7908 t_FN,
7909 t_ARGTYPES_01,
7910 t_ARGTYPES_02,
7911 t_ARGTYPES_03,
7912 t_ARGTYPES_04,
7913 t_ARGTYPES_05,
7914 t_ARGTYPES_06,
7915 t_ARGTYPES_07,
7916 t_ARGTYPES_08,
7917 t_ARGTYPES_09,
7918 t_ARGTYPES_10,
7919 t_ARGTYPES_11,
7920 t_ARGTYPES_12,
7921 t_ARGTYPES_13> : InvokeResult_ImpUtils {
7922
7923
7924 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES_01>(),
7925 myDeclval<t_ARGTYPES_02>(),
7926 myDeclval<t_ARGTYPES_03>(),
7927 myDeclval<t_ARGTYPES_04>(),
7928 myDeclval<t_ARGTYPES_05>(),
7929 myDeclval<t_ARGTYPES_06>(),
7930 myDeclval<t_ARGTYPES_07>(),
7931 myDeclval<t_ARGTYPES_08>(),
7932 myDeclval<t_ARGTYPES_09>(),
7933 myDeclval<t_ARGTYPES_10>(),
7934 myDeclval<t_ARGTYPES_11>(),
7935 myDeclval<t_ARGTYPES_12>(),
7936 myDeclval<t_ARGTYPES_13>())) type;
7937};
7938#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
7939
7940#else
7941#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
7942template <class t_VOID_TYPE, class t_FN>
7943struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN> {
7944
7945 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
7946
7947 typedef typename bsl::conditional<
7948 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
7949 QType,
7950 typename bsl::remove_cv<QType>::type>::type type;
7951};
7952#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
7953
7954#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
7955template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01>
7956struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01> {
7957
7958 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
7959
7960 typedef typename bsl::conditional<
7961 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
7962 QType,
7963 typename bsl::remove_cv<QType>::type>::type type;
7964};
7965#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
7966
7967#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
7968template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7969 class t_ARGTYPES_02>
7970struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7971 t_ARGTYPES_02> {
7972
7973 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
7974
7975 typedef typename bsl::conditional<
7976 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
7977 QType,
7978 typename bsl::remove_cv<QType>::type>::type type;
7979};
7980#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
7981
7982#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
7983template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
7984 class t_ARGTYPES_02,
7985 class t_ARGTYPES_03>
7986struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
7987 t_ARGTYPES_02,
7988 t_ARGTYPES_03> {
7989
7990 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
7991
7992 typedef typename bsl::conditional<
7993 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
7994 QType,
7995 typename bsl::remove_cv<QType>::type>::type type;
7996};
7997#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
7998
7999#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
8000template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8001 class t_ARGTYPES_02,
8002 class t_ARGTYPES_03,
8003 class t_ARGTYPES_04>
8004struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8005 t_ARGTYPES_02,
8006 t_ARGTYPES_03,
8007 t_ARGTYPES_04> {
8008
8009 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8010
8011 typedef typename bsl::conditional<
8012 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8013 QType,
8014 typename bsl::remove_cv<QType>::type>::type type;
8015};
8016#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
8017
8018#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
8019template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8020 class t_ARGTYPES_02,
8021 class t_ARGTYPES_03,
8022 class t_ARGTYPES_04,
8023 class t_ARGTYPES_05>
8024struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8025 t_ARGTYPES_02,
8026 t_ARGTYPES_03,
8027 t_ARGTYPES_04,
8028 t_ARGTYPES_05> {
8029
8030 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8031
8032 typedef typename bsl::conditional<
8033 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8034 QType,
8035 typename bsl::remove_cv<QType>::type>::type type;
8036};
8037#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
8038
8039#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
8040template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8041 class t_ARGTYPES_02,
8042 class t_ARGTYPES_03,
8043 class t_ARGTYPES_04,
8044 class t_ARGTYPES_05,
8045 class t_ARGTYPES_06>
8046struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8047 t_ARGTYPES_02,
8048 t_ARGTYPES_03,
8049 t_ARGTYPES_04,
8050 t_ARGTYPES_05,
8051 t_ARGTYPES_06> {
8052
8053 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8054
8055 typedef typename bsl::conditional<
8056 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8057 QType,
8058 typename bsl::remove_cv<QType>::type>::type type;
8059};
8060#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
8061
8062#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
8063template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8064 class t_ARGTYPES_02,
8065 class t_ARGTYPES_03,
8066 class t_ARGTYPES_04,
8067 class t_ARGTYPES_05,
8068 class t_ARGTYPES_06,
8069 class t_ARGTYPES_07>
8070struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8071 t_ARGTYPES_02,
8072 t_ARGTYPES_03,
8073 t_ARGTYPES_04,
8074 t_ARGTYPES_05,
8075 t_ARGTYPES_06,
8076 t_ARGTYPES_07> {
8077
8078 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8079
8080 typedef typename bsl::conditional<
8081 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8082 QType,
8083 typename bsl::remove_cv<QType>::type>::type type;
8084};
8085#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
8086
8087#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
8088template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8089 class t_ARGTYPES_02,
8090 class t_ARGTYPES_03,
8091 class t_ARGTYPES_04,
8092 class t_ARGTYPES_05,
8093 class t_ARGTYPES_06,
8094 class t_ARGTYPES_07,
8095 class t_ARGTYPES_08>
8096struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8097 t_ARGTYPES_02,
8098 t_ARGTYPES_03,
8099 t_ARGTYPES_04,
8100 t_ARGTYPES_05,
8101 t_ARGTYPES_06,
8102 t_ARGTYPES_07,
8103 t_ARGTYPES_08> {
8104
8105 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8106
8107 typedef typename bsl::conditional<
8108 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8109 QType,
8110 typename bsl::remove_cv<QType>::type>::type type;
8111};
8112#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
8113
8114#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
8115template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8116 class t_ARGTYPES_02,
8117 class t_ARGTYPES_03,
8118 class t_ARGTYPES_04,
8119 class t_ARGTYPES_05,
8120 class t_ARGTYPES_06,
8121 class t_ARGTYPES_07,
8122 class t_ARGTYPES_08,
8123 class t_ARGTYPES_09>
8124struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8125 t_ARGTYPES_02,
8126 t_ARGTYPES_03,
8127 t_ARGTYPES_04,
8128 t_ARGTYPES_05,
8129 t_ARGTYPES_06,
8130 t_ARGTYPES_07,
8131 t_ARGTYPES_08,
8132 t_ARGTYPES_09> {
8133
8134 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8135
8136 typedef typename bsl::conditional<
8137 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8138 QType,
8139 typename bsl::remove_cv<QType>::type>::type type;
8140};
8141#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
8142
8143#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
8144template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8145 class t_ARGTYPES_02,
8146 class t_ARGTYPES_03,
8147 class t_ARGTYPES_04,
8148 class t_ARGTYPES_05,
8149 class t_ARGTYPES_06,
8150 class t_ARGTYPES_07,
8151 class t_ARGTYPES_08,
8152 class t_ARGTYPES_09,
8153 class t_ARGTYPES_10>
8154struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8155 t_ARGTYPES_02,
8156 t_ARGTYPES_03,
8157 t_ARGTYPES_04,
8158 t_ARGTYPES_05,
8159 t_ARGTYPES_06,
8160 t_ARGTYPES_07,
8161 t_ARGTYPES_08,
8162 t_ARGTYPES_09,
8163 t_ARGTYPES_10> {
8164
8165 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8166
8167 typedef typename bsl::conditional<
8168 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8169 QType,
8170 typename bsl::remove_cv<QType>::type>::type type;
8171};
8172#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
8173
8174#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
8175template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8176 class t_ARGTYPES_02,
8177 class t_ARGTYPES_03,
8178 class t_ARGTYPES_04,
8179 class t_ARGTYPES_05,
8180 class t_ARGTYPES_06,
8181 class t_ARGTYPES_07,
8182 class t_ARGTYPES_08,
8183 class t_ARGTYPES_09,
8184 class t_ARGTYPES_10,
8185 class t_ARGTYPES_11>
8186struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8187 t_ARGTYPES_02,
8188 t_ARGTYPES_03,
8189 t_ARGTYPES_04,
8190 t_ARGTYPES_05,
8191 t_ARGTYPES_06,
8192 t_ARGTYPES_07,
8193 t_ARGTYPES_08,
8194 t_ARGTYPES_09,
8195 t_ARGTYPES_10,
8196 t_ARGTYPES_11> {
8197
8198 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8199
8200 typedef typename bsl::conditional<
8201 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8202 QType,
8203 typename bsl::remove_cv<QType>::type>::type type;
8204};
8205#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
8206
8207#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
8208template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8209 class t_ARGTYPES_02,
8210 class t_ARGTYPES_03,
8211 class t_ARGTYPES_04,
8212 class t_ARGTYPES_05,
8213 class t_ARGTYPES_06,
8214 class t_ARGTYPES_07,
8215 class t_ARGTYPES_08,
8216 class t_ARGTYPES_09,
8217 class t_ARGTYPES_10,
8218 class t_ARGTYPES_11,
8219 class t_ARGTYPES_12>
8220struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8221 t_ARGTYPES_02,
8222 t_ARGTYPES_03,
8223 t_ARGTYPES_04,
8224 t_ARGTYPES_05,
8225 t_ARGTYPES_06,
8226 t_ARGTYPES_07,
8227 t_ARGTYPES_08,
8228 t_ARGTYPES_09,
8229 t_ARGTYPES_10,
8230 t_ARGTYPES_11,
8231 t_ARGTYPES_12> {
8232
8233 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8234
8235 typedef typename bsl::conditional<
8236 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8237 QType,
8238 typename bsl::remove_cv<QType>::type>::type type;
8239};
8240#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
8241
8242#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
8243template <class t_VOID_TYPE, class t_FN, class t_ARGTYPES_01,
8244 class t_ARGTYPES_02,
8245 class t_ARGTYPES_03,
8246 class t_ARGTYPES_04,
8247 class t_ARGTYPES_05,
8248 class t_ARGTYPES_06,
8249 class t_ARGTYPES_07,
8250 class t_ARGTYPES_08,
8251 class t_ARGTYPES_09,
8252 class t_ARGTYPES_10,
8253 class t_ARGTYPES_11,
8254 class t_ARGTYPES_12,
8255 class t_ARGTYPES_13>
8256struct InvokeResult_FuncPtrImp<t_VOID_TYPE, t_FN, t_ARGTYPES_01,
8257 t_ARGTYPES_02,
8258 t_ARGTYPES_03,
8259 t_ARGTYPES_04,
8260 t_ARGTYPES_05,
8261 t_ARGTYPES_06,
8262 t_ARGTYPES_07,
8263 t_ARGTYPES_08,
8264 t_ARGTYPES_09,
8265 t_ARGTYPES_10,
8266 t_ARGTYPES_11,
8267 t_ARGTYPES_12,
8268 t_ARGTYPES_13> {
8269
8270 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
8271
8272 typedef typename bsl::conditional<
8273 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8274 QType,
8275 typename bsl::remove_cv<QType>::type>::type type;
8276};
8277#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
8278
8279#endif
8280
8281
8282#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
8283template <class t_VOID_TYPE,
8284 bool t_ARG1_DERIVES_FROM_CLASS,
8285 bool t_ARG1_IS_REFERENCE_WRAPPER,
8286 class t_FN,
8287 class t_ARG1TYPE
8288#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
8289 , class t_ARGTYPES_0 = BSLS_COMPILERFEATURES_NILT
8290#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
8291
8292#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
8293 , class t_ARGTYPES_1 = BSLS_COMPILERFEATURES_NILT
8294#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
8295
8296#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
8297 , class t_ARGTYPES_2 = BSLS_COMPILERFEATURES_NILT
8298#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
8299
8300#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
8301 , class t_ARGTYPES_3 = BSLS_COMPILERFEATURES_NILT
8302#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
8303
8304#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
8305 , class t_ARGTYPES_4 = BSLS_COMPILERFEATURES_NILT
8306#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
8307
8308#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
8309 , class t_ARGTYPES_5 = BSLS_COMPILERFEATURES_NILT
8310#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
8311
8312#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
8313 , class t_ARGTYPES_6 = BSLS_COMPILERFEATURES_NILT
8314#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
8315
8316#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
8317 , class t_ARGTYPES_7 = BSLS_COMPILERFEATURES_NILT
8318#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
8319
8320#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
8321 , class t_ARGTYPES_8 = BSLS_COMPILERFEATURES_NILT
8322#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
8323
8324#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
8325 , class t_ARGTYPES_9 = BSLS_COMPILERFEATURES_NILT
8326#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
8327
8328#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
8329 , class t_ARGTYPES_10 = BSLS_COMPILERFEATURES_NILT
8330#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
8331
8332#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
8333 , class t_ARGTYPES_11 = BSLS_COMPILERFEATURES_NILT
8334#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
8335
8336#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
8337 , class t_ARGTYPES_12 = BSLS_COMPILERFEATURES_NILT
8338#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
8339 , class = BSLS_COMPILERFEATURES_NILT>
8340struct InvokeResult_MemFuncPtrImpDispatch;
8341
8342
8343
8344template <class t_FN>
8345struct InvokeResult_MemFuncPtrImp<t_FN> {
8346};
8347
8348#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
8349template <class t_FN, class t_ARG1TYPE>
8350struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE>
8351: InvokeResult_MemFuncPtrImpDispatch<
8352 void,
8353 IsAccessibleBaseOf<
8354 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8355 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8356 IsReferenceWrapper<typename bsl::remove_const<
8357 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8358 t_FN,
8359 t_ARG1TYPE> {
8360};
8361#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
8362
8363#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
8364template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01>
8365struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01>
8366: InvokeResult_MemFuncPtrImpDispatch<
8367 void,
8368 IsAccessibleBaseOf<
8369 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8370 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8371 IsReferenceWrapper<typename bsl::remove_const<
8372 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8373 t_FN,
8374 t_ARG1TYPE,
8375 t_ARGTYPES_01> {
8376};
8377#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
8378
8379#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
8380template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8381 class t_ARGTYPES_02>
8382struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8383 t_ARGTYPES_02>
8384: InvokeResult_MemFuncPtrImpDispatch<
8385 void,
8386 IsAccessibleBaseOf<
8387 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8388 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8389 IsReferenceWrapper<typename bsl::remove_const<
8390 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8391 t_FN,
8392 t_ARG1TYPE,
8393 t_ARGTYPES_01,
8394 t_ARGTYPES_02> {
8395};
8396#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
8397
8398#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
8399template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8400 class t_ARGTYPES_02,
8401 class t_ARGTYPES_03>
8402struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8403 t_ARGTYPES_02,
8404 t_ARGTYPES_03>
8405: InvokeResult_MemFuncPtrImpDispatch<
8406 void,
8407 IsAccessibleBaseOf<
8408 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8409 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8410 IsReferenceWrapper<typename bsl::remove_const<
8411 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8412 t_FN,
8413 t_ARG1TYPE,
8414 t_ARGTYPES_01,
8415 t_ARGTYPES_02,
8416 t_ARGTYPES_03> {
8417};
8418#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
8419
8420#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
8421template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8422 class t_ARGTYPES_02,
8423 class t_ARGTYPES_03,
8424 class t_ARGTYPES_04>
8425struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8426 t_ARGTYPES_02,
8427 t_ARGTYPES_03,
8428 t_ARGTYPES_04>
8429: InvokeResult_MemFuncPtrImpDispatch<
8430 void,
8431 IsAccessibleBaseOf<
8432 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8433 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8434 IsReferenceWrapper<typename bsl::remove_const<
8435 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8436 t_FN,
8437 t_ARG1TYPE,
8438 t_ARGTYPES_01,
8439 t_ARGTYPES_02,
8440 t_ARGTYPES_03,
8441 t_ARGTYPES_04> {
8442};
8443#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
8444
8445#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
8446template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8447 class t_ARGTYPES_02,
8448 class t_ARGTYPES_03,
8449 class t_ARGTYPES_04,
8450 class t_ARGTYPES_05>
8451struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8452 t_ARGTYPES_02,
8453 t_ARGTYPES_03,
8454 t_ARGTYPES_04,
8455 t_ARGTYPES_05>
8456: InvokeResult_MemFuncPtrImpDispatch<
8457 void,
8458 IsAccessibleBaseOf<
8459 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8460 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8461 IsReferenceWrapper<typename bsl::remove_const<
8462 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8463 t_FN,
8464 t_ARG1TYPE,
8465 t_ARGTYPES_01,
8466 t_ARGTYPES_02,
8467 t_ARGTYPES_03,
8468 t_ARGTYPES_04,
8469 t_ARGTYPES_05> {
8470};
8471#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
8472
8473#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
8474template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8475 class t_ARGTYPES_02,
8476 class t_ARGTYPES_03,
8477 class t_ARGTYPES_04,
8478 class t_ARGTYPES_05,
8479 class t_ARGTYPES_06>
8480struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8481 t_ARGTYPES_02,
8482 t_ARGTYPES_03,
8483 t_ARGTYPES_04,
8484 t_ARGTYPES_05,
8485 t_ARGTYPES_06>
8486: InvokeResult_MemFuncPtrImpDispatch<
8487 void,
8488 IsAccessibleBaseOf<
8489 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8490 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8491 IsReferenceWrapper<typename bsl::remove_const<
8492 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8493 t_FN,
8494 t_ARG1TYPE,
8495 t_ARGTYPES_01,
8496 t_ARGTYPES_02,
8497 t_ARGTYPES_03,
8498 t_ARGTYPES_04,
8499 t_ARGTYPES_05,
8500 t_ARGTYPES_06> {
8501};
8502#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
8503
8504#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
8505template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8506 class t_ARGTYPES_02,
8507 class t_ARGTYPES_03,
8508 class t_ARGTYPES_04,
8509 class t_ARGTYPES_05,
8510 class t_ARGTYPES_06,
8511 class t_ARGTYPES_07>
8512struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8513 t_ARGTYPES_02,
8514 t_ARGTYPES_03,
8515 t_ARGTYPES_04,
8516 t_ARGTYPES_05,
8517 t_ARGTYPES_06,
8518 t_ARGTYPES_07>
8519: InvokeResult_MemFuncPtrImpDispatch<
8520 void,
8521 IsAccessibleBaseOf<
8522 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8523 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8524 IsReferenceWrapper<typename bsl::remove_const<
8525 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8526 t_FN,
8527 t_ARG1TYPE,
8528 t_ARGTYPES_01,
8529 t_ARGTYPES_02,
8530 t_ARGTYPES_03,
8531 t_ARGTYPES_04,
8532 t_ARGTYPES_05,
8533 t_ARGTYPES_06,
8534 t_ARGTYPES_07> {
8535};
8536#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
8537
8538#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
8539template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8540 class t_ARGTYPES_02,
8541 class t_ARGTYPES_03,
8542 class t_ARGTYPES_04,
8543 class t_ARGTYPES_05,
8544 class t_ARGTYPES_06,
8545 class t_ARGTYPES_07,
8546 class t_ARGTYPES_08>
8547struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8548 t_ARGTYPES_02,
8549 t_ARGTYPES_03,
8550 t_ARGTYPES_04,
8551 t_ARGTYPES_05,
8552 t_ARGTYPES_06,
8553 t_ARGTYPES_07,
8554 t_ARGTYPES_08>
8555: InvokeResult_MemFuncPtrImpDispatch<
8556 void,
8557 IsAccessibleBaseOf<
8558 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8559 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8560 IsReferenceWrapper<typename bsl::remove_const<
8561 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8562 t_FN,
8563 t_ARG1TYPE,
8564 t_ARGTYPES_01,
8565 t_ARGTYPES_02,
8566 t_ARGTYPES_03,
8567 t_ARGTYPES_04,
8568 t_ARGTYPES_05,
8569 t_ARGTYPES_06,
8570 t_ARGTYPES_07,
8571 t_ARGTYPES_08> {
8572};
8573#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
8574
8575#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
8576template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8577 class t_ARGTYPES_02,
8578 class t_ARGTYPES_03,
8579 class t_ARGTYPES_04,
8580 class t_ARGTYPES_05,
8581 class t_ARGTYPES_06,
8582 class t_ARGTYPES_07,
8583 class t_ARGTYPES_08,
8584 class t_ARGTYPES_09>
8585struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8586 t_ARGTYPES_02,
8587 t_ARGTYPES_03,
8588 t_ARGTYPES_04,
8589 t_ARGTYPES_05,
8590 t_ARGTYPES_06,
8591 t_ARGTYPES_07,
8592 t_ARGTYPES_08,
8593 t_ARGTYPES_09>
8594: InvokeResult_MemFuncPtrImpDispatch<
8595 void,
8596 IsAccessibleBaseOf<
8597 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8598 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8599 IsReferenceWrapper<typename bsl::remove_const<
8600 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8601 t_FN,
8602 t_ARG1TYPE,
8603 t_ARGTYPES_01,
8604 t_ARGTYPES_02,
8605 t_ARGTYPES_03,
8606 t_ARGTYPES_04,
8607 t_ARGTYPES_05,
8608 t_ARGTYPES_06,
8609 t_ARGTYPES_07,
8610 t_ARGTYPES_08,
8611 t_ARGTYPES_09> {
8612};
8613#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
8614
8615#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
8616template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8617 class t_ARGTYPES_02,
8618 class t_ARGTYPES_03,
8619 class t_ARGTYPES_04,
8620 class t_ARGTYPES_05,
8621 class t_ARGTYPES_06,
8622 class t_ARGTYPES_07,
8623 class t_ARGTYPES_08,
8624 class t_ARGTYPES_09,
8625 class t_ARGTYPES_10>
8626struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8627 t_ARGTYPES_02,
8628 t_ARGTYPES_03,
8629 t_ARGTYPES_04,
8630 t_ARGTYPES_05,
8631 t_ARGTYPES_06,
8632 t_ARGTYPES_07,
8633 t_ARGTYPES_08,
8634 t_ARGTYPES_09,
8635 t_ARGTYPES_10>
8636: InvokeResult_MemFuncPtrImpDispatch<
8637 void,
8638 IsAccessibleBaseOf<
8639 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8640 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8641 IsReferenceWrapper<typename bsl::remove_const<
8642 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8643 t_FN,
8644 t_ARG1TYPE,
8645 t_ARGTYPES_01,
8646 t_ARGTYPES_02,
8647 t_ARGTYPES_03,
8648 t_ARGTYPES_04,
8649 t_ARGTYPES_05,
8650 t_ARGTYPES_06,
8651 t_ARGTYPES_07,
8652 t_ARGTYPES_08,
8653 t_ARGTYPES_09,
8654 t_ARGTYPES_10> {
8655};
8656#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
8657
8658#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
8659template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8660 class t_ARGTYPES_02,
8661 class t_ARGTYPES_03,
8662 class t_ARGTYPES_04,
8663 class t_ARGTYPES_05,
8664 class t_ARGTYPES_06,
8665 class t_ARGTYPES_07,
8666 class t_ARGTYPES_08,
8667 class t_ARGTYPES_09,
8668 class t_ARGTYPES_10,
8669 class t_ARGTYPES_11>
8670struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8671 t_ARGTYPES_02,
8672 t_ARGTYPES_03,
8673 t_ARGTYPES_04,
8674 t_ARGTYPES_05,
8675 t_ARGTYPES_06,
8676 t_ARGTYPES_07,
8677 t_ARGTYPES_08,
8678 t_ARGTYPES_09,
8679 t_ARGTYPES_10,
8680 t_ARGTYPES_11>
8681: InvokeResult_MemFuncPtrImpDispatch<
8682 void,
8683 IsAccessibleBaseOf<
8684 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8685 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8686 IsReferenceWrapper<typename bsl::remove_const<
8687 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8688 t_FN,
8689 t_ARG1TYPE,
8690 t_ARGTYPES_01,
8691 t_ARGTYPES_02,
8692 t_ARGTYPES_03,
8693 t_ARGTYPES_04,
8694 t_ARGTYPES_05,
8695 t_ARGTYPES_06,
8696 t_ARGTYPES_07,
8697 t_ARGTYPES_08,
8698 t_ARGTYPES_09,
8699 t_ARGTYPES_10,
8700 t_ARGTYPES_11> {
8701};
8702#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
8703
8704#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
8705template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8706 class t_ARGTYPES_02,
8707 class t_ARGTYPES_03,
8708 class t_ARGTYPES_04,
8709 class t_ARGTYPES_05,
8710 class t_ARGTYPES_06,
8711 class t_ARGTYPES_07,
8712 class t_ARGTYPES_08,
8713 class t_ARGTYPES_09,
8714 class t_ARGTYPES_10,
8715 class t_ARGTYPES_11,
8716 class t_ARGTYPES_12>
8717struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8718 t_ARGTYPES_02,
8719 t_ARGTYPES_03,
8720 t_ARGTYPES_04,
8721 t_ARGTYPES_05,
8722 t_ARGTYPES_06,
8723 t_ARGTYPES_07,
8724 t_ARGTYPES_08,
8725 t_ARGTYPES_09,
8726 t_ARGTYPES_10,
8727 t_ARGTYPES_11,
8728 t_ARGTYPES_12>
8729: InvokeResult_MemFuncPtrImpDispatch<
8730 void,
8731 IsAccessibleBaseOf<
8732 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8733 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8734 IsReferenceWrapper<typename bsl::remove_const<
8735 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8736 t_FN,
8737 t_ARG1TYPE,
8738 t_ARGTYPES_01,
8739 t_ARGTYPES_02,
8740 t_ARGTYPES_03,
8741 t_ARGTYPES_04,
8742 t_ARGTYPES_05,
8743 t_ARGTYPES_06,
8744 t_ARGTYPES_07,
8745 t_ARGTYPES_08,
8746 t_ARGTYPES_09,
8747 t_ARGTYPES_10,
8748 t_ARGTYPES_11,
8749 t_ARGTYPES_12> {
8750};
8751#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
8752
8753#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
8754template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
8755 class t_ARGTYPES_02,
8756 class t_ARGTYPES_03,
8757 class t_ARGTYPES_04,
8758 class t_ARGTYPES_05,
8759 class t_ARGTYPES_06,
8760 class t_ARGTYPES_07,
8761 class t_ARGTYPES_08,
8762 class t_ARGTYPES_09,
8763 class t_ARGTYPES_10,
8764 class t_ARGTYPES_11,
8765 class t_ARGTYPES_12,
8766 class t_ARGTYPES_13>
8767struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES_01,
8768 t_ARGTYPES_02,
8769 t_ARGTYPES_03,
8770 t_ARGTYPES_04,
8771 t_ARGTYPES_05,
8772 t_ARGTYPES_06,
8773 t_ARGTYPES_07,
8774 t_ARGTYPES_08,
8775 t_ARGTYPES_09,
8776 t_ARGTYPES_10,
8777 t_ARGTYPES_11,
8778 t_ARGTYPES_12,
8779 t_ARGTYPES_13>
8780: InvokeResult_MemFuncPtrImpDispatch<
8781 void,
8782 IsAccessibleBaseOf<
8783 typename MemberFunctionPointerTraits<t_FN>::ClassType,
8784 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
8785 IsReferenceWrapper<typename bsl::remove_const<
8786 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
8787 t_FN,
8788 t_ARG1TYPE,
8789 t_ARGTYPES_01,
8790 t_ARGTYPES_02,
8791 t_ARGTYPES_03,
8792 t_ARGTYPES_04,
8793 t_ARGTYPES_05,
8794 t_ARGTYPES_06,
8795 t_ARGTYPES_07,
8796 t_ARGTYPES_08,
8797 t_ARGTYPES_09,
8798 t_ARGTYPES_10,
8799 t_ARGTYPES_11,
8800 t_ARGTYPES_12,
8801 t_ARGTYPES_13> {
8802};
8803#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
8804
8805#else
8806#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
8807template <class t_FN>
8808struct InvokeResult_MemFuncPtrImp<t_FN> {
8809
8810 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
8811
8812 typedef typename bsl::conditional<
8813 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8814 QType,
8815 typename bsl::remove_cv<QType>::type>::type type;
8816};
8817#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
8818
8819#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
8820template <class t_FN, class t_ARGTYPES_01>
8821struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01> {
8822
8823 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
8824
8825 typedef typename bsl::conditional<
8826 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8827 QType,
8828 typename bsl::remove_cv<QType>::type>::type type;
8829};
8830#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
8831
8832#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
8833template <class t_FN, class t_ARGTYPES_01,
8834 class t_ARGTYPES_02>
8835struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
8836 t_ARGTYPES_02> {
8837
8838 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
8839
8840 typedef typename bsl::conditional<
8841 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8842 QType,
8843 typename bsl::remove_cv<QType>::type>::type type;
8844};
8845#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
8846
8847#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
8848template <class t_FN, class t_ARGTYPES_01,
8849 class t_ARGTYPES_02,
8850 class t_ARGTYPES_03>
8851struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
8852 t_ARGTYPES_02,
8853 t_ARGTYPES_03> {
8854
8855 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
8856
8857 typedef typename bsl::conditional<
8858 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8859 QType,
8860 typename bsl::remove_cv<QType>::type>::type type;
8861};
8862#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
8863
8864#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
8865template <class t_FN, class t_ARGTYPES_01,
8866 class t_ARGTYPES_02,
8867 class t_ARGTYPES_03,
8868 class t_ARGTYPES_04>
8869struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
8870 t_ARGTYPES_02,
8871 t_ARGTYPES_03,
8872 t_ARGTYPES_04> {
8873
8874 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
8875
8876 typedef typename bsl::conditional<
8877 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8878 QType,
8879 typename bsl::remove_cv<QType>::type>::type type;
8880};
8881#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
8882
8883#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
8884template <class t_FN, class t_ARGTYPES_01,
8885 class t_ARGTYPES_02,
8886 class t_ARGTYPES_03,
8887 class t_ARGTYPES_04,
8888 class t_ARGTYPES_05>
8889struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
8890 t_ARGTYPES_02,
8891 t_ARGTYPES_03,
8892 t_ARGTYPES_04,
8893 t_ARGTYPES_05> {
8894
8895 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
8896
8897 typedef typename bsl::conditional<
8898 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8899 QType,
8900 typename bsl::remove_cv<QType>::type>::type type;
8901};
8902#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
8903
8904#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
8905template <class t_FN, class t_ARGTYPES_01,
8906 class t_ARGTYPES_02,
8907 class t_ARGTYPES_03,
8908 class t_ARGTYPES_04,
8909 class t_ARGTYPES_05,
8910 class t_ARGTYPES_06>
8911struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
8912 t_ARGTYPES_02,
8913 t_ARGTYPES_03,
8914 t_ARGTYPES_04,
8915 t_ARGTYPES_05,
8916 t_ARGTYPES_06> {
8917
8918 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
8919
8920 typedef typename bsl::conditional<
8921 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8922 QType,
8923 typename bsl::remove_cv<QType>::type>::type type;
8924};
8925#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
8926
8927#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
8928template <class t_FN, class t_ARGTYPES_01,
8929 class t_ARGTYPES_02,
8930 class t_ARGTYPES_03,
8931 class t_ARGTYPES_04,
8932 class t_ARGTYPES_05,
8933 class t_ARGTYPES_06,
8934 class t_ARGTYPES_07>
8935struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
8936 t_ARGTYPES_02,
8937 t_ARGTYPES_03,
8938 t_ARGTYPES_04,
8939 t_ARGTYPES_05,
8940 t_ARGTYPES_06,
8941 t_ARGTYPES_07> {
8942
8943 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
8944
8945 typedef typename bsl::conditional<
8946 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8947 QType,
8948 typename bsl::remove_cv<QType>::type>::type type;
8949};
8950#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
8951
8952#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
8953template <class t_FN, class t_ARGTYPES_01,
8954 class t_ARGTYPES_02,
8955 class t_ARGTYPES_03,
8956 class t_ARGTYPES_04,
8957 class t_ARGTYPES_05,
8958 class t_ARGTYPES_06,
8959 class t_ARGTYPES_07,
8960 class t_ARGTYPES_08>
8961struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
8962 t_ARGTYPES_02,
8963 t_ARGTYPES_03,
8964 t_ARGTYPES_04,
8965 t_ARGTYPES_05,
8966 t_ARGTYPES_06,
8967 t_ARGTYPES_07,
8968 t_ARGTYPES_08> {
8969
8970 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
8971
8972 typedef typename bsl::conditional<
8973 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
8974 QType,
8975 typename bsl::remove_cv<QType>::type>::type type;
8976};
8977#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
8978
8979#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
8980template <class t_FN, class t_ARGTYPES_01,
8981 class t_ARGTYPES_02,
8982 class t_ARGTYPES_03,
8983 class t_ARGTYPES_04,
8984 class t_ARGTYPES_05,
8985 class t_ARGTYPES_06,
8986 class t_ARGTYPES_07,
8987 class t_ARGTYPES_08,
8988 class t_ARGTYPES_09>
8989struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
8990 t_ARGTYPES_02,
8991 t_ARGTYPES_03,
8992 t_ARGTYPES_04,
8993 t_ARGTYPES_05,
8994 t_ARGTYPES_06,
8995 t_ARGTYPES_07,
8996 t_ARGTYPES_08,
8997 t_ARGTYPES_09> {
8998
8999 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
9000
9001 typedef typename bsl::conditional<
9002 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
9003 QType,
9004 typename bsl::remove_cv<QType>::type>::type type;
9005};
9006#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
9007
9008#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
9009template <class t_FN, class t_ARGTYPES_01,
9010 class t_ARGTYPES_02,
9011 class t_ARGTYPES_03,
9012 class t_ARGTYPES_04,
9013 class t_ARGTYPES_05,
9014 class t_ARGTYPES_06,
9015 class t_ARGTYPES_07,
9016 class t_ARGTYPES_08,
9017 class t_ARGTYPES_09,
9018 class t_ARGTYPES_10>
9019struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
9020 t_ARGTYPES_02,
9021 t_ARGTYPES_03,
9022 t_ARGTYPES_04,
9023 t_ARGTYPES_05,
9024 t_ARGTYPES_06,
9025 t_ARGTYPES_07,
9026 t_ARGTYPES_08,
9027 t_ARGTYPES_09,
9028 t_ARGTYPES_10> {
9029
9030 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
9031
9032 typedef typename bsl::conditional<
9033 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
9034 QType,
9035 typename bsl::remove_cv<QType>::type>::type type;
9036};
9037#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
9038
9039#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
9040template <class t_FN, class t_ARGTYPES_01,
9041 class t_ARGTYPES_02,
9042 class t_ARGTYPES_03,
9043 class t_ARGTYPES_04,
9044 class t_ARGTYPES_05,
9045 class t_ARGTYPES_06,
9046 class t_ARGTYPES_07,
9047 class t_ARGTYPES_08,
9048 class t_ARGTYPES_09,
9049 class t_ARGTYPES_10,
9050 class t_ARGTYPES_11>
9051struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
9052 t_ARGTYPES_02,
9053 t_ARGTYPES_03,
9054 t_ARGTYPES_04,
9055 t_ARGTYPES_05,
9056 t_ARGTYPES_06,
9057 t_ARGTYPES_07,
9058 t_ARGTYPES_08,
9059 t_ARGTYPES_09,
9060 t_ARGTYPES_10,
9061 t_ARGTYPES_11> {
9062
9063 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
9064
9065 typedef typename bsl::conditional<
9066 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
9067 QType,
9068 typename bsl::remove_cv<QType>::type>::type type;
9069};
9070#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
9071
9072#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
9073template <class t_FN, class t_ARGTYPES_01,
9074 class t_ARGTYPES_02,
9075 class t_ARGTYPES_03,
9076 class t_ARGTYPES_04,
9077 class t_ARGTYPES_05,
9078 class t_ARGTYPES_06,
9079 class t_ARGTYPES_07,
9080 class t_ARGTYPES_08,
9081 class t_ARGTYPES_09,
9082 class t_ARGTYPES_10,
9083 class t_ARGTYPES_11,
9084 class t_ARGTYPES_12>
9085struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
9086 t_ARGTYPES_02,
9087 t_ARGTYPES_03,
9088 t_ARGTYPES_04,
9089 t_ARGTYPES_05,
9090 t_ARGTYPES_06,
9091 t_ARGTYPES_07,
9092 t_ARGTYPES_08,
9093 t_ARGTYPES_09,
9094 t_ARGTYPES_10,
9095 t_ARGTYPES_11,
9096 t_ARGTYPES_12> {
9097
9098 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
9099
9100 typedef typename bsl::conditional<
9101 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
9102 QType,
9103 typename bsl::remove_cv<QType>::type>::type type;
9104};
9105#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
9106
9107#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
9108template <class t_FN, class t_ARGTYPES_01,
9109 class t_ARGTYPES_02,
9110 class t_ARGTYPES_03,
9111 class t_ARGTYPES_04,
9112 class t_ARGTYPES_05,
9113 class t_ARGTYPES_06,
9114 class t_ARGTYPES_07,
9115 class t_ARGTYPES_08,
9116 class t_ARGTYPES_09,
9117 class t_ARGTYPES_10,
9118 class t_ARGTYPES_11,
9119 class t_ARGTYPES_12,
9120 class t_ARGTYPES_13>
9121struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES_01,
9122 t_ARGTYPES_02,
9123 t_ARGTYPES_03,
9124 t_ARGTYPES_04,
9125 t_ARGTYPES_05,
9126 t_ARGTYPES_06,
9127 t_ARGTYPES_07,
9128 t_ARGTYPES_08,
9129 t_ARGTYPES_09,
9130 t_ARGTYPES_10,
9131 t_ARGTYPES_11,
9132 t_ARGTYPES_12,
9133 t_ARGTYPES_13> {
9134
9135 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
9136
9137 typedef typename bsl::conditional<
9138 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
9139 QType,
9140 typename bsl::remove_cv<QType>::type>::type type;
9141};
9142#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
9143
9144#endif
9145
9146
9147#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
9148#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
9149template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9150 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE>
9151struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE> {
9152};
9153#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
9154
9155#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
9156template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9157 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9158 class t_ARGTYPES_01>
9159struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9160 t_ARGTYPES_01> {
9161};
9162#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
9163
9164#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
9165template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9166 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9167 class t_ARGTYPES_01,
9168 class t_ARGTYPES_02>
9169struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9170 t_ARGTYPES_01,
9171 t_ARGTYPES_02> {
9172};
9173#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
9174
9175#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
9176template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9177 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9178 class t_ARGTYPES_01,
9179 class t_ARGTYPES_02,
9180 class t_ARGTYPES_03>
9181struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9182 t_ARGTYPES_01,
9183 t_ARGTYPES_02,
9184 t_ARGTYPES_03> {
9185};
9186#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
9187
9188#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
9189template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9190 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9191 class t_ARGTYPES_01,
9192 class t_ARGTYPES_02,
9193 class t_ARGTYPES_03,
9194 class t_ARGTYPES_04>
9195struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9196 t_ARGTYPES_01,
9197 t_ARGTYPES_02,
9198 t_ARGTYPES_03,
9199 t_ARGTYPES_04> {
9200};
9201#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
9202
9203#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
9204template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9205 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9206 class t_ARGTYPES_01,
9207 class t_ARGTYPES_02,
9208 class t_ARGTYPES_03,
9209 class t_ARGTYPES_04,
9210 class t_ARGTYPES_05>
9211struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9212 t_ARGTYPES_01,
9213 t_ARGTYPES_02,
9214 t_ARGTYPES_03,
9215 t_ARGTYPES_04,
9216 t_ARGTYPES_05> {
9217};
9218#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
9219
9220#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
9221template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9222 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9223 class t_ARGTYPES_01,
9224 class t_ARGTYPES_02,
9225 class t_ARGTYPES_03,
9226 class t_ARGTYPES_04,
9227 class t_ARGTYPES_05,
9228 class t_ARGTYPES_06>
9229struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9230 t_ARGTYPES_01,
9231 t_ARGTYPES_02,
9232 t_ARGTYPES_03,
9233 t_ARGTYPES_04,
9234 t_ARGTYPES_05,
9235 t_ARGTYPES_06> {
9236};
9237#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
9238
9239#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
9240template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9241 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9242 class t_ARGTYPES_01,
9243 class t_ARGTYPES_02,
9244 class t_ARGTYPES_03,
9245 class t_ARGTYPES_04,
9246 class t_ARGTYPES_05,
9247 class t_ARGTYPES_06,
9248 class t_ARGTYPES_07>
9249struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9250 t_ARGTYPES_01,
9251 t_ARGTYPES_02,
9252 t_ARGTYPES_03,
9253 t_ARGTYPES_04,
9254 t_ARGTYPES_05,
9255 t_ARGTYPES_06,
9256 t_ARGTYPES_07> {
9257};
9258#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
9259
9260#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
9261template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9262 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9263 class t_ARGTYPES_01,
9264 class t_ARGTYPES_02,
9265 class t_ARGTYPES_03,
9266 class t_ARGTYPES_04,
9267 class t_ARGTYPES_05,
9268 class t_ARGTYPES_06,
9269 class t_ARGTYPES_07,
9270 class t_ARGTYPES_08>
9271struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9272 t_ARGTYPES_01,
9273 t_ARGTYPES_02,
9274 t_ARGTYPES_03,
9275 t_ARGTYPES_04,
9276 t_ARGTYPES_05,
9277 t_ARGTYPES_06,
9278 t_ARGTYPES_07,
9279 t_ARGTYPES_08> {
9280};
9281#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
9282
9283#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
9284template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9285 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9286 class t_ARGTYPES_01,
9287 class t_ARGTYPES_02,
9288 class t_ARGTYPES_03,
9289 class t_ARGTYPES_04,
9290 class t_ARGTYPES_05,
9291 class t_ARGTYPES_06,
9292 class t_ARGTYPES_07,
9293 class t_ARGTYPES_08,
9294 class t_ARGTYPES_09>
9295struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9296 t_ARGTYPES_01,
9297 t_ARGTYPES_02,
9298 t_ARGTYPES_03,
9299 t_ARGTYPES_04,
9300 t_ARGTYPES_05,
9301 t_ARGTYPES_06,
9302 t_ARGTYPES_07,
9303 t_ARGTYPES_08,
9304 t_ARGTYPES_09> {
9305};
9306#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
9307
9308#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
9309template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9310 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9311 class t_ARGTYPES_01,
9312 class t_ARGTYPES_02,
9313 class t_ARGTYPES_03,
9314 class t_ARGTYPES_04,
9315 class t_ARGTYPES_05,
9316 class t_ARGTYPES_06,
9317 class t_ARGTYPES_07,
9318 class t_ARGTYPES_08,
9319 class t_ARGTYPES_09,
9320 class t_ARGTYPES_10>
9321struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9322 t_ARGTYPES_01,
9323 t_ARGTYPES_02,
9324 t_ARGTYPES_03,
9325 t_ARGTYPES_04,
9326 t_ARGTYPES_05,
9327 t_ARGTYPES_06,
9328 t_ARGTYPES_07,
9329 t_ARGTYPES_08,
9330 t_ARGTYPES_09,
9331 t_ARGTYPES_10> {
9332};
9333#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
9334
9335#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
9336template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9337 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9338 class t_ARGTYPES_01,
9339 class t_ARGTYPES_02,
9340 class t_ARGTYPES_03,
9341 class t_ARGTYPES_04,
9342 class t_ARGTYPES_05,
9343 class t_ARGTYPES_06,
9344 class t_ARGTYPES_07,
9345 class t_ARGTYPES_08,
9346 class t_ARGTYPES_09,
9347 class t_ARGTYPES_10,
9348 class t_ARGTYPES_11>
9349struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9350 t_ARGTYPES_01,
9351 t_ARGTYPES_02,
9352 t_ARGTYPES_03,
9353 t_ARGTYPES_04,
9354 t_ARGTYPES_05,
9355 t_ARGTYPES_06,
9356 t_ARGTYPES_07,
9357 t_ARGTYPES_08,
9358 t_ARGTYPES_09,
9359 t_ARGTYPES_10,
9360 t_ARGTYPES_11> {
9361};
9362#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
9363
9364#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
9365template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9366 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9367 class t_ARGTYPES_01,
9368 class t_ARGTYPES_02,
9369 class t_ARGTYPES_03,
9370 class t_ARGTYPES_04,
9371 class t_ARGTYPES_05,
9372 class t_ARGTYPES_06,
9373 class t_ARGTYPES_07,
9374 class t_ARGTYPES_08,
9375 class t_ARGTYPES_09,
9376 class t_ARGTYPES_10,
9377 class t_ARGTYPES_11,
9378 class t_ARGTYPES_12>
9379struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9380 t_ARGTYPES_01,
9381 t_ARGTYPES_02,
9382 t_ARGTYPES_03,
9383 t_ARGTYPES_04,
9384 t_ARGTYPES_05,
9385 t_ARGTYPES_06,
9386 t_ARGTYPES_07,
9387 t_ARGTYPES_08,
9388 t_ARGTYPES_09,
9389 t_ARGTYPES_10,
9390 t_ARGTYPES_11,
9391 t_ARGTYPES_12> {
9392};
9393#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
9394
9395#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
9396template <class t_VOID_TYPE, bool t_ARG1_DERIVES_FROM_CLASS,
9397 bool t_ARG1_IS_REFERENCE_WRAPPER, class t_FN, class t_ARG1TYPE,
9398 class t_ARGTYPES_01,
9399 class t_ARGTYPES_02,
9400 class t_ARGTYPES_03,
9401 class t_ARGTYPES_04,
9402 class t_ARGTYPES_05,
9403 class t_ARGTYPES_06,
9404 class t_ARGTYPES_07,
9405 class t_ARGTYPES_08,
9406 class t_ARGTYPES_09,
9407 class t_ARGTYPES_10,
9408 class t_ARGTYPES_11,
9409 class t_ARGTYPES_12,
9410 class t_ARGTYPES_13>
9411struct InvokeResult_MemFuncPtrImpDispatch<t_VOID_TYPE, t_ARG1_DERIVES_FROM_CLASS, t_ARG1_IS_REFERENCE_WRAPPER, t_FN, t_ARG1TYPE,
9412 t_ARGTYPES_01,
9413 t_ARGTYPES_02,
9414 t_ARGTYPES_03,
9415 t_ARGTYPES_04,
9416 t_ARGTYPES_05,
9417 t_ARGTYPES_06,
9418 t_ARGTYPES_07,
9419 t_ARGTYPES_08,
9420 t_ARGTYPES_09,
9421 t_ARGTYPES_10,
9422 t_ARGTYPES_11,
9423 t_ARGTYPES_12,
9424 t_ARGTYPES_13> {
9425};
9426#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
9427
9428
9429#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
9430template <class t_FN, class t_ARG1TYPE>
9431struct InvokeResult_MemFuncPtrImpDispatch<
9432 typename bslmf::VoidType<
9433 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9434 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9435 ))>::type,
9436false,
9437false,
9438 t_FN,
9439 t_ARG1TYPE> : InvokeResult_ImpUtils {
9440
9441
9442 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9443 myDeclval<t_FN>())()) type;
9444};
9445#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
9446
9447#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
9448template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01>
9449struct InvokeResult_MemFuncPtrImpDispatch<
9450 typename bslmf::VoidType<
9451 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9452 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9453 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>()))>::type,
9454false,
9455false,
9456 t_FN,
9457 t_ARG1TYPE,
9458 t_ARGTYPES_01> : InvokeResult_ImpUtils {
9459
9460
9461 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9462 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>())) type;
9463};
9464#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
9465
9466#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
9467template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9468 class t_ARGTYPES_02>
9469struct InvokeResult_MemFuncPtrImpDispatch<
9470 typename bslmf::VoidType<
9471 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9472 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9473 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9474 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>()))>::type,
9475false,
9476false,
9477 t_FN,
9478 t_ARG1TYPE,
9479 t_ARGTYPES_01,
9480 t_ARGTYPES_02> : InvokeResult_ImpUtils {
9481
9482
9483 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9484 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9485 myDeclval<t_ARGTYPES_02>())) type;
9486};
9487#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
9488
9489#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
9490template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9491 class t_ARGTYPES_02,
9492 class t_ARGTYPES_03>
9493struct InvokeResult_MemFuncPtrImpDispatch<
9494 typename bslmf::VoidType<
9495 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9496 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9497 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9498 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9499 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>()))>::type,
9500false,
9501false,
9502 t_FN,
9503 t_ARG1TYPE,
9504 t_ARGTYPES_01,
9505 t_ARGTYPES_02,
9506 t_ARGTYPES_03> : InvokeResult_ImpUtils {
9507
9508
9509 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9510 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9511 myDeclval<t_ARGTYPES_02>(),
9512 myDeclval<t_ARGTYPES_03>())) type;
9513};
9514#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
9515
9516#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
9517template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9518 class t_ARGTYPES_02,
9519 class t_ARGTYPES_03,
9520 class t_ARGTYPES_04>
9521struct InvokeResult_MemFuncPtrImpDispatch<
9522 typename bslmf::VoidType<
9523 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9524 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9525 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9526 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9527 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9528 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>()))>::type,
9529false,
9530false,
9531 t_FN,
9532 t_ARG1TYPE,
9533 t_ARGTYPES_01,
9534 t_ARGTYPES_02,
9535 t_ARGTYPES_03,
9536 t_ARGTYPES_04> : InvokeResult_ImpUtils {
9537
9538
9539 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9540 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9541 myDeclval<t_ARGTYPES_02>(),
9542 myDeclval<t_ARGTYPES_03>(),
9543 myDeclval<t_ARGTYPES_04>())) type;
9544};
9545#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
9546
9547#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
9548template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9549 class t_ARGTYPES_02,
9550 class t_ARGTYPES_03,
9551 class t_ARGTYPES_04,
9552 class t_ARGTYPES_05>
9553struct InvokeResult_MemFuncPtrImpDispatch<
9554 typename bslmf::VoidType<
9555 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9556 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9557 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9558 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9559 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9560 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
9561 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>()))>::type,
9562false,
9563false,
9564 t_FN,
9565 t_ARG1TYPE,
9566 t_ARGTYPES_01,
9567 t_ARGTYPES_02,
9568 t_ARGTYPES_03,
9569 t_ARGTYPES_04,
9570 t_ARGTYPES_05> : InvokeResult_ImpUtils {
9571
9572
9573 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9574 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9575 myDeclval<t_ARGTYPES_02>(),
9576 myDeclval<t_ARGTYPES_03>(),
9577 myDeclval<t_ARGTYPES_04>(),
9578 myDeclval<t_ARGTYPES_05>())) type;
9579};
9580#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
9581
9582#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
9583template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9584 class t_ARGTYPES_02,
9585 class t_ARGTYPES_03,
9586 class t_ARGTYPES_04,
9587 class t_ARGTYPES_05,
9588 class t_ARGTYPES_06>
9589struct InvokeResult_MemFuncPtrImpDispatch<
9590 typename bslmf::VoidType<
9591 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9592 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9593 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9594 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9595 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9596 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
9597 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
9598 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>()))>::type,
9599false,
9600false,
9601 t_FN,
9602 t_ARG1TYPE,
9603 t_ARGTYPES_01,
9604 t_ARGTYPES_02,
9605 t_ARGTYPES_03,
9606 t_ARGTYPES_04,
9607 t_ARGTYPES_05,
9608 t_ARGTYPES_06> : InvokeResult_ImpUtils {
9609
9610
9611 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9612 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9613 myDeclval<t_ARGTYPES_02>(),
9614 myDeclval<t_ARGTYPES_03>(),
9615 myDeclval<t_ARGTYPES_04>(),
9616 myDeclval<t_ARGTYPES_05>(),
9617 myDeclval<t_ARGTYPES_06>())) type;
9618};
9619#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
9620
9621#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
9622template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9623 class t_ARGTYPES_02,
9624 class t_ARGTYPES_03,
9625 class t_ARGTYPES_04,
9626 class t_ARGTYPES_05,
9627 class t_ARGTYPES_06,
9628 class t_ARGTYPES_07>
9629struct InvokeResult_MemFuncPtrImpDispatch<
9630 typename bslmf::VoidType<
9631 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9632 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9633 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9634 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9635 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9636 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
9637 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
9638 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
9639 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>()))>::type,
9640false,
9641false,
9642 t_FN,
9643 t_ARG1TYPE,
9644 t_ARGTYPES_01,
9645 t_ARGTYPES_02,
9646 t_ARGTYPES_03,
9647 t_ARGTYPES_04,
9648 t_ARGTYPES_05,
9649 t_ARGTYPES_06,
9650 t_ARGTYPES_07> : InvokeResult_ImpUtils {
9651
9652
9653 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9654 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9655 myDeclval<t_ARGTYPES_02>(),
9656 myDeclval<t_ARGTYPES_03>(),
9657 myDeclval<t_ARGTYPES_04>(),
9658 myDeclval<t_ARGTYPES_05>(),
9659 myDeclval<t_ARGTYPES_06>(),
9660 myDeclval<t_ARGTYPES_07>())) type;
9661};
9662#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
9663
9664#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
9665template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9666 class t_ARGTYPES_02,
9667 class t_ARGTYPES_03,
9668 class t_ARGTYPES_04,
9669 class t_ARGTYPES_05,
9670 class t_ARGTYPES_06,
9671 class t_ARGTYPES_07,
9672 class t_ARGTYPES_08>
9673struct InvokeResult_MemFuncPtrImpDispatch<
9674 typename bslmf::VoidType<
9675 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9676 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9677 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9678 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9679 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9680 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
9681 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
9682 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
9683 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
9684 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>()))>::type,
9685false,
9686false,
9687 t_FN,
9688 t_ARG1TYPE,
9689 t_ARGTYPES_01,
9690 t_ARGTYPES_02,
9691 t_ARGTYPES_03,
9692 t_ARGTYPES_04,
9693 t_ARGTYPES_05,
9694 t_ARGTYPES_06,
9695 t_ARGTYPES_07,
9696 t_ARGTYPES_08> : InvokeResult_ImpUtils {
9697
9698
9699 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9700 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9701 myDeclval<t_ARGTYPES_02>(),
9702 myDeclval<t_ARGTYPES_03>(),
9703 myDeclval<t_ARGTYPES_04>(),
9704 myDeclval<t_ARGTYPES_05>(),
9705 myDeclval<t_ARGTYPES_06>(),
9706 myDeclval<t_ARGTYPES_07>(),
9707 myDeclval<t_ARGTYPES_08>())) type;
9708};
9709#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
9710
9711#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
9712template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9713 class t_ARGTYPES_02,
9714 class t_ARGTYPES_03,
9715 class t_ARGTYPES_04,
9716 class t_ARGTYPES_05,
9717 class t_ARGTYPES_06,
9718 class t_ARGTYPES_07,
9719 class t_ARGTYPES_08,
9720 class t_ARGTYPES_09>
9721struct InvokeResult_MemFuncPtrImpDispatch<
9722 typename bslmf::VoidType<
9723 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9724 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9725 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9726 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9727 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9728 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
9729 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
9730 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
9731 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
9732 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
9733 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>()))>::type,
9734false,
9735false,
9736 t_FN,
9737 t_ARG1TYPE,
9738 t_ARGTYPES_01,
9739 t_ARGTYPES_02,
9740 t_ARGTYPES_03,
9741 t_ARGTYPES_04,
9742 t_ARGTYPES_05,
9743 t_ARGTYPES_06,
9744 t_ARGTYPES_07,
9745 t_ARGTYPES_08,
9746 t_ARGTYPES_09> : InvokeResult_ImpUtils {
9747
9748
9749 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9750 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9751 myDeclval<t_ARGTYPES_02>(),
9752 myDeclval<t_ARGTYPES_03>(),
9753 myDeclval<t_ARGTYPES_04>(),
9754 myDeclval<t_ARGTYPES_05>(),
9755 myDeclval<t_ARGTYPES_06>(),
9756 myDeclval<t_ARGTYPES_07>(),
9757 myDeclval<t_ARGTYPES_08>(),
9758 myDeclval<t_ARGTYPES_09>())) type;
9759};
9760#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
9761
9762#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
9763template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9764 class t_ARGTYPES_02,
9765 class t_ARGTYPES_03,
9766 class t_ARGTYPES_04,
9767 class t_ARGTYPES_05,
9768 class t_ARGTYPES_06,
9769 class t_ARGTYPES_07,
9770 class t_ARGTYPES_08,
9771 class t_ARGTYPES_09,
9772 class t_ARGTYPES_10>
9773struct InvokeResult_MemFuncPtrImpDispatch<
9774 typename bslmf::VoidType<
9775 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9776 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9777 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9778 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9779 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9780 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
9781 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
9782 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
9783 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
9784 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
9785 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
9786 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>()))>::type,
9787false,
9788false,
9789 t_FN,
9790 t_ARG1TYPE,
9791 t_ARGTYPES_01,
9792 t_ARGTYPES_02,
9793 t_ARGTYPES_03,
9794 t_ARGTYPES_04,
9795 t_ARGTYPES_05,
9796 t_ARGTYPES_06,
9797 t_ARGTYPES_07,
9798 t_ARGTYPES_08,
9799 t_ARGTYPES_09,
9800 t_ARGTYPES_10> : InvokeResult_ImpUtils {
9801
9802
9803 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9804 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9805 myDeclval<t_ARGTYPES_02>(),
9806 myDeclval<t_ARGTYPES_03>(),
9807 myDeclval<t_ARGTYPES_04>(),
9808 myDeclval<t_ARGTYPES_05>(),
9809 myDeclval<t_ARGTYPES_06>(),
9810 myDeclval<t_ARGTYPES_07>(),
9811 myDeclval<t_ARGTYPES_08>(),
9812 myDeclval<t_ARGTYPES_09>(),
9813 myDeclval<t_ARGTYPES_10>())) type;
9814};
9815#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
9816
9817#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
9818template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9819 class t_ARGTYPES_02,
9820 class t_ARGTYPES_03,
9821 class t_ARGTYPES_04,
9822 class t_ARGTYPES_05,
9823 class t_ARGTYPES_06,
9824 class t_ARGTYPES_07,
9825 class t_ARGTYPES_08,
9826 class t_ARGTYPES_09,
9827 class t_ARGTYPES_10,
9828 class t_ARGTYPES_11>
9829struct InvokeResult_MemFuncPtrImpDispatch<
9830 typename bslmf::VoidType<
9831 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9832 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9833 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9834 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9835 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9836 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
9837 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
9838 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
9839 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
9840 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
9841 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
9842 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
9843 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>()))>::type,
9844false,
9845false,
9846 t_FN,
9847 t_ARG1TYPE,
9848 t_ARGTYPES_01,
9849 t_ARGTYPES_02,
9850 t_ARGTYPES_03,
9851 t_ARGTYPES_04,
9852 t_ARGTYPES_05,
9853 t_ARGTYPES_06,
9854 t_ARGTYPES_07,
9855 t_ARGTYPES_08,
9856 t_ARGTYPES_09,
9857 t_ARGTYPES_10,
9858 t_ARGTYPES_11> : InvokeResult_ImpUtils {
9859
9860
9861 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9862 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9863 myDeclval<t_ARGTYPES_02>(),
9864 myDeclval<t_ARGTYPES_03>(),
9865 myDeclval<t_ARGTYPES_04>(),
9866 myDeclval<t_ARGTYPES_05>(),
9867 myDeclval<t_ARGTYPES_06>(),
9868 myDeclval<t_ARGTYPES_07>(),
9869 myDeclval<t_ARGTYPES_08>(),
9870 myDeclval<t_ARGTYPES_09>(),
9871 myDeclval<t_ARGTYPES_10>(),
9872 myDeclval<t_ARGTYPES_11>())) type;
9873};
9874#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
9875
9876#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
9877template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9878 class t_ARGTYPES_02,
9879 class t_ARGTYPES_03,
9880 class t_ARGTYPES_04,
9881 class t_ARGTYPES_05,
9882 class t_ARGTYPES_06,
9883 class t_ARGTYPES_07,
9884 class t_ARGTYPES_08,
9885 class t_ARGTYPES_09,
9886 class t_ARGTYPES_10,
9887 class t_ARGTYPES_11,
9888 class t_ARGTYPES_12>
9889struct InvokeResult_MemFuncPtrImpDispatch<
9890 typename bslmf::VoidType<
9891 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9892 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9893 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9894 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9895 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9896 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
9897 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
9898 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
9899 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
9900 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
9901 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
9902 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
9903 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
9904 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>()))>::type,
9905false,
9906false,
9907 t_FN,
9908 t_ARG1TYPE,
9909 t_ARGTYPES_01,
9910 t_ARGTYPES_02,
9911 t_ARGTYPES_03,
9912 t_ARGTYPES_04,
9913 t_ARGTYPES_05,
9914 t_ARGTYPES_06,
9915 t_ARGTYPES_07,
9916 t_ARGTYPES_08,
9917 t_ARGTYPES_09,
9918 t_ARGTYPES_10,
9919 t_ARGTYPES_11,
9920 t_ARGTYPES_12> : InvokeResult_ImpUtils {
9921
9922
9923 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9924 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9925 myDeclval<t_ARGTYPES_02>(),
9926 myDeclval<t_ARGTYPES_03>(),
9927 myDeclval<t_ARGTYPES_04>(),
9928 myDeclval<t_ARGTYPES_05>(),
9929 myDeclval<t_ARGTYPES_06>(),
9930 myDeclval<t_ARGTYPES_07>(),
9931 myDeclval<t_ARGTYPES_08>(),
9932 myDeclval<t_ARGTYPES_09>(),
9933 myDeclval<t_ARGTYPES_10>(),
9934 myDeclval<t_ARGTYPES_11>(),
9935 myDeclval<t_ARGTYPES_12>())) type;
9936};
9937#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
9938
9939#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
9940template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
9941 class t_ARGTYPES_02,
9942 class t_ARGTYPES_03,
9943 class t_ARGTYPES_04,
9944 class t_ARGTYPES_05,
9945 class t_ARGTYPES_06,
9946 class t_ARGTYPES_07,
9947 class t_ARGTYPES_08,
9948 class t_ARGTYPES_09,
9949 class t_ARGTYPES_10,
9950 class t_ARGTYPES_11,
9951 class t_ARGTYPES_12,
9952 class t_ARGTYPES_13>
9953struct InvokeResult_MemFuncPtrImpDispatch<
9954 typename bslmf::VoidType<
9955 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
9956 InvokeResult_ImpUtils::myDeclval<t_FN>())(
9957 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
9958 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
9959 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
9960 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
9961 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
9962 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
9963 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
9964 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
9965 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
9966 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
9967 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
9968 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>(),
9969 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_13>()))>::type,
9970false,
9971false,
9972 t_FN,
9973 t_ARG1TYPE,
9974 t_ARGTYPES_01,
9975 t_ARGTYPES_02,
9976 t_ARGTYPES_03,
9977 t_ARGTYPES_04,
9978 t_ARGTYPES_05,
9979 t_ARGTYPES_06,
9980 t_ARGTYPES_07,
9981 t_ARGTYPES_08,
9982 t_ARGTYPES_09,
9983 t_ARGTYPES_10,
9984 t_ARGTYPES_11,
9985 t_ARGTYPES_12,
9986 t_ARGTYPES_13> : InvokeResult_ImpUtils {
9987
9988
9989 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
9990 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
9991 myDeclval<t_ARGTYPES_02>(),
9992 myDeclval<t_ARGTYPES_03>(),
9993 myDeclval<t_ARGTYPES_04>(),
9994 myDeclval<t_ARGTYPES_05>(),
9995 myDeclval<t_ARGTYPES_06>(),
9996 myDeclval<t_ARGTYPES_07>(),
9997 myDeclval<t_ARGTYPES_08>(),
9998 myDeclval<t_ARGTYPES_09>(),
9999 myDeclval<t_ARGTYPES_10>(),
10000 myDeclval<t_ARGTYPES_11>(),
10001 myDeclval<t_ARGTYPES_12>(),
10002 myDeclval<t_ARGTYPES_13>())) type;
10003};
10004#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
10005
10006
10007#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
10008template <class t_FN, class t_ARG1TYPE>
10009struct InvokeResult_MemFuncPtrImpDispatch<
10010 typename bslmf::VoidType<
10011 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10012 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10013 ))>::type,
10014true,
10015false,
10016 t_FN,
10017 t_ARG1TYPE> : InvokeResult_ImpUtils {
10018
10019
10020 typedef decltype((myDeclval<t_ARG1TYPE>().*
10021 myDeclval<t_FN>())()) type;
10022};
10023#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
10024
10025#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
10026template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01>
10027struct InvokeResult_MemFuncPtrImpDispatch<
10028 typename bslmf::VoidType<
10029 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10030 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10031 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>()))>::type,
10032true,
10033false,
10034 t_FN,
10035 t_ARG1TYPE,
10036 t_ARGTYPES_01> : InvokeResult_ImpUtils {
10037
10038
10039 typedef decltype((myDeclval<t_ARG1TYPE>().*
10040 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>())) type;
10041};
10042#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
10043
10044#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
10045template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10046 class t_ARGTYPES_02>
10047struct InvokeResult_MemFuncPtrImpDispatch<
10048 typename bslmf::VoidType<
10049 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10050 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10051 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10052 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>()))>::type,
10053true,
10054false,
10055 t_FN,
10056 t_ARG1TYPE,
10057 t_ARGTYPES_01,
10058 t_ARGTYPES_02> : InvokeResult_ImpUtils {
10059
10060
10061 typedef decltype((myDeclval<t_ARG1TYPE>().*
10062 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10063 myDeclval<t_ARGTYPES_02>())) type;
10064};
10065#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
10066
10067#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
10068template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10069 class t_ARGTYPES_02,
10070 class t_ARGTYPES_03>
10071struct InvokeResult_MemFuncPtrImpDispatch<
10072 typename bslmf::VoidType<
10073 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10074 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10075 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10076 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10077 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>()))>::type,
10078true,
10079false,
10080 t_FN,
10081 t_ARG1TYPE,
10082 t_ARGTYPES_01,
10083 t_ARGTYPES_02,
10084 t_ARGTYPES_03> : InvokeResult_ImpUtils {
10085
10086
10087 typedef decltype((myDeclval<t_ARG1TYPE>().*
10088 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10089 myDeclval<t_ARGTYPES_02>(),
10090 myDeclval<t_ARGTYPES_03>())) type;
10091};
10092#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
10093
10094#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
10095template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10096 class t_ARGTYPES_02,
10097 class t_ARGTYPES_03,
10098 class t_ARGTYPES_04>
10099struct InvokeResult_MemFuncPtrImpDispatch<
10100 typename bslmf::VoidType<
10101 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10102 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10103 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10104 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10105 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10106 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>()))>::type,
10107true,
10108false,
10109 t_FN,
10110 t_ARG1TYPE,
10111 t_ARGTYPES_01,
10112 t_ARGTYPES_02,
10113 t_ARGTYPES_03,
10114 t_ARGTYPES_04> : InvokeResult_ImpUtils {
10115
10116
10117 typedef decltype((myDeclval<t_ARG1TYPE>().*
10118 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10119 myDeclval<t_ARGTYPES_02>(),
10120 myDeclval<t_ARGTYPES_03>(),
10121 myDeclval<t_ARGTYPES_04>())) type;
10122};
10123#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
10124
10125#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
10126template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10127 class t_ARGTYPES_02,
10128 class t_ARGTYPES_03,
10129 class t_ARGTYPES_04,
10130 class t_ARGTYPES_05>
10131struct InvokeResult_MemFuncPtrImpDispatch<
10132 typename bslmf::VoidType<
10133 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10134 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10135 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10136 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10137 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10138 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10139 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>()))>::type,
10140true,
10141false,
10142 t_FN,
10143 t_ARG1TYPE,
10144 t_ARGTYPES_01,
10145 t_ARGTYPES_02,
10146 t_ARGTYPES_03,
10147 t_ARGTYPES_04,
10148 t_ARGTYPES_05> : InvokeResult_ImpUtils {
10149
10150
10151 typedef decltype((myDeclval<t_ARG1TYPE>().*
10152 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10153 myDeclval<t_ARGTYPES_02>(),
10154 myDeclval<t_ARGTYPES_03>(),
10155 myDeclval<t_ARGTYPES_04>(),
10156 myDeclval<t_ARGTYPES_05>())) type;
10157};
10158#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
10159
10160#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
10161template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10162 class t_ARGTYPES_02,
10163 class t_ARGTYPES_03,
10164 class t_ARGTYPES_04,
10165 class t_ARGTYPES_05,
10166 class t_ARGTYPES_06>
10167struct InvokeResult_MemFuncPtrImpDispatch<
10168 typename bslmf::VoidType<
10169 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10170 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10171 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10172 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10173 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10174 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10175 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10176 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>()))>::type,
10177true,
10178false,
10179 t_FN,
10180 t_ARG1TYPE,
10181 t_ARGTYPES_01,
10182 t_ARGTYPES_02,
10183 t_ARGTYPES_03,
10184 t_ARGTYPES_04,
10185 t_ARGTYPES_05,
10186 t_ARGTYPES_06> : InvokeResult_ImpUtils {
10187
10188
10189 typedef decltype((myDeclval<t_ARG1TYPE>().*
10190 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10191 myDeclval<t_ARGTYPES_02>(),
10192 myDeclval<t_ARGTYPES_03>(),
10193 myDeclval<t_ARGTYPES_04>(),
10194 myDeclval<t_ARGTYPES_05>(),
10195 myDeclval<t_ARGTYPES_06>())) type;
10196};
10197#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
10198
10199#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
10200template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10201 class t_ARGTYPES_02,
10202 class t_ARGTYPES_03,
10203 class t_ARGTYPES_04,
10204 class t_ARGTYPES_05,
10205 class t_ARGTYPES_06,
10206 class t_ARGTYPES_07>
10207struct InvokeResult_MemFuncPtrImpDispatch<
10208 typename bslmf::VoidType<
10209 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10210 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10211 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10212 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10213 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10214 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10215 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10216 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10217 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>()))>::type,
10218true,
10219false,
10220 t_FN,
10221 t_ARG1TYPE,
10222 t_ARGTYPES_01,
10223 t_ARGTYPES_02,
10224 t_ARGTYPES_03,
10225 t_ARGTYPES_04,
10226 t_ARGTYPES_05,
10227 t_ARGTYPES_06,
10228 t_ARGTYPES_07> : InvokeResult_ImpUtils {
10229
10230
10231 typedef decltype((myDeclval<t_ARG1TYPE>().*
10232 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10233 myDeclval<t_ARGTYPES_02>(),
10234 myDeclval<t_ARGTYPES_03>(),
10235 myDeclval<t_ARGTYPES_04>(),
10236 myDeclval<t_ARGTYPES_05>(),
10237 myDeclval<t_ARGTYPES_06>(),
10238 myDeclval<t_ARGTYPES_07>())) type;
10239};
10240#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
10241
10242#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
10243template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10244 class t_ARGTYPES_02,
10245 class t_ARGTYPES_03,
10246 class t_ARGTYPES_04,
10247 class t_ARGTYPES_05,
10248 class t_ARGTYPES_06,
10249 class t_ARGTYPES_07,
10250 class t_ARGTYPES_08>
10251struct InvokeResult_MemFuncPtrImpDispatch<
10252 typename bslmf::VoidType<
10253 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10254 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10255 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10256 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10257 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10258 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10259 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10260 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10261 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10262 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>()))>::type,
10263true,
10264false,
10265 t_FN,
10266 t_ARG1TYPE,
10267 t_ARGTYPES_01,
10268 t_ARGTYPES_02,
10269 t_ARGTYPES_03,
10270 t_ARGTYPES_04,
10271 t_ARGTYPES_05,
10272 t_ARGTYPES_06,
10273 t_ARGTYPES_07,
10274 t_ARGTYPES_08> : InvokeResult_ImpUtils {
10275
10276
10277 typedef decltype((myDeclval<t_ARG1TYPE>().*
10278 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10279 myDeclval<t_ARGTYPES_02>(),
10280 myDeclval<t_ARGTYPES_03>(),
10281 myDeclval<t_ARGTYPES_04>(),
10282 myDeclval<t_ARGTYPES_05>(),
10283 myDeclval<t_ARGTYPES_06>(),
10284 myDeclval<t_ARGTYPES_07>(),
10285 myDeclval<t_ARGTYPES_08>())) type;
10286};
10287#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
10288
10289#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
10290template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10291 class t_ARGTYPES_02,
10292 class t_ARGTYPES_03,
10293 class t_ARGTYPES_04,
10294 class t_ARGTYPES_05,
10295 class t_ARGTYPES_06,
10296 class t_ARGTYPES_07,
10297 class t_ARGTYPES_08,
10298 class t_ARGTYPES_09>
10299struct InvokeResult_MemFuncPtrImpDispatch<
10300 typename bslmf::VoidType<
10301 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10302 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10303 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10304 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10305 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10306 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10307 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10308 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10309 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10310 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
10311 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>()))>::type,
10312true,
10313false,
10314 t_FN,
10315 t_ARG1TYPE,
10316 t_ARGTYPES_01,
10317 t_ARGTYPES_02,
10318 t_ARGTYPES_03,
10319 t_ARGTYPES_04,
10320 t_ARGTYPES_05,
10321 t_ARGTYPES_06,
10322 t_ARGTYPES_07,
10323 t_ARGTYPES_08,
10324 t_ARGTYPES_09> : InvokeResult_ImpUtils {
10325
10326
10327 typedef decltype((myDeclval<t_ARG1TYPE>().*
10328 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10329 myDeclval<t_ARGTYPES_02>(),
10330 myDeclval<t_ARGTYPES_03>(),
10331 myDeclval<t_ARGTYPES_04>(),
10332 myDeclval<t_ARGTYPES_05>(),
10333 myDeclval<t_ARGTYPES_06>(),
10334 myDeclval<t_ARGTYPES_07>(),
10335 myDeclval<t_ARGTYPES_08>(),
10336 myDeclval<t_ARGTYPES_09>())) type;
10337};
10338#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
10339
10340#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
10341template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10342 class t_ARGTYPES_02,
10343 class t_ARGTYPES_03,
10344 class t_ARGTYPES_04,
10345 class t_ARGTYPES_05,
10346 class t_ARGTYPES_06,
10347 class t_ARGTYPES_07,
10348 class t_ARGTYPES_08,
10349 class t_ARGTYPES_09,
10350 class t_ARGTYPES_10>
10351struct InvokeResult_MemFuncPtrImpDispatch<
10352 typename bslmf::VoidType<
10353 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10354 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10355 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10356 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10357 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10358 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10359 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10360 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10361 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10362 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
10363 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
10364 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>()))>::type,
10365true,
10366false,
10367 t_FN,
10368 t_ARG1TYPE,
10369 t_ARGTYPES_01,
10370 t_ARGTYPES_02,
10371 t_ARGTYPES_03,
10372 t_ARGTYPES_04,
10373 t_ARGTYPES_05,
10374 t_ARGTYPES_06,
10375 t_ARGTYPES_07,
10376 t_ARGTYPES_08,
10377 t_ARGTYPES_09,
10378 t_ARGTYPES_10> : InvokeResult_ImpUtils {
10379
10380
10381 typedef decltype((myDeclval<t_ARG1TYPE>().*
10382 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10383 myDeclval<t_ARGTYPES_02>(),
10384 myDeclval<t_ARGTYPES_03>(),
10385 myDeclval<t_ARGTYPES_04>(),
10386 myDeclval<t_ARGTYPES_05>(),
10387 myDeclval<t_ARGTYPES_06>(),
10388 myDeclval<t_ARGTYPES_07>(),
10389 myDeclval<t_ARGTYPES_08>(),
10390 myDeclval<t_ARGTYPES_09>(),
10391 myDeclval<t_ARGTYPES_10>())) type;
10392};
10393#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
10394
10395#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
10396template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10397 class t_ARGTYPES_02,
10398 class t_ARGTYPES_03,
10399 class t_ARGTYPES_04,
10400 class t_ARGTYPES_05,
10401 class t_ARGTYPES_06,
10402 class t_ARGTYPES_07,
10403 class t_ARGTYPES_08,
10404 class t_ARGTYPES_09,
10405 class t_ARGTYPES_10,
10406 class t_ARGTYPES_11>
10407struct InvokeResult_MemFuncPtrImpDispatch<
10408 typename bslmf::VoidType<
10409 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10410 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10411 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10412 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10413 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10414 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10415 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10416 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10417 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10418 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
10419 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
10420 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
10421 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>()))>::type,
10422true,
10423false,
10424 t_FN,
10425 t_ARG1TYPE,
10426 t_ARGTYPES_01,
10427 t_ARGTYPES_02,
10428 t_ARGTYPES_03,
10429 t_ARGTYPES_04,
10430 t_ARGTYPES_05,
10431 t_ARGTYPES_06,
10432 t_ARGTYPES_07,
10433 t_ARGTYPES_08,
10434 t_ARGTYPES_09,
10435 t_ARGTYPES_10,
10436 t_ARGTYPES_11> : InvokeResult_ImpUtils {
10437
10438
10439 typedef decltype((myDeclval<t_ARG1TYPE>().*
10440 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10441 myDeclval<t_ARGTYPES_02>(),
10442 myDeclval<t_ARGTYPES_03>(),
10443 myDeclval<t_ARGTYPES_04>(),
10444 myDeclval<t_ARGTYPES_05>(),
10445 myDeclval<t_ARGTYPES_06>(),
10446 myDeclval<t_ARGTYPES_07>(),
10447 myDeclval<t_ARGTYPES_08>(),
10448 myDeclval<t_ARGTYPES_09>(),
10449 myDeclval<t_ARGTYPES_10>(),
10450 myDeclval<t_ARGTYPES_11>())) type;
10451};
10452#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
10453
10454#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
10455template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10456 class t_ARGTYPES_02,
10457 class t_ARGTYPES_03,
10458 class t_ARGTYPES_04,
10459 class t_ARGTYPES_05,
10460 class t_ARGTYPES_06,
10461 class t_ARGTYPES_07,
10462 class t_ARGTYPES_08,
10463 class t_ARGTYPES_09,
10464 class t_ARGTYPES_10,
10465 class t_ARGTYPES_11,
10466 class t_ARGTYPES_12>
10467struct InvokeResult_MemFuncPtrImpDispatch<
10468 typename bslmf::VoidType<
10469 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10470 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10471 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10472 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10473 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10474 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10475 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10476 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10477 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10478 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
10479 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
10480 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
10481 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
10482 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>()))>::type,
10483true,
10484false,
10485 t_FN,
10486 t_ARG1TYPE,
10487 t_ARGTYPES_01,
10488 t_ARGTYPES_02,
10489 t_ARGTYPES_03,
10490 t_ARGTYPES_04,
10491 t_ARGTYPES_05,
10492 t_ARGTYPES_06,
10493 t_ARGTYPES_07,
10494 t_ARGTYPES_08,
10495 t_ARGTYPES_09,
10496 t_ARGTYPES_10,
10497 t_ARGTYPES_11,
10498 t_ARGTYPES_12> : InvokeResult_ImpUtils {
10499
10500
10501 typedef decltype((myDeclval<t_ARG1TYPE>().*
10502 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10503 myDeclval<t_ARGTYPES_02>(),
10504 myDeclval<t_ARGTYPES_03>(),
10505 myDeclval<t_ARGTYPES_04>(),
10506 myDeclval<t_ARGTYPES_05>(),
10507 myDeclval<t_ARGTYPES_06>(),
10508 myDeclval<t_ARGTYPES_07>(),
10509 myDeclval<t_ARGTYPES_08>(),
10510 myDeclval<t_ARGTYPES_09>(),
10511 myDeclval<t_ARGTYPES_10>(),
10512 myDeclval<t_ARGTYPES_11>(),
10513 myDeclval<t_ARGTYPES_12>())) type;
10514};
10515#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
10516
10517#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
10518template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10519 class t_ARGTYPES_02,
10520 class t_ARGTYPES_03,
10521 class t_ARGTYPES_04,
10522 class t_ARGTYPES_05,
10523 class t_ARGTYPES_06,
10524 class t_ARGTYPES_07,
10525 class t_ARGTYPES_08,
10526 class t_ARGTYPES_09,
10527 class t_ARGTYPES_10,
10528 class t_ARGTYPES_11,
10529 class t_ARGTYPES_12,
10530 class t_ARGTYPES_13>
10531struct InvokeResult_MemFuncPtrImpDispatch<
10532 typename bslmf::VoidType<
10533 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
10534 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10535 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10536 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10537 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10538 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10539 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10540 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10541 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10542 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
10543 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
10544 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
10545 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
10546 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>(),
10547 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_13>()))>::type,
10548true,
10549false,
10550 t_FN,
10551 t_ARG1TYPE,
10552 t_ARGTYPES_01,
10553 t_ARGTYPES_02,
10554 t_ARGTYPES_03,
10555 t_ARGTYPES_04,
10556 t_ARGTYPES_05,
10557 t_ARGTYPES_06,
10558 t_ARGTYPES_07,
10559 t_ARGTYPES_08,
10560 t_ARGTYPES_09,
10561 t_ARGTYPES_10,
10562 t_ARGTYPES_11,
10563 t_ARGTYPES_12,
10564 t_ARGTYPES_13> : InvokeResult_ImpUtils {
10565
10566
10567 typedef decltype((myDeclval<t_ARG1TYPE>().*
10568 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10569 myDeclval<t_ARGTYPES_02>(),
10570 myDeclval<t_ARGTYPES_03>(),
10571 myDeclval<t_ARGTYPES_04>(),
10572 myDeclval<t_ARGTYPES_05>(),
10573 myDeclval<t_ARGTYPES_06>(),
10574 myDeclval<t_ARGTYPES_07>(),
10575 myDeclval<t_ARGTYPES_08>(),
10576 myDeclval<t_ARGTYPES_09>(),
10577 myDeclval<t_ARGTYPES_10>(),
10578 myDeclval<t_ARGTYPES_11>(),
10579 myDeclval<t_ARGTYPES_12>(),
10580 myDeclval<t_ARGTYPES_13>())) type;
10581};
10582#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
10583
10584
10585#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
10586template <class t_FN, class t_ARG1TYPE>
10587struct InvokeResult_MemFuncPtrImpDispatch<
10588 typename bslmf::VoidType<
10589 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10590 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10591 ))>::type,
10592false,
10593true,
10594 t_FN,
10595 t_ARG1TYPE> : InvokeResult_ImpUtils {
10596
10597
10598 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10599 myDeclval<t_FN>())()) type;
10600};
10601#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
10602
10603#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
10604template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01>
10605struct InvokeResult_MemFuncPtrImpDispatch<
10606 typename bslmf::VoidType<
10607 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10608 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10609 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>()))>::type,
10610false,
10611true,
10612 t_FN,
10613 t_ARG1TYPE,
10614 t_ARGTYPES_01> : InvokeResult_ImpUtils {
10615
10616
10617 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10618 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>())) type;
10619};
10620#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
10621
10622#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
10623template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10624 class t_ARGTYPES_02>
10625struct InvokeResult_MemFuncPtrImpDispatch<
10626 typename bslmf::VoidType<
10627 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10628 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10629 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10630 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>()))>::type,
10631false,
10632true,
10633 t_FN,
10634 t_ARG1TYPE,
10635 t_ARGTYPES_01,
10636 t_ARGTYPES_02> : InvokeResult_ImpUtils {
10637
10638
10639 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10640 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10641 myDeclval<t_ARGTYPES_02>())) type;
10642};
10643#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
10644
10645#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
10646template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10647 class t_ARGTYPES_02,
10648 class t_ARGTYPES_03>
10649struct InvokeResult_MemFuncPtrImpDispatch<
10650 typename bslmf::VoidType<
10651 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10652 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10653 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10654 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10655 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>()))>::type,
10656false,
10657true,
10658 t_FN,
10659 t_ARG1TYPE,
10660 t_ARGTYPES_01,
10661 t_ARGTYPES_02,
10662 t_ARGTYPES_03> : InvokeResult_ImpUtils {
10663
10664
10665 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10666 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10667 myDeclval<t_ARGTYPES_02>(),
10668 myDeclval<t_ARGTYPES_03>())) type;
10669};
10670#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
10671
10672#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
10673template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10674 class t_ARGTYPES_02,
10675 class t_ARGTYPES_03,
10676 class t_ARGTYPES_04>
10677struct InvokeResult_MemFuncPtrImpDispatch<
10678 typename bslmf::VoidType<
10679 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10680 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10681 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10682 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10683 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10684 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>()))>::type,
10685false,
10686true,
10687 t_FN,
10688 t_ARG1TYPE,
10689 t_ARGTYPES_01,
10690 t_ARGTYPES_02,
10691 t_ARGTYPES_03,
10692 t_ARGTYPES_04> : InvokeResult_ImpUtils {
10693
10694
10695 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10696 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10697 myDeclval<t_ARGTYPES_02>(),
10698 myDeclval<t_ARGTYPES_03>(),
10699 myDeclval<t_ARGTYPES_04>())) type;
10700};
10701#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
10702
10703#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
10704template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10705 class t_ARGTYPES_02,
10706 class t_ARGTYPES_03,
10707 class t_ARGTYPES_04,
10708 class t_ARGTYPES_05>
10709struct InvokeResult_MemFuncPtrImpDispatch<
10710 typename bslmf::VoidType<
10711 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10712 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10713 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10714 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10715 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10716 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10717 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>()))>::type,
10718false,
10719true,
10720 t_FN,
10721 t_ARG1TYPE,
10722 t_ARGTYPES_01,
10723 t_ARGTYPES_02,
10724 t_ARGTYPES_03,
10725 t_ARGTYPES_04,
10726 t_ARGTYPES_05> : InvokeResult_ImpUtils {
10727
10728
10729 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10730 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10731 myDeclval<t_ARGTYPES_02>(),
10732 myDeclval<t_ARGTYPES_03>(),
10733 myDeclval<t_ARGTYPES_04>(),
10734 myDeclval<t_ARGTYPES_05>())) type;
10735};
10736#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
10737
10738#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
10739template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10740 class t_ARGTYPES_02,
10741 class t_ARGTYPES_03,
10742 class t_ARGTYPES_04,
10743 class t_ARGTYPES_05,
10744 class t_ARGTYPES_06>
10745struct InvokeResult_MemFuncPtrImpDispatch<
10746 typename bslmf::VoidType<
10747 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10748 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10749 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10750 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10751 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10752 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10753 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10754 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>()))>::type,
10755false,
10756true,
10757 t_FN,
10758 t_ARG1TYPE,
10759 t_ARGTYPES_01,
10760 t_ARGTYPES_02,
10761 t_ARGTYPES_03,
10762 t_ARGTYPES_04,
10763 t_ARGTYPES_05,
10764 t_ARGTYPES_06> : InvokeResult_ImpUtils {
10765
10766
10767 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10768 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10769 myDeclval<t_ARGTYPES_02>(),
10770 myDeclval<t_ARGTYPES_03>(),
10771 myDeclval<t_ARGTYPES_04>(),
10772 myDeclval<t_ARGTYPES_05>(),
10773 myDeclval<t_ARGTYPES_06>())) type;
10774};
10775#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
10776
10777#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
10778template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10779 class t_ARGTYPES_02,
10780 class t_ARGTYPES_03,
10781 class t_ARGTYPES_04,
10782 class t_ARGTYPES_05,
10783 class t_ARGTYPES_06,
10784 class t_ARGTYPES_07>
10785struct InvokeResult_MemFuncPtrImpDispatch<
10786 typename bslmf::VoidType<
10787 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10788 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10789 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10790 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10791 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10792 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10793 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10794 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10795 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>()))>::type,
10796false,
10797true,
10798 t_FN,
10799 t_ARG1TYPE,
10800 t_ARGTYPES_01,
10801 t_ARGTYPES_02,
10802 t_ARGTYPES_03,
10803 t_ARGTYPES_04,
10804 t_ARGTYPES_05,
10805 t_ARGTYPES_06,
10806 t_ARGTYPES_07> : InvokeResult_ImpUtils {
10807
10808
10809 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10810 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10811 myDeclval<t_ARGTYPES_02>(),
10812 myDeclval<t_ARGTYPES_03>(),
10813 myDeclval<t_ARGTYPES_04>(),
10814 myDeclval<t_ARGTYPES_05>(),
10815 myDeclval<t_ARGTYPES_06>(),
10816 myDeclval<t_ARGTYPES_07>())) type;
10817};
10818#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
10819
10820#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
10821template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10822 class t_ARGTYPES_02,
10823 class t_ARGTYPES_03,
10824 class t_ARGTYPES_04,
10825 class t_ARGTYPES_05,
10826 class t_ARGTYPES_06,
10827 class t_ARGTYPES_07,
10828 class t_ARGTYPES_08>
10829struct InvokeResult_MemFuncPtrImpDispatch<
10830 typename bslmf::VoidType<
10831 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10832 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10833 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10834 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10835 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10836 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10837 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10838 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10839 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10840 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>()))>::type,
10841false,
10842true,
10843 t_FN,
10844 t_ARG1TYPE,
10845 t_ARGTYPES_01,
10846 t_ARGTYPES_02,
10847 t_ARGTYPES_03,
10848 t_ARGTYPES_04,
10849 t_ARGTYPES_05,
10850 t_ARGTYPES_06,
10851 t_ARGTYPES_07,
10852 t_ARGTYPES_08> : InvokeResult_ImpUtils {
10853
10854
10855 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10856 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10857 myDeclval<t_ARGTYPES_02>(),
10858 myDeclval<t_ARGTYPES_03>(),
10859 myDeclval<t_ARGTYPES_04>(),
10860 myDeclval<t_ARGTYPES_05>(),
10861 myDeclval<t_ARGTYPES_06>(),
10862 myDeclval<t_ARGTYPES_07>(),
10863 myDeclval<t_ARGTYPES_08>())) type;
10864};
10865#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
10866
10867#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
10868template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10869 class t_ARGTYPES_02,
10870 class t_ARGTYPES_03,
10871 class t_ARGTYPES_04,
10872 class t_ARGTYPES_05,
10873 class t_ARGTYPES_06,
10874 class t_ARGTYPES_07,
10875 class t_ARGTYPES_08,
10876 class t_ARGTYPES_09>
10877struct InvokeResult_MemFuncPtrImpDispatch<
10878 typename bslmf::VoidType<
10879 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10880 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10881 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10882 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10883 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10884 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10885 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10886 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10887 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10888 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
10889 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>()))>::type,
10890false,
10891true,
10892 t_FN,
10893 t_ARG1TYPE,
10894 t_ARGTYPES_01,
10895 t_ARGTYPES_02,
10896 t_ARGTYPES_03,
10897 t_ARGTYPES_04,
10898 t_ARGTYPES_05,
10899 t_ARGTYPES_06,
10900 t_ARGTYPES_07,
10901 t_ARGTYPES_08,
10902 t_ARGTYPES_09> : InvokeResult_ImpUtils {
10903
10904
10905 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10906 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10907 myDeclval<t_ARGTYPES_02>(),
10908 myDeclval<t_ARGTYPES_03>(),
10909 myDeclval<t_ARGTYPES_04>(),
10910 myDeclval<t_ARGTYPES_05>(),
10911 myDeclval<t_ARGTYPES_06>(),
10912 myDeclval<t_ARGTYPES_07>(),
10913 myDeclval<t_ARGTYPES_08>(),
10914 myDeclval<t_ARGTYPES_09>())) type;
10915};
10916#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
10917
10918#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
10919template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10920 class t_ARGTYPES_02,
10921 class t_ARGTYPES_03,
10922 class t_ARGTYPES_04,
10923 class t_ARGTYPES_05,
10924 class t_ARGTYPES_06,
10925 class t_ARGTYPES_07,
10926 class t_ARGTYPES_08,
10927 class t_ARGTYPES_09,
10928 class t_ARGTYPES_10>
10929struct InvokeResult_MemFuncPtrImpDispatch<
10930 typename bslmf::VoidType<
10931 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10932 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10933 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10934 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10935 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10936 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10937 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10938 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10939 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10940 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
10941 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
10942 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>()))>::type,
10943false,
10944true,
10945 t_FN,
10946 t_ARG1TYPE,
10947 t_ARGTYPES_01,
10948 t_ARGTYPES_02,
10949 t_ARGTYPES_03,
10950 t_ARGTYPES_04,
10951 t_ARGTYPES_05,
10952 t_ARGTYPES_06,
10953 t_ARGTYPES_07,
10954 t_ARGTYPES_08,
10955 t_ARGTYPES_09,
10956 t_ARGTYPES_10> : InvokeResult_ImpUtils {
10957
10958
10959 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
10960 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
10961 myDeclval<t_ARGTYPES_02>(),
10962 myDeclval<t_ARGTYPES_03>(),
10963 myDeclval<t_ARGTYPES_04>(),
10964 myDeclval<t_ARGTYPES_05>(),
10965 myDeclval<t_ARGTYPES_06>(),
10966 myDeclval<t_ARGTYPES_07>(),
10967 myDeclval<t_ARGTYPES_08>(),
10968 myDeclval<t_ARGTYPES_09>(),
10969 myDeclval<t_ARGTYPES_10>())) type;
10970};
10971#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
10972
10973#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
10974template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
10975 class t_ARGTYPES_02,
10976 class t_ARGTYPES_03,
10977 class t_ARGTYPES_04,
10978 class t_ARGTYPES_05,
10979 class t_ARGTYPES_06,
10980 class t_ARGTYPES_07,
10981 class t_ARGTYPES_08,
10982 class t_ARGTYPES_09,
10983 class t_ARGTYPES_10,
10984 class t_ARGTYPES_11>
10985struct InvokeResult_MemFuncPtrImpDispatch<
10986 typename bslmf::VoidType<
10987 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
10988 InvokeResult_ImpUtils::myDeclval<t_FN>())(
10989 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
10990 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
10991 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
10992 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
10993 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
10994 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
10995 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
10996 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
10997 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
10998 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
10999 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>()))>::type,
11000false,
11001true,
11002 t_FN,
11003 t_ARG1TYPE,
11004 t_ARGTYPES_01,
11005 t_ARGTYPES_02,
11006 t_ARGTYPES_03,
11007 t_ARGTYPES_04,
11008 t_ARGTYPES_05,
11009 t_ARGTYPES_06,
11010 t_ARGTYPES_07,
11011 t_ARGTYPES_08,
11012 t_ARGTYPES_09,
11013 t_ARGTYPES_10,
11014 t_ARGTYPES_11> : InvokeResult_ImpUtils {
11015
11016
11017 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
11018 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
11019 myDeclval<t_ARGTYPES_02>(),
11020 myDeclval<t_ARGTYPES_03>(),
11021 myDeclval<t_ARGTYPES_04>(),
11022 myDeclval<t_ARGTYPES_05>(),
11023 myDeclval<t_ARGTYPES_06>(),
11024 myDeclval<t_ARGTYPES_07>(),
11025 myDeclval<t_ARGTYPES_08>(),
11026 myDeclval<t_ARGTYPES_09>(),
11027 myDeclval<t_ARGTYPES_10>(),
11028 myDeclval<t_ARGTYPES_11>())) type;
11029};
11030#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
11031
11032#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
11033template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
11034 class t_ARGTYPES_02,
11035 class t_ARGTYPES_03,
11036 class t_ARGTYPES_04,
11037 class t_ARGTYPES_05,
11038 class t_ARGTYPES_06,
11039 class t_ARGTYPES_07,
11040 class t_ARGTYPES_08,
11041 class t_ARGTYPES_09,
11042 class t_ARGTYPES_10,
11043 class t_ARGTYPES_11,
11044 class t_ARGTYPES_12>
11045struct InvokeResult_MemFuncPtrImpDispatch<
11046 typename bslmf::VoidType<
11047 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
11048 InvokeResult_ImpUtils::myDeclval<t_FN>())(
11049 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
11050 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
11051 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
11052 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
11053 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
11054 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
11055 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
11056 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
11057 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
11058 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
11059 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
11060 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>()))>::type,
11061false,
11062true,
11063 t_FN,
11064 t_ARG1TYPE,
11065 t_ARGTYPES_01,
11066 t_ARGTYPES_02,
11067 t_ARGTYPES_03,
11068 t_ARGTYPES_04,
11069 t_ARGTYPES_05,
11070 t_ARGTYPES_06,
11071 t_ARGTYPES_07,
11072 t_ARGTYPES_08,
11073 t_ARGTYPES_09,
11074 t_ARGTYPES_10,
11075 t_ARGTYPES_11,
11076 t_ARGTYPES_12> : InvokeResult_ImpUtils {
11077
11078
11079 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
11080 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
11081 myDeclval<t_ARGTYPES_02>(),
11082 myDeclval<t_ARGTYPES_03>(),
11083 myDeclval<t_ARGTYPES_04>(),
11084 myDeclval<t_ARGTYPES_05>(),
11085 myDeclval<t_ARGTYPES_06>(),
11086 myDeclval<t_ARGTYPES_07>(),
11087 myDeclval<t_ARGTYPES_08>(),
11088 myDeclval<t_ARGTYPES_09>(),
11089 myDeclval<t_ARGTYPES_10>(),
11090 myDeclval<t_ARGTYPES_11>(),
11091 myDeclval<t_ARGTYPES_12>())) type;
11092};
11093#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
11094
11095#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
11096template <class t_FN, class t_ARG1TYPE, class t_ARGTYPES_01,
11097 class t_ARGTYPES_02,
11098 class t_ARGTYPES_03,
11099 class t_ARGTYPES_04,
11100 class t_ARGTYPES_05,
11101 class t_ARGTYPES_06,
11102 class t_ARGTYPES_07,
11103 class t_ARGTYPES_08,
11104 class t_ARGTYPES_09,
11105 class t_ARGTYPES_10,
11106 class t_ARGTYPES_11,
11107 class t_ARGTYPES_12,
11108 class t_ARGTYPES_13>
11109struct InvokeResult_MemFuncPtrImpDispatch<
11110 typename bslmf::VoidType<
11111 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
11112 InvokeResult_ImpUtils::myDeclval<t_FN>())(
11113 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_01>(),
11114 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_02>(),
11115 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_03>(),
11116 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_04>(),
11117 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_05>(),
11118 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_06>(),
11119 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_07>(),
11120 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_08>(),
11121 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_09>(),
11122 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_10>(),
11123 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_11>(),
11124 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_12>(),
11125 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES_13>()))>::type,
11126false,
11127true,
11128 t_FN,
11129 t_ARG1TYPE,
11130 t_ARGTYPES_01,
11131 t_ARGTYPES_02,
11132 t_ARGTYPES_03,
11133 t_ARGTYPES_04,
11134 t_ARGTYPES_05,
11135 t_ARGTYPES_06,
11136 t_ARGTYPES_07,
11137 t_ARGTYPES_08,
11138 t_ARGTYPES_09,
11139 t_ARGTYPES_10,
11140 t_ARGTYPES_11,
11141 t_ARGTYPES_12,
11142 t_ARGTYPES_13> : InvokeResult_ImpUtils {
11143
11144
11145 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
11146 myDeclval<t_FN>())(myDeclval<t_ARGTYPES_01>(),
11147 myDeclval<t_ARGTYPES_02>(),
11148 myDeclval<t_ARGTYPES_03>(),
11149 myDeclval<t_ARGTYPES_04>(),
11150 myDeclval<t_ARGTYPES_05>(),
11151 myDeclval<t_ARGTYPES_06>(),
11152 myDeclval<t_ARGTYPES_07>(),
11153 myDeclval<t_ARGTYPES_08>(),
11154 myDeclval<t_ARGTYPES_09>(),
11155 myDeclval<t_ARGTYPES_10>(),
11156 myDeclval<t_ARGTYPES_11>(),
11157 myDeclval<t_ARGTYPES_12>(),
11158 myDeclval<t_ARGTYPES_13>())) type;
11159};
11160#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
11161
11162
11163#endif
11164
11165
11166#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
11167template <class t_VOID_TYPE,
11168 bool t_ARG_DERIVES_FROM_CLASS,
11169 bool t_ARG_IS_REFERENCE_WRAPPER,
11170 class t_FN,
11171 class t_ARGTYPE>
11172struct InvokeResult_MemObjPtrImpDispatch;
11173
11174
11175#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
11176template <class t_FN>
11177struct InvokeResult_MemObjPtrImp<t_FN> {
11178};
11179#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
11180
11181#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
11182template <class t_FN, class t_ARGTYPES_01>
11183struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01> {
11184};
11185#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
11186
11187#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
11188template <class t_FN, class t_ARGTYPES_01,
11189 class t_ARGTYPES_02>
11190struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11191 t_ARGTYPES_02> {
11192};
11193#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
11194
11195#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
11196template <class t_FN, class t_ARGTYPES_01,
11197 class t_ARGTYPES_02,
11198 class t_ARGTYPES_03>
11199struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11200 t_ARGTYPES_02,
11201 t_ARGTYPES_03> {
11202};
11203#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
11204
11205#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
11206template <class t_FN, class t_ARGTYPES_01,
11207 class t_ARGTYPES_02,
11208 class t_ARGTYPES_03,
11209 class t_ARGTYPES_04>
11210struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11211 t_ARGTYPES_02,
11212 t_ARGTYPES_03,
11213 t_ARGTYPES_04> {
11214};
11215#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
11216
11217#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
11218template <class t_FN, class t_ARGTYPES_01,
11219 class t_ARGTYPES_02,
11220 class t_ARGTYPES_03,
11221 class t_ARGTYPES_04,
11222 class t_ARGTYPES_05>
11223struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11224 t_ARGTYPES_02,
11225 t_ARGTYPES_03,
11226 t_ARGTYPES_04,
11227 t_ARGTYPES_05> {
11228};
11229#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
11230
11231#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
11232template <class t_FN, class t_ARGTYPES_01,
11233 class t_ARGTYPES_02,
11234 class t_ARGTYPES_03,
11235 class t_ARGTYPES_04,
11236 class t_ARGTYPES_05,
11237 class t_ARGTYPES_06>
11238struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11239 t_ARGTYPES_02,
11240 t_ARGTYPES_03,
11241 t_ARGTYPES_04,
11242 t_ARGTYPES_05,
11243 t_ARGTYPES_06> {
11244};
11245#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
11246
11247#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
11248template <class t_FN, class t_ARGTYPES_01,
11249 class t_ARGTYPES_02,
11250 class t_ARGTYPES_03,
11251 class t_ARGTYPES_04,
11252 class t_ARGTYPES_05,
11253 class t_ARGTYPES_06,
11254 class t_ARGTYPES_07>
11255struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11256 t_ARGTYPES_02,
11257 t_ARGTYPES_03,
11258 t_ARGTYPES_04,
11259 t_ARGTYPES_05,
11260 t_ARGTYPES_06,
11261 t_ARGTYPES_07> {
11262};
11263#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
11264
11265#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
11266template <class t_FN, class t_ARGTYPES_01,
11267 class t_ARGTYPES_02,
11268 class t_ARGTYPES_03,
11269 class t_ARGTYPES_04,
11270 class t_ARGTYPES_05,
11271 class t_ARGTYPES_06,
11272 class t_ARGTYPES_07,
11273 class t_ARGTYPES_08>
11274struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11275 t_ARGTYPES_02,
11276 t_ARGTYPES_03,
11277 t_ARGTYPES_04,
11278 t_ARGTYPES_05,
11279 t_ARGTYPES_06,
11280 t_ARGTYPES_07,
11281 t_ARGTYPES_08> {
11282};
11283#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
11284
11285#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
11286template <class t_FN, class t_ARGTYPES_01,
11287 class t_ARGTYPES_02,
11288 class t_ARGTYPES_03,
11289 class t_ARGTYPES_04,
11290 class t_ARGTYPES_05,
11291 class t_ARGTYPES_06,
11292 class t_ARGTYPES_07,
11293 class t_ARGTYPES_08,
11294 class t_ARGTYPES_09>
11295struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11296 t_ARGTYPES_02,
11297 t_ARGTYPES_03,
11298 t_ARGTYPES_04,
11299 t_ARGTYPES_05,
11300 t_ARGTYPES_06,
11301 t_ARGTYPES_07,
11302 t_ARGTYPES_08,
11303 t_ARGTYPES_09> {
11304};
11305#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
11306
11307#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
11308template <class t_FN, class t_ARGTYPES_01,
11309 class t_ARGTYPES_02,
11310 class t_ARGTYPES_03,
11311 class t_ARGTYPES_04,
11312 class t_ARGTYPES_05,
11313 class t_ARGTYPES_06,
11314 class t_ARGTYPES_07,
11315 class t_ARGTYPES_08,
11316 class t_ARGTYPES_09,
11317 class t_ARGTYPES_10>
11318struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11319 t_ARGTYPES_02,
11320 t_ARGTYPES_03,
11321 t_ARGTYPES_04,
11322 t_ARGTYPES_05,
11323 t_ARGTYPES_06,
11324 t_ARGTYPES_07,
11325 t_ARGTYPES_08,
11326 t_ARGTYPES_09,
11327 t_ARGTYPES_10> {
11328};
11329#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
11330
11331#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
11332template <class t_FN, class t_ARGTYPES_01,
11333 class t_ARGTYPES_02,
11334 class t_ARGTYPES_03,
11335 class t_ARGTYPES_04,
11336 class t_ARGTYPES_05,
11337 class t_ARGTYPES_06,
11338 class t_ARGTYPES_07,
11339 class t_ARGTYPES_08,
11340 class t_ARGTYPES_09,
11341 class t_ARGTYPES_10,
11342 class t_ARGTYPES_11>
11343struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11344 t_ARGTYPES_02,
11345 t_ARGTYPES_03,
11346 t_ARGTYPES_04,
11347 t_ARGTYPES_05,
11348 t_ARGTYPES_06,
11349 t_ARGTYPES_07,
11350 t_ARGTYPES_08,
11351 t_ARGTYPES_09,
11352 t_ARGTYPES_10,
11353 t_ARGTYPES_11> {
11354};
11355#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
11356
11357#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
11358template <class t_FN, class t_ARGTYPES_01,
11359 class t_ARGTYPES_02,
11360 class t_ARGTYPES_03,
11361 class t_ARGTYPES_04,
11362 class t_ARGTYPES_05,
11363 class t_ARGTYPES_06,
11364 class t_ARGTYPES_07,
11365 class t_ARGTYPES_08,
11366 class t_ARGTYPES_09,
11367 class t_ARGTYPES_10,
11368 class t_ARGTYPES_11,
11369 class t_ARGTYPES_12>
11370struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11371 t_ARGTYPES_02,
11372 t_ARGTYPES_03,
11373 t_ARGTYPES_04,
11374 t_ARGTYPES_05,
11375 t_ARGTYPES_06,
11376 t_ARGTYPES_07,
11377 t_ARGTYPES_08,
11378 t_ARGTYPES_09,
11379 t_ARGTYPES_10,
11380 t_ARGTYPES_11,
11381 t_ARGTYPES_12> {
11382};
11383#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
11384
11385#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
11386template <class t_FN, class t_ARGTYPES_01,
11387 class t_ARGTYPES_02,
11388 class t_ARGTYPES_03,
11389 class t_ARGTYPES_04,
11390 class t_ARGTYPES_05,
11391 class t_ARGTYPES_06,
11392 class t_ARGTYPES_07,
11393 class t_ARGTYPES_08,
11394 class t_ARGTYPES_09,
11395 class t_ARGTYPES_10,
11396 class t_ARGTYPES_11,
11397 class t_ARGTYPES_12,
11398 class t_ARGTYPES_13>
11399struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11400 t_ARGTYPES_02,
11401 t_ARGTYPES_03,
11402 t_ARGTYPES_04,
11403 t_ARGTYPES_05,
11404 t_ARGTYPES_06,
11405 t_ARGTYPES_07,
11406 t_ARGTYPES_08,
11407 t_ARGTYPES_09,
11408 t_ARGTYPES_10,
11409 t_ARGTYPES_11,
11410 t_ARGTYPES_12,
11411 t_ARGTYPES_13> {
11412};
11413#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
11414
11415
11416template <class t_FN, class t_ARGTYPE>
11417struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPE>
11418: InvokeResult_MemObjPtrImpDispatch<
11419 void,
11420 IsAccessibleBaseOf<
11421 typename MemberPointerTraits<t_FN>::ClassType,
11422 typename bsl::remove_reference<t_ARGTYPE>::type>::value,
11423 IsReferenceWrapper<typename bsl::remove_const<
11424 typename bsl::remove_reference<t_ARGTYPE>::type>::type>::value,
11425 t_FN,
11426 t_ARGTYPE> {
11427};
11428
11429#else
11430
11431#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
11432template <class t_FN>
11433struct InvokeResult_MemObjPtrImp<t_FN> {
11434};
11435#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 0
11436
11437#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
11438template <class t_FN, class t_ARGTYPES_01>
11439struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01> {
11440};
11441#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 1
11442
11443#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
11444template <class t_FN, class t_ARGTYPES_01,
11445 class t_ARGTYPES_02>
11446struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11447 t_ARGTYPES_02> {
11448};
11449#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 2
11450
11451#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
11452template <class t_FN, class t_ARGTYPES_01,
11453 class t_ARGTYPES_02,
11454 class t_ARGTYPES_03>
11455struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11456 t_ARGTYPES_02,
11457 t_ARGTYPES_03> {
11458};
11459#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 3
11460
11461#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
11462template <class t_FN, class t_ARGTYPES_01,
11463 class t_ARGTYPES_02,
11464 class t_ARGTYPES_03,
11465 class t_ARGTYPES_04>
11466struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11467 t_ARGTYPES_02,
11468 t_ARGTYPES_03,
11469 t_ARGTYPES_04> {
11470};
11471#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 4
11472
11473#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
11474template <class t_FN, class t_ARGTYPES_01,
11475 class t_ARGTYPES_02,
11476 class t_ARGTYPES_03,
11477 class t_ARGTYPES_04,
11478 class t_ARGTYPES_05>
11479struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11480 t_ARGTYPES_02,
11481 t_ARGTYPES_03,
11482 t_ARGTYPES_04,
11483 t_ARGTYPES_05> {
11484};
11485#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 5
11486
11487#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
11488template <class t_FN, class t_ARGTYPES_01,
11489 class t_ARGTYPES_02,
11490 class t_ARGTYPES_03,
11491 class t_ARGTYPES_04,
11492 class t_ARGTYPES_05,
11493 class t_ARGTYPES_06>
11494struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11495 t_ARGTYPES_02,
11496 t_ARGTYPES_03,
11497 t_ARGTYPES_04,
11498 t_ARGTYPES_05,
11499 t_ARGTYPES_06> {
11500};
11501#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 6
11502
11503#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
11504template <class t_FN, class t_ARGTYPES_01,
11505 class t_ARGTYPES_02,
11506 class t_ARGTYPES_03,
11507 class t_ARGTYPES_04,
11508 class t_ARGTYPES_05,
11509 class t_ARGTYPES_06,
11510 class t_ARGTYPES_07>
11511struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11512 t_ARGTYPES_02,
11513 t_ARGTYPES_03,
11514 t_ARGTYPES_04,
11515 t_ARGTYPES_05,
11516 t_ARGTYPES_06,
11517 t_ARGTYPES_07> {
11518};
11519#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 7
11520
11521#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
11522template <class t_FN, class t_ARGTYPES_01,
11523 class t_ARGTYPES_02,
11524 class t_ARGTYPES_03,
11525 class t_ARGTYPES_04,
11526 class t_ARGTYPES_05,
11527 class t_ARGTYPES_06,
11528 class t_ARGTYPES_07,
11529 class t_ARGTYPES_08>
11530struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11531 t_ARGTYPES_02,
11532 t_ARGTYPES_03,
11533 t_ARGTYPES_04,
11534 t_ARGTYPES_05,
11535 t_ARGTYPES_06,
11536 t_ARGTYPES_07,
11537 t_ARGTYPES_08> {
11538};
11539#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 8
11540
11541#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
11542template <class t_FN, class t_ARGTYPES_01,
11543 class t_ARGTYPES_02,
11544 class t_ARGTYPES_03,
11545 class t_ARGTYPES_04,
11546 class t_ARGTYPES_05,
11547 class t_ARGTYPES_06,
11548 class t_ARGTYPES_07,
11549 class t_ARGTYPES_08,
11550 class t_ARGTYPES_09>
11551struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11552 t_ARGTYPES_02,
11553 t_ARGTYPES_03,
11554 t_ARGTYPES_04,
11555 t_ARGTYPES_05,
11556 t_ARGTYPES_06,
11557 t_ARGTYPES_07,
11558 t_ARGTYPES_08,
11559 t_ARGTYPES_09> {
11560};
11561#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 9
11562
11563#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
11564template <class t_FN, class t_ARGTYPES_01,
11565 class t_ARGTYPES_02,
11566 class t_ARGTYPES_03,
11567 class t_ARGTYPES_04,
11568 class t_ARGTYPES_05,
11569 class t_ARGTYPES_06,
11570 class t_ARGTYPES_07,
11571 class t_ARGTYPES_08,
11572 class t_ARGTYPES_09,
11573 class t_ARGTYPES_10>
11574struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11575 t_ARGTYPES_02,
11576 t_ARGTYPES_03,
11577 t_ARGTYPES_04,
11578 t_ARGTYPES_05,
11579 t_ARGTYPES_06,
11580 t_ARGTYPES_07,
11581 t_ARGTYPES_08,
11582 t_ARGTYPES_09,
11583 t_ARGTYPES_10> {
11584};
11585#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 10
11586
11587#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
11588template <class t_FN, class t_ARGTYPES_01,
11589 class t_ARGTYPES_02,
11590 class t_ARGTYPES_03,
11591 class t_ARGTYPES_04,
11592 class t_ARGTYPES_05,
11593 class t_ARGTYPES_06,
11594 class t_ARGTYPES_07,
11595 class t_ARGTYPES_08,
11596 class t_ARGTYPES_09,
11597 class t_ARGTYPES_10,
11598 class t_ARGTYPES_11>
11599struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11600 t_ARGTYPES_02,
11601 t_ARGTYPES_03,
11602 t_ARGTYPES_04,
11603 t_ARGTYPES_05,
11604 t_ARGTYPES_06,
11605 t_ARGTYPES_07,
11606 t_ARGTYPES_08,
11607 t_ARGTYPES_09,
11608 t_ARGTYPES_10,
11609 t_ARGTYPES_11> {
11610};
11611#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 11
11612
11613#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
11614template <class t_FN, class t_ARGTYPES_01,
11615 class t_ARGTYPES_02,
11616 class t_ARGTYPES_03,
11617 class t_ARGTYPES_04,
11618 class t_ARGTYPES_05,
11619 class t_ARGTYPES_06,
11620 class t_ARGTYPES_07,
11621 class t_ARGTYPES_08,
11622 class t_ARGTYPES_09,
11623 class t_ARGTYPES_10,
11624 class t_ARGTYPES_11,
11625 class t_ARGTYPES_12>
11626struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11627 t_ARGTYPES_02,
11628 t_ARGTYPES_03,
11629 t_ARGTYPES_04,
11630 t_ARGTYPES_05,
11631 t_ARGTYPES_06,
11632 t_ARGTYPES_07,
11633 t_ARGTYPES_08,
11634 t_ARGTYPES_09,
11635 t_ARGTYPES_10,
11636 t_ARGTYPES_11,
11637 t_ARGTYPES_12> {
11638};
11639#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 12
11640
11641#if BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
11642template <class t_FN, class t_ARGTYPES_01,
11643 class t_ARGTYPES_02,
11644 class t_ARGTYPES_03,
11645 class t_ARGTYPES_04,
11646 class t_ARGTYPES_05,
11647 class t_ARGTYPES_06,
11648 class t_ARGTYPES_07,
11649 class t_ARGTYPES_08,
11650 class t_ARGTYPES_09,
11651 class t_ARGTYPES_10,
11652 class t_ARGTYPES_11,
11653 class t_ARGTYPES_12,
11654 class t_ARGTYPES_13>
11655struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES_01,
11656 t_ARGTYPES_02,
11657 t_ARGTYPES_03,
11658 t_ARGTYPES_04,
11659 t_ARGTYPES_05,
11660 t_ARGTYPES_06,
11661 t_ARGTYPES_07,
11662 t_ARGTYPES_08,
11663 t_ARGTYPES_09,
11664 t_ARGTYPES_10,
11665 t_ARGTYPES_11,
11666 t_ARGTYPES_12,
11667 t_ARGTYPES_13> {
11668};
11669#endif // BSLMF_INVOKERESULT_VARIADIC_LIMIT_E >= 13
11670
11671
11672template <class t_CLASS, class t_RET, class t_ARGTYPE>
11673struct InvokeResult_MemObjPtrImp<t_RET t_CLASS::*, t_ARGTYPE> {
11674
11675 private:
11676 typedef InvokeResult_MemPtrArgQualifiers<t_CLASS, t_ARGTYPE> ArgQualifiers;
11677
11678 typedef typename InvokeResult_AddCVRef<t_RET,
11679 ArgQualifiers::k_IS_CONST,
11680 ArgQualifiers::k_IS_VOLATILE,
11681 ArgQualifiers::k_IS_LVALUE>::type
11682 cvtype;
11683
11684 public:
11685#ifdef BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES
11686 typedef typename bsl::conditional<
11687 ArgQualifiers::k_IS_LVALUE,
11688 cvtype,
11689 typename bsl::add_rvalue_reference<cvtype>::type>::type type;
11690#else
11691 typedef cvtype type;
11692#endif
11693};
11694#endif
11695
11696
11697#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
11698template <class t_VOID_TYPE,
11699 bool t_ARG_DERIVES_FROM_CLASS,
11700 bool t_ARG_IS_REFERENCE_WRAPPER,
11701 class t_FN,
11702 class t_ARGTYPE>
11703struct InvokeResult_MemObjPtrImpDispatch {
11704};
11705
11706template <class t_FN, class t_ARGTYPE>
11707struct InvokeResult_MemObjPtrImpDispatch<
11708 typename bslmf::VoidType<
11709 decltype((*InvokeResult_ImpUtils::myDeclval<t_ARGTYPE>()).*
11710 InvokeResult_ImpUtils::myDeclval<t_FN>())>::type,
11711false,
11712false,
11713 t_FN,
11714 t_ARGTYPE> : InvokeResult_ImpUtils {
11715
11716 typedef decltype((*myDeclval<t_ARGTYPE>()).*myDeclval<t_FN>()) type;
11717};
11718
11719template <class t_FN, class t_ARGTYPE>
11720struct InvokeResult_MemObjPtrImpDispatch<
11721 typename bslmf::VoidType<
11722 decltype(InvokeResult_ImpUtils::myDeclval<t_ARGTYPE>().*
11723 InvokeResult_ImpUtils::myDeclval<t_FN>())>::type,
11724true,
11725false,
11726 t_FN,
11727 t_ARGTYPE> : InvokeResult_ImpUtils {
11728
11729 typedef decltype(myDeclval<t_ARGTYPE>().*myDeclval<t_FN>()) type;
11730};
11731
11732template <class t_FN, class t_ARGTYPE>
11733struct InvokeResult_MemObjPtrImpDispatch<
11734 typename bslmf::VoidType<
11735 decltype(InvokeResult_ImpUtils::myDeclval<t_ARGTYPE>().get().*
11736 InvokeResult_ImpUtils::myDeclval<t_FN>())>::type,
11737false,
11738true,
11739 t_FN,
11740 t_ARGTYPE> : InvokeResult_ImpUtils {
11741
11742 typedef decltype(myDeclval<t_ARGTYPE>().get().*myDeclval<t_FN>()) type;
11743};
11744
11745#endif
11746#else
11747// The generated code below is a workaround for the absence of perfect
11748// forwarding in some compilers.
11749
11750template <class t_VOID_TYPE, class t_FN, class... t_ARGTYPES>
11751struct InvokeResult_FunctorImp;
11752
11753template <class t_VOID_TYPE, class t_FN, class... t_ARGTYPES>
11754struct InvokeResult_FuncPtrImp;
11755
11756template <class t_FN, class... t_ARGTYPES>
11757struct InvokeResult_MemFuncPtrImp;
11758
11759template <class t_FN, class... t_ARGTYPES>
11760struct InvokeResult_MemObjPtrImp;
11761
11762
11763template <bool t_IS_FUNCPTR,
11764 bool t_IS_MEMFUNCPTR,
11765 bool t_IS_MEMOBJPTR,
11766 class t_FN,
11767 class... t_ARGTYPES>
11768struct InvokeResult_Imp : InvokeResult_FunctorImp<void, t_FN, t_ARGTYPES...> {
11769};
11770
11771template <class t_FN, class... t_ARGTYPES>
11772struct InvokeResult_Imp<true ,
11773 false,
11774 false,
11775 t_FN,
11776 t_ARGTYPES...>
11777: InvokeResult_FuncPtrImp<void, t_FN, t_ARGTYPES...> {
11778};
11779
11780template <class t_FN, class... t_ARGTYPES>
11781struct InvokeResult_Imp<false,
11782 true ,
11783 false,
11784 t_FN,
11785 t_ARGTYPES...>
11786: InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES...> {
11787};
11788
11789template <class t_FN, class... t_ARGTYPES>
11790struct InvokeResult_Imp<false,
11791 false,
11792 true ,
11793 t_FN,
11794 t_ARGTYPES...>
11795: InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPES...> {
11796};
11797
11798
11799#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
11800template <class t_VOID_TYPE, class t_FN, class... t_ARGTYPES>
11801struct InvokeResult_FunctorImp {
11802};
11803
11804template <class t_FN, class... t_ARGTYPES>
11805struct InvokeResult_FunctorImp<
11806 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
11807 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES>()...))>::type,
11808 t_FN,
11809 t_ARGTYPES...> : InvokeResult_ImpUtils {
11810
11811
11812 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...)) type;
11813};
11814#else
11815template <class t_VOID_TYPE, class t_FN, class... t_ARGTYPES>
11816struct InvokeResult_FunctorImp : InvokeResult_ImpUtils {
11817
11818 enum {
11819 k_IS_VOID = BSLMF_TAG_TO_INT((
11820 myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...),
11821 InvokeResult_VoidChecker()))
11822 };
11823
11824 typedef typename InvokeResult_FunctorDeduction<k_IS_VOID,
11825 t_FN,
11826 t_ARGTYPES...>::type type;
11827};
11828#endif
11829
11830
11831#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
11832template <class t_VOID_TYPE, class t_FN, class... t_ARGTYPES>
11833struct InvokeResult_FuncPtrImp {
11834};
11835
11836template <class t_FN, class... t_ARGTYPES>
11837struct InvokeResult_FuncPtrImp<
11838 typename bslmf::VoidType<decltype(InvokeResult_ImpUtils::myDeclval<t_FN>()(
11839 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES>()...))>::type,
11840 t_FN,
11841 t_ARGTYPES...> : InvokeResult_ImpUtils {
11842
11843
11844 typedef decltype(myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...)) type;
11845};
11846#else
11847template <class t_VOID_TYPE, class t_FN, class... t_ARGTYPES>
11848struct InvokeResult_FuncPtrImp {
11849
11850 typedef typename bslmf::FunctionPointerTraits<t_FN>::ResultType QType;
11851
11852 typedef typename bsl::conditional<
11853 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
11854 QType,
11855 typename bsl::remove_cv<QType>::type>::type type;
11856};
11857#endif
11858
11859
11860#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
11861template <class t_VOID_TYPE,
11862 bool t_ARG1_DERIVES_FROM_CLASS,
11863 bool t_ARG1_IS_REFERENCE_WRAPPER,
11864 class t_FN,
11865 class t_ARG1TYPE,
11866 class... t_ARGTYPES>
11867struct InvokeResult_MemFuncPtrImpDispatch;
11868
11869
11870template <class t_FN>
11871struct InvokeResult_MemFuncPtrImp<t_FN> {
11872};
11873
11874template <class t_FN, class t_ARG1TYPE, class... t_ARGTYPES>
11875struct InvokeResult_MemFuncPtrImp<t_FN, t_ARG1TYPE, t_ARGTYPES...>
11876: InvokeResult_MemFuncPtrImpDispatch<
11877 void,
11878 IsAccessibleBaseOf<
11879 typename MemberFunctionPointerTraits<t_FN>::ClassType,
11880 typename bsl::remove_reference<t_ARG1TYPE>::type>::value,
11881 IsReferenceWrapper<typename bsl::remove_const<
11882 typename bsl::remove_reference<t_ARG1TYPE>::type>::type>::value,
11883 t_FN,
11884 t_ARG1TYPE,
11885 t_ARGTYPES...> {
11886};
11887#else
11888template <class t_FN, class... t_ARGTYPES>
11889struct InvokeResult_MemFuncPtrImp<t_FN, t_ARGTYPES...> {
11890
11891 typedef typename MemberFunctionPointerTraits<t_FN>::ResultType QType;
11892
11893 typedef typename bsl::conditional<
11894 bsl::is_reference<QType>::value || bsl::is_class<QType>::value,
11895 QType,
11896 typename bsl::remove_cv<QType>::type>::type type;
11897};
11898#endif
11899
11900
11901#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
11902template <class t_VOID_TYPE,
11903 bool t_ARG1_DERIVES_FROM_CLASS,
11904 bool t_ARG1_IS_REFERENCE_WRAPPER,
11905 class t_FN,
11906 class t_ARG1TYPE,
11907 class... t_ARGTYPES>
11908struct InvokeResult_MemFuncPtrImpDispatch {
11909};
11910
11911template <class t_FN, class t_ARG1TYPE, class... t_ARGTYPES>
11912struct InvokeResult_MemFuncPtrImpDispatch<
11913 typename bslmf::VoidType<
11914 decltype(((*InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>()).*
11915 InvokeResult_ImpUtils::myDeclval<t_FN>())(
11916 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES>()...))>::type,
11917false,
11918false,
11919 t_FN,
11920 t_ARG1TYPE,
11921 t_ARGTYPES...> : InvokeResult_ImpUtils {
11922
11923
11924 typedef decltype(((*myDeclval<t_ARG1TYPE>()).*
11925 myDeclval<t_FN>())(myDeclval<t_ARGTYPES>()...)) type;
11926};
11927
11928template <class t_FN, class t_ARG1TYPE, class... t_ARGTYPES>
11929struct InvokeResult_MemFuncPtrImpDispatch<
11930 typename bslmf::VoidType<
11931 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().*
11932 InvokeResult_ImpUtils::myDeclval<t_FN>())(
11933 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES>()...))>::type,
11934true,
11935false,
11936 t_FN,
11937 t_ARG1TYPE,
11938 t_ARGTYPES...> : InvokeResult_ImpUtils {
11939
11940
11941 typedef decltype((myDeclval<t_ARG1TYPE>().*
11942 myDeclval<t_FN>())(myDeclval<t_ARGTYPES>()...)) type;
11943};
11944
11945template <class t_FN, class t_ARG1TYPE, class... t_ARGTYPES>
11946struct InvokeResult_MemFuncPtrImpDispatch<
11947 typename bslmf::VoidType<
11948 decltype((InvokeResult_ImpUtils::myDeclval<t_ARG1TYPE>().get().*
11949 InvokeResult_ImpUtils::myDeclval<t_FN>())(
11950 InvokeResult_ImpUtils::myDeclval<t_ARGTYPES>()...))>::type,
11951false,
11952true,
11953 t_FN,
11954 t_ARG1TYPE,
11955 t_ARGTYPES...> : InvokeResult_ImpUtils {
11956
11957
11958 typedef decltype((myDeclval<t_ARG1TYPE>().get().*
11959 myDeclval<t_FN>())(myDeclval<t_ARGTYPES>()...)) type;
11960};
11961
11962#endif
11963
11964
11965#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
11966template <class t_VOID_TYPE,
11967 bool t_ARG_DERIVES_FROM_CLASS,
11968 bool t_ARG_IS_REFERENCE_WRAPPER,
11969 class t_FN,
11970 class t_ARGTYPE>
11971struct InvokeResult_MemObjPtrImpDispatch;
11972
11973
11974template <class t_FN, class... t_ARGTYPES>
11975struct InvokeResult_MemObjPtrImp {
11976};
11977
11978template <class t_FN, class t_ARGTYPE>
11979struct InvokeResult_MemObjPtrImp<t_FN, t_ARGTYPE>
11980: InvokeResult_MemObjPtrImpDispatch<
11981 void,
11982 IsAccessibleBaseOf<
11983 typename MemberPointerTraits<t_FN>::ClassType,
11984 typename bsl::remove_reference<t_ARGTYPE>::type>::value,
11985 IsReferenceWrapper<typename bsl::remove_const<
11986 typename bsl::remove_reference<t_ARGTYPE>::type>::type>::value,
11987 t_FN,
11988 t_ARGTYPE> {
11989};
11990
11991#else
11992
11993template <class t_FN, class... t_ARGTYPES>
11994struct InvokeResult_MemObjPtrImp {
11995};
11996
11997template <class t_CLASS, class t_RET, class t_ARGTYPE>
11998struct InvokeResult_MemObjPtrImp<t_RET t_CLASS::*, t_ARGTYPE> {
11999
12000 private:
12001 typedef InvokeResult_MemPtrArgQualifiers<t_CLASS, t_ARGTYPE> ArgQualifiers;
12002
12003 typedef typename InvokeResult_AddCVRef<t_RET,
12004 ArgQualifiers::k_IS_CONST,
12005 ArgQualifiers::k_IS_VOLATILE,
12006 ArgQualifiers::k_IS_LVALUE>::type
12007 cvtype;
12008
12009 public:
12010#ifdef BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES
12011 typedef typename bsl::conditional<
12012 ArgQualifiers::k_IS_LVALUE,
12013 cvtype,
12014 typename bsl::add_rvalue_reference<cvtype>::type>::type type;
12015#else
12016 typedef cvtype type;
12017#endif
12018};
12019#endif
12020
12021
12022#ifdef BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS
12023template <class t_VOID_TYPE,
12024 bool t_ARG_DERIVES_FROM_CLASS,
12025 bool t_ARG_IS_REFERENCE_WRAPPER,
12026 class t_FN,
12027 class t_ARGTYPE>
12028struct InvokeResult_MemObjPtrImpDispatch {
12029};
12030
12031template <class t_FN, class t_ARGTYPE>
12032struct InvokeResult_MemObjPtrImpDispatch<
12033 typename bslmf::VoidType<
12034 decltype((*InvokeResult_ImpUtils::myDeclval<t_ARGTYPE>()).*
12035 InvokeResult_ImpUtils::myDeclval<t_FN>())>::type,
12036false,
12037false,
12038 t_FN,
12039 t_ARGTYPE> : InvokeResult_ImpUtils {
12040
12041 typedef decltype((*myDeclval<t_ARGTYPE>()).*myDeclval<t_FN>()) type;
12042};
12043
12044template <class t_FN, class t_ARGTYPE>
12045struct InvokeResult_MemObjPtrImpDispatch<
12046 typename bslmf::VoidType<
12047 decltype(InvokeResult_ImpUtils::myDeclval<t_ARGTYPE>().*
12048 InvokeResult_ImpUtils::myDeclval<t_FN>())>::type,
12049true,
12050false,
12051 t_FN,
12052 t_ARGTYPE> : InvokeResult_ImpUtils {
12053
12054 typedef decltype(myDeclval<t_ARGTYPE>().*myDeclval<t_FN>()) type;
12055};
12056
12057template <class t_FN, class t_ARGTYPE>
12058struct InvokeResult_MemObjPtrImpDispatch<
12059 typename bslmf::VoidType<
12060 decltype(InvokeResult_ImpUtils::myDeclval<t_ARGTYPE>().get().*
12061 InvokeResult_ImpUtils::myDeclval<t_FN>())>::type,
12062false,
12063true,
12064 t_FN,
12065 t_ARGTYPE> : InvokeResult_ImpUtils {
12066
12067 typedef decltype(myDeclval<t_ARGTYPE>().get().*myDeclval<t_FN>()) type;
12068};
12069
12070#endif
12071
12072// }}} END GENERATED CODE
12073#endif
12074
12075} // close package namespace
12076
12077
12078#else // if ! defined(DEFINED_BSLMF_INVOKERESULT_H)
12079# error Not valid except when included from bslmf_invokeresult.h
12080#endif // ! defined(COMPILING_BSLMF_INVOKERESULT_H)
12081
12082#endif // ! defined(INCLUDED_BSLMF_INVOKERESULT_CPP03)
12083
12084// ----------------------------------------------------------------------------
12085// Copyright 2018 Bloomberg Finance L.P.
12086//
12087// Licensed under the Apache License, Version 2.0 (the "License");
12088// you may not use this file except in compliance with the License.
12089// You may obtain a copy of the License at
12090//
12091// http://www.apache.org/licenses/LICENSE-2.0
12092//
12093// Unless required by applicable law or agreed to in writing, software
12094// distributed under the License is distributed on an "AS IS" BASIS,
12095// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12096// See the License for the specific language governing permissions and
12097// limitations under the License.
12098// ----------------------------- END-OF-FILE ----------------------------------
12099
12100/** @} */
12101/** @} */
12102/** @} */
bsl::decay< MovableRefUtil_RemoveReference< t_TYPE >::type >::type
decay_imp< U, k_ISARRAY, k_ISFUNC >::type type
Definition bslmf_decay.h:166
BSLMF_TAG_TO_INT
#define BSLMF_TAG_TO_INT(BSLMF_EXPR)
Definition bslmf_tag.h:176
bsl
Definition bdlb_printmethods.h:283
bsl::nullptr_t
BloombergLP::bsls::Nullptr_Impl::Type nullptr_t
Definition bsls_nullptr.h:281
bslmf
Definition bdlbb_blob.h:576
bsl::add_const::type
BloombergLP::bslmf::AddConst_Imp< t_TYPE,!is_reference< t_TYPE >::value &&!is_function< t_TYPE >::value &&!is_const< t_TYPE >::value >::Type type
Definition bslmf_addconst.h:172
bsl::add_lvalue_reference::type
t_TYPE & type
This typedef defines the return type of this meta function.
Definition bslmf_addlvaluereference.h:129
bsl::add_pointer::type
BloombergLP::bslmf::AddPointer_Impl< t_TYPE >::type type
Definition bslmf_addpointer.h:175
bsl::add_volatile::type
BloombergLP::bslmf::AddVolatile_Imp< t_TYPE,!is_reference< t_TYPE >::value &&!is_function< t_TYPE >::value &&!is_volatile< t_TYPE >::value >::Type type
Definition bslmf_addvolatile.h:174
bsl::conditional
Definition bslmf_conditional.h:120
bsl::enable_if
Definition bslmf_enableif.h:525
bsl::is_class
Definition bslmf_isclass.h:163
bsl::is_const
Definition bslmf_isconst.h:144
bsl::is_convertible
Definition bslmf_isconvertible.h:867
bsl::is_lvalue_reference
Definition bslmf_islvaluereference.h:125
bsl::is_member_object_pointer
Definition bslmf_ismemberobjectpointer.h:141
bsl::is_reference
Definition bslmf_isreference.h:137
bsl::is_rvalue_reference
Definition bslmf_isrvaluereference.h:126
bsl::is_volatile
Definition bslmf_isvolatile.h:144
bsl::remove_cv::type
remove_const< typenameremove_volatile< t_TYPE >::type >::type type
Definition bslmf_removecv.h:126
bslmf::FunctionPointerTraits
Definition bslmf_functionpointertraits.h:137
bslmf::InvokeResultDeductionFailed::InvokeResultDeductionFailed
InvokeResultDeductionFailed(const t_TYPE &)
Definition bslmf_invokeresult.h:315
bslmf::InvokeResult_BaseCalcUtil::BaseType
BloombergLP::bslmf::InvokeResult_Imp< k_IS_FUNCPTR, k_IS_MEMFUNCPTR, k_IS_MEMOBJPTR, FwdFn, t_ARGTYPES... > BaseType
Definition bslmf_invokeresult.h:453
bslmf::InvokeResult_ImpUtils::AnyLvalue::AnyLvalue
AnyLvalue(volatile t_TP &)
(Declared but not defined) Convert from any lvalue argument.
bslmf::InvokeResult_ImpUtils::AnyRvalue::AnyRvalue
AnyRvalue(t_TP)
bslmf::ResultType_Fallback::type
t_FALLBACK type
Definition bslmf_resulttype.h:260
bslmf::Tag
Definition bslmf_tag.h:163