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