BDE 4.14.0 Production release
Loading...
Searching...
No Matches
bslstl_function_invokerutil_cpp03.h
Go to the documentation of this file.
1/// @file bslstl_function_invokerutil_cpp03.h
2///
3/// The content of this file has been pre-processed for Doxygen.
4///
5
6
7// bslstl_function_invokerutil_cpp03.h -*-C++-*-
8
9// Automatically generated file. **DO NOT EDIT**
10
11#ifndef INCLUDED_BSLSTL_FUNCTION_INVOKERUTIL_CPP03
12#define INCLUDED_BSLSTL_FUNCTION_INVOKERUTIL_CPP03
13
14/// @defgroup bslstl_function_invokerutil_cpp03 bslstl_function_invokerutil_cpp03
15/// @brief Provide C++03 implementation for bslstl_function_invokerutil.h
16/// @addtogroup bsl
17/// @{
18/// @addtogroup bslstl
19/// @{
20/// @addtogroup bslstl_function_invokerutil_cpp03
21/// @{
22///
23/// <h1> Outline </h1>
24/// * <a href="#bslstl_function_invokerutil_cpp03-purpose"> Purpose</a>
25/// * <a href="#bslstl_function_invokerutil_cpp03-classes"> Classes </a>
26/// * <a href="#bslstl_function_invokerutil_cpp03-description"> Description </a>
27///
28/// # Purpose {#bslstl_function_invokerutil_cpp03-purpose}
29/// Provide C++03 implementation for bslstl_function_invokerutil.h
30///
31/// # Classes {#bslstl_function_invokerutil_cpp03-classes}
32/// See bslstl_function_invokerutil.h for list of classes
33///
34/// @see bslstl_function_invokerutil
35///
36/// # Description {#bslstl_function_invokerutil_cpp03-description}
37/// This component is the C++03 translation of a C++11 component,
38/// generated by the 'sim_cpp11_features.pl' program. If the original header
39/// contains any specially delimited regions of C++11 code, then this generated
40/// file contains the C++03 equivalent, i.e., with variadic templates expanded
41/// and rvalue-references replaced by 'bslmf::MovableRef' objects. The header
42/// code in this file is designed to be '#include'd into the original header
43/// when compiling with a C++03 compiler. If there are no specially delimited
44/// regions of C++11 code, then this header contains no code and is not
45/// '#include'd in the original header.
46///
47/// Generated on Sun Sep 1 05:39:09 2024
48/// Command line: sim_cpp11_features.pl bslstl_function_invokerutil.h
49/// @}
50/** @} */
51/** @} */
52
53/** @addtogroup bsl
54 * @{
55 */
56/** @addtogroup bslstl
57 * @{
58 */
59/** @addtogroup bslstl_function_invokerutil_cpp03
60 * @{
61 */
62
63#ifdef COMPILING_BSLSTL_FUNCTION_INVOKERUTIL_H
64
65#ifndef BSLS_PLATFORM_CMP_SUN
66#define BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET, X) static_cast<RET>(X)
67#else
68#define BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET, X) (RET)(X)
69#endif
70
71#if defined(BSLMF_INVOKERESULT_SUPPORT_CPP17_SEMANTICS) \
72 && defined(BSLS_COMPILERFEATURES_SUPPORT_DECLTYPE) \
73 && defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
74 && defined(BSLS_LIBRARYFEATURES_HAS_CPP11_BASELINE_LIBRARY)
75#define BSLSTL_FUNCTION_INVOKERUTIL_SUPPORT_IS_FUNC_INVOCABLE
76#endif
77
78
79namespace bslstl {
80
81#ifdef BSLSTL_FUNCTION_INVOKERUTIL_SUPPORT_IS_FUNC_INVOCABLE
82
83/// forward declaration
84template <class PROTOTYPE, class FUNC>
85struct Function_InvokerUtil_IsFuncInvocable;
86
87#endif
88
89 // ===========================
90 // struct Function_InvokerUtil
91 // ===========================
92
93/// This struct is a namespace containing a single function template,
94/// `invokerForFunc`, that returns a pointer to a function that is used to
95/// invoke a callable object of a particular type.
96struct Function_InvokerUtil {
97
98 // TYPES
99 enum {
100 // Enumeration of the different types of callable objects.
101
102 e_Null,
103 e_FunctionPtr,
104 e_MemFunctionPtr,
105 e_MemDataPtr,
106 e_InplaceFunctor,
107 e_OutofplaceFunctor
108 };
109
110 /// Generic function pointer. This type is as close as we can get to
111 /// `void *` for function pointers.
112 typedef Function_Rep::GenericInvoker GenericInvoker;
113
114#ifdef BSLSTL_FUNCTION_INVOKERUTIL_SUPPORT_IS_FUNC_INVOCABLE
115 /// This `struct` template implements a Boolean metafunction that
116 /// publicly inherits from `bsl::true_type` if an object of the
117 /// specified `FUNC` type is invocable under the specified `PROTOTYPE`,
118 /// and publicly inherits from `bsl::false_type` otherwise. An object
119 /// of `FUNC` type is invocable under the `PROTOTYPE` if it is
120 /// Lvalue-Callable with the arguments of the `PROTOTYPE` (as forwarded
121 /// by the facilities of 'bslmf_forwardingtype), and returns an object
122 /// of type explicitly convertible to the return type of the
123 /// `PROTOTYPE`. If the return type of the `PROTOTYPE` is `void`, then
124 /// any type is considered explicitly convertible to the return type of
125 /// the `PROTOTYPE`. This `struct` template requires 'PROTOTYPE" to be
126 /// an unqualified function type.
127 ///
128 /// Note that `IsFuncInvocable` is qualitatively different than
129 /// `std::is_invocable_r`, in that it makes concessions for supporting
130 /// legacy behavior of `bsl::function`.
131 /// `std::is_invocable_r<RET, FUNC, ARGS...>` requires that the return
132 /// type of the invocation of `FUNC` with `ARGS...` be implicitly
133 /// convertible to `RET`, as opposed to explicitly convertible.
134 /// Further, the use of `bslmf::ForwardingType` to forward arguments in
135 /// the invoker of a `bsl::function` creates qualitatively different
136 /// behavior than the argument forwarding mechanism used by the standard
137 /// `INVOKE` pseudo-expression.
138 template <class PROTOTYPE, class FUNC>
139 struct IsFuncInvocable
140 : Function_InvokerUtil_IsFuncInvocable<PROTOTYPE, FUNC> {
141 };
142#endif
143
144 // CLASS METHODS
145
146 /// Return a null pointer. Note that template argument `PROTOTYPE` must
147 /// be supplied excplicitly, as there is no way to deduce it from the
148 /// function arguments.
149 template <class PROTOTYPE>
150 static GenericInvoker *invokerForFunc(const bsl::nullptr_t&);
151
152 /// Return a pointer to the invoker for a callable object of (template
153 /// paramter) type `FUNC`. If the specified `f` object is a null
154 /// pointer or null pointer-to-member, return a null pointer. Note that
155 /// template argument `PROTOTYPE` must be supplied excplicitly, as there
156 /// is no way to deduce it from the function arguments.
157 template <class PROTOTYPE, class FUNC>
158 static GenericInvoker *invokerForFunc(const FUNC& f);
159};
160
161 // =============================================
162 // template struct Function_InvokerUtilNullCheck
163 // =============================================
164
165/// Provides an `isNull` static method that that returns whether or not its
166/// argument is "null", i.e., it cannot be invoked. For must `FUNC` types
167/// `isNull` always returns `false` as every instance of `FUNC` is
168/// invocable. However, specializations of this class, especially for
169/// pointer types, have `isNull` functions that sometimes return `true`.
170/// This class is a customization point: types outside of this component can
171/// (but rarely should) specialize this template. In particular,
172/// @ref bslstl_function contains a specialization for `bsl::function`.
173template <class FUNC>
174struct Function_InvokerUtilNullCheck {
175
176 // CLASS METHODS
177
178 /// Return `false`.
179 static bool isNull(const FUNC&);
180};
181
182/// Specialization of dispatcher for pointer objects.
183template <class FUNC>
184struct Function_InvokerUtilNullCheck<FUNC *> {
185
186 // CLASS METHODS
187
188 /// Return `true` if the specified `f` pointer is null; otherwise
189 /// `false`.
190 static bool isNull(FUNC *f);
191};
192
193/// Specialization of dispatcher for pointer-to-member objects.
194template <class CLASS, class MEMTYPE>
195struct Function_InvokerUtilNullCheck<MEMTYPE CLASS::*> {
196
197 public:
198 // CLASS METHODS
199
200 /// Return `true` if the specified `f` pointer to member is null;
201 /// otherwise `false`.
202 static bool isNull(MEMTYPE CLASS::* f);
203};
204
205#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
206// {{{ BEGIN GENERATED CODE
207// Command line: sim_cpp11_features.pl bslstl_function_invokerutil.h
208#ifndef BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT
209#define BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT 13
210#endif
211#ifndef BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A
212#define BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT
213#endif
214
215
216#ifdef BSLSTL_FUNCTION_INVOKERUTIL_SUPPORT_IS_FUNC_INVOCABLE
217
218template <class VOID_TYPE,
219 class RET,
220 class FUNC
221#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
222 , class ARGS_0 = BSLS_COMPILERFEATURES_NILT
223#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
224
225#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
226 , class ARGS_1 = BSLS_COMPILERFEATURES_NILT
227#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
228
229#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
230 , class ARGS_2 = BSLS_COMPILERFEATURES_NILT
231#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
232
233#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
234 , class ARGS_3 = BSLS_COMPILERFEATURES_NILT
235#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
236
237#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
238 , class ARGS_4 = BSLS_COMPILERFEATURES_NILT
239#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
240
241#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
242 , class ARGS_5 = BSLS_COMPILERFEATURES_NILT
243#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
244
245#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
246 , class ARGS_6 = BSLS_COMPILERFEATURES_NILT
247#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
248
249#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
250 , class ARGS_7 = BSLS_COMPILERFEATURES_NILT
251#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
252
253#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
254 , class ARGS_8 = BSLS_COMPILERFEATURES_NILT
255#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
256
257#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
258 , class ARGS_9 = BSLS_COMPILERFEATURES_NILT
259#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
260
261#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
262 , class ARGS_10 = BSLS_COMPILERFEATURES_NILT
263#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
264
265#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
266 , class ARGS_11 = BSLS_COMPILERFEATURES_NILT
267#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
268
269#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
270 , class ARGS_12 = BSLS_COMPILERFEATURES_NILT
271#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
272 , class = BSLS_COMPILERFEATURES_NILT>
273struct Function_InvokerUtil_IsFuncInvocableImp;
274
275
276#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
277template <class RET, class FUNC>
278struct Function_InvokerUtil_IsFuncInvocable<RET(), FUNC>
279: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC> {
280};
281#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
282
283#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
284template <class RET, class FUNC, class ARGS_01>
285struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01), FUNC>
286: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01> {
287};
288#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
289
290#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
291template <class RET, class FUNC, class ARGS_01,
292 class ARGS_02>
293struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
294 ARGS_02), FUNC>
295: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
296 ARGS_02> {
297};
298#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
299
300#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
301template <class RET, class FUNC, class ARGS_01,
302 class ARGS_02,
303 class ARGS_03>
304struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
305 ARGS_02,
306 ARGS_03), FUNC>
307: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
308 ARGS_02,
309 ARGS_03> {
310};
311#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
312
313#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
314template <class RET, class FUNC, class ARGS_01,
315 class ARGS_02,
316 class ARGS_03,
317 class ARGS_04>
318struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
319 ARGS_02,
320 ARGS_03,
321 ARGS_04), FUNC>
322: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
323 ARGS_02,
324 ARGS_03,
325 ARGS_04> {
326};
327#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
328
329#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
330template <class RET, class FUNC, class ARGS_01,
331 class ARGS_02,
332 class ARGS_03,
333 class ARGS_04,
334 class ARGS_05>
335struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
336 ARGS_02,
337 ARGS_03,
338 ARGS_04,
339 ARGS_05), FUNC>
340: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
341 ARGS_02,
342 ARGS_03,
343 ARGS_04,
344 ARGS_05> {
345};
346#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
347
348#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
349template <class RET, class FUNC, class ARGS_01,
350 class ARGS_02,
351 class ARGS_03,
352 class ARGS_04,
353 class ARGS_05,
354 class ARGS_06>
355struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
356 ARGS_02,
357 ARGS_03,
358 ARGS_04,
359 ARGS_05,
360 ARGS_06), FUNC>
361: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
362 ARGS_02,
363 ARGS_03,
364 ARGS_04,
365 ARGS_05,
366 ARGS_06> {
367};
368#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
369
370#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
371template <class RET, class FUNC, class ARGS_01,
372 class ARGS_02,
373 class ARGS_03,
374 class ARGS_04,
375 class ARGS_05,
376 class ARGS_06,
377 class ARGS_07>
378struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
379 ARGS_02,
380 ARGS_03,
381 ARGS_04,
382 ARGS_05,
383 ARGS_06,
384 ARGS_07), FUNC>
385: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
386 ARGS_02,
387 ARGS_03,
388 ARGS_04,
389 ARGS_05,
390 ARGS_06,
391 ARGS_07> {
392};
393#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
394
395#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
396template <class RET, class FUNC, class ARGS_01,
397 class ARGS_02,
398 class ARGS_03,
399 class ARGS_04,
400 class ARGS_05,
401 class ARGS_06,
402 class ARGS_07,
403 class ARGS_08>
404struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
405 ARGS_02,
406 ARGS_03,
407 ARGS_04,
408 ARGS_05,
409 ARGS_06,
410 ARGS_07,
411 ARGS_08), FUNC>
412: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
413 ARGS_02,
414 ARGS_03,
415 ARGS_04,
416 ARGS_05,
417 ARGS_06,
418 ARGS_07,
419 ARGS_08> {
420};
421#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
422
423#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
424template <class RET, class FUNC, class ARGS_01,
425 class ARGS_02,
426 class ARGS_03,
427 class ARGS_04,
428 class ARGS_05,
429 class ARGS_06,
430 class ARGS_07,
431 class ARGS_08,
432 class ARGS_09>
433struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
434 ARGS_02,
435 ARGS_03,
436 ARGS_04,
437 ARGS_05,
438 ARGS_06,
439 ARGS_07,
440 ARGS_08,
441 ARGS_09), FUNC>
442: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
443 ARGS_02,
444 ARGS_03,
445 ARGS_04,
446 ARGS_05,
447 ARGS_06,
448 ARGS_07,
449 ARGS_08,
450 ARGS_09> {
451};
452#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
453
454#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
455template <class RET, class FUNC, class ARGS_01,
456 class ARGS_02,
457 class ARGS_03,
458 class ARGS_04,
459 class ARGS_05,
460 class ARGS_06,
461 class ARGS_07,
462 class ARGS_08,
463 class ARGS_09,
464 class ARGS_10>
465struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
466 ARGS_02,
467 ARGS_03,
468 ARGS_04,
469 ARGS_05,
470 ARGS_06,
471 ARGS_07,
472 ARGS_08,
473 ARGS_09,
474 ARGS_10), FUNC>
475: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
476 ARGS_02,
477 ARGS_03,
478 ARGS_04,
479 ARGS_05,
480 ARGS_06,
481 ARGS_07,
482 ARGS_08,
483 ARGS_09,
484 ARGS_10> {
485};
486#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
487
488#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
489template <class RET, class FUNC, class ARGS_01,
490 class ARGS_02,
491 class ARGS_03,
492 class ARGS_04,
493 class ARGS_05,
494 class ARGS_06,
495 class ARGS_07,
496 class ARGS_08,
497 class ARGS_09,
498 class ARGS_10,
499 class ARGS_11>
500struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
501 ARGS_02,
502 ARGS_03,
503 ARGS_04,
504 ARGS_05,
505 ARGS_06,
506 ARGS_07,
507 ARGS_08,
508 ARGS_09,
509 ARGS_10,
510 ARGS_11), FUNC>
511: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
512 ARGS_02,
513 ARGS_03,
514 ARGS_04,
515 ARGS_05,
516 ARGS_06,
517 ARGS_07,
518 ARGS_08,
519 ARGS_09,
520 ARGS_10,
521 ARGS_11> {
522};
523#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
524
525#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
526template <class RET, class FUNC, class ARGS_01,
527 class ARGS_02,
528 class ARGS_03,
529 class ARGS_04,
530 class ARGS_05,
531 class ARGS_06,
532 class ARGS_07,
533 class ARGS_08,
534 class ARGS_09,
535 class ARGS_10,
536 class ARGS_11,
537 class ARGS_12>
538struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
539 ARGS_02,
540 ARGS_03,
541 ARGS_04,
542 ARGS_05,
543 ARGS_06,
544 ARGS_07,
545 ARGS_08,
546 ARGS_09,
547 ARGS_10,
548 ARGS_11,
549 ARGS_12), FUNC>
550: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
551 ARGS_02,
552 ARGS_03,
553 ARGS_04,
554 ARGS_05,
555 ARGS_06,
556 ARGS_07,
557 ARGS_08,
558 ARGS_09,
559 ARGS_10,
560 ARGS_11,
561 ARGS_12> {
562};
563#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
564
565#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
566template <class RET, class FUNC, class ARGS_01,
567 class ARGS_02,
568 class ARGS_03,
569 class ARGS_04,
570 class ARGS_05,
571 class ARGS_06,
572 class ARGS_07,
573 class ARGS_08,
574 class ARGS_09,
575 class ARGS_10,
576 class ARGS_11,
577 class ARGS_12,
578 class ARGS_13>
579struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS_01,
580 ARGS_02,
581 ARGS_03,
582 ARGS_04,
583 ARGS_05,
584 ARGS_06,
585 ARGS_07,
586 ARGS_08,
587 ARGS_09,
588 ARGS_10,
589 ARGS_11,
590 ARGS_12,
591 ARGS_13), FUNC>
592: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS_01,
593 ARGS_02,
594 ARGS_03,
595 ARGS_04,
596 ARGS_05,
597 ARGS_06,
598 ARGS_07,
599 ARGS_08,
600 ARGS_09,
601 ARGS_10,
602 ARGS_11,
603 ARGS_12,
604 ARGS_13> {
605};
606#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
607
608
609
610template <class ARG>
611struct Function_InvokerUtil_ForwardType;
612
613template <class FROM, class TO>
614struct Function_InvokerUtil_IsExplicitlyConvertible;
615
616template <class FUNC
617#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
618 , class ARGS_0 = BSLS_COMPILERFEATURES_NILT
619#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
620
621#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
622 , class ARGS_1 = BSLS_COMPILERFEATURES_NILT
623#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
624
625#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
626 , class ARGS_2 = BSLS_COMPILERFEATURES_NILT
627#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
628
629#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
630 , class ARGS_3 = BSLS_COMPILERFEATURES_NILT
631#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
632
633#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
634 , class ARGS_4 = BSLS_COMPILERFEATURES_NILT
635#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
636
637#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
638 , class ARGS_5 = BSLS_COMPILERFEATURES_NILT
639#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
640
641#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
642 , class ARGS_6 = BSLS_COMPILERFEATURES_NILT
643#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
644
645#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
646 , class ARGS_7 = BSLS_COMPILERFEATURES_NILT
647#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
648
649#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
650 , class ARGS_8 = BSLS_COMPILERFEATURES_NILT
651#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
652
653#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
654 , class ARGS_9 = BSLS_COMPILERFEATURES_NILT
655#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
656
657#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
658 , class ARGS_10 = BSLS_COMPILERFEATURES_NILT
659#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
660
661#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
662 , class ARGS_11 = BSLS_COMPILERFEATURES_NILT
663#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
664
665#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
666 , class ARGS_12 = BSLS_COMPILERFEATURES_NILT
667#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
668 , class = BSLS_COMPILERFEATURES_NILT>
669struct Function_InvokerUtil_ResultType;
670
671
672#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
673template <class VOID_TYPE, class RET, class FUNC>
674struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC
675 > : bsl::false_type {
676};
677#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
678
679#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
680template <class VOID_TYPE, class RET, class FUNC, class ARGS_01>
681struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01
682 > : bsl::false_type {
683};
684#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
685
686#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
687template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
688 class ARGS_02>
689struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
690 ARGS_02
691 > : bsl::false_type {
692};
693#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
694
695#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
696template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
697 class ARGS_02,
698 class ARGS_03>
699struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
700 ARGS_02,
701 ARGS_03
702 > : bsl::false_type {
703};
704#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
705
706#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
707template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
708 class ARGS_02,
709 class ARGS_03,
710 class ARGS_04>
711struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
712 ARGS_02,
713 ARGS_03,
714 ARGS_04
715 > : bsl::false_type {
716};
717#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
718
719#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
720template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
721 class ARGS_02,
722 class ARGS_03,
723 class ARGS_04,
724 class ARGS_05>
725struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
726 ARGS_02,
727 ARGS_03,
728 ARGS_04,
729 ARGS_05
730 > : bsl::false_type {
731};
732#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
733
734#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
735template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
736 class ARGS_02,
737 class ARGS_03,
738 class ARGS_04,
739 class ARGS_05,
740 class ARGS_06>
741struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
742 ARGS_02,
743 ARGS_03,
744 ARGS_04,
745 ARGS_05,
746 ARGS_06
747 > : bsl::false_type {
748};
749#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
750
751#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
752template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
753 class ARGS_02,
754 class ARGS_03,
755 class ARGS_04,
756 class ARGS_05,
757 class ARGS_06,
758 class ARGS_07>
759struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
760 ARGS_02,
761 ARGS_03,
762 ARGS_04,
763 ARGS_05,
764 ARGS_06,
765 ARGS_07
766 > : bsl::false_type {
767};
768#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
769
770#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
771template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
772 class ARGS_02,
773 class ARGS_03,
774 class ARGS_04,
775 class ARGS_05,
776 class ARGS_06,
777 class ARGS_07,
778 class ARGS_08>
779struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
780 ARGS_02,
781 ARGS_03,
782 ARGS_04,
783 ARGS_05,
784 ARGS_06,
785 ARGS_07,
786 ARGS_08
787 > : bsl::false_type {
788};
789#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
790
791#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
792template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
793 class ARGS_02,
794 class ARGS_03,
795 class ARGS_04,
796 class ARGS_05,
797 class ARGS_06,
798 class ARGS_07,
799 class ARGS_08,
800 class ARGS_09>
801struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
802 ARGS_02,
803 ARGS_03,
804 ARGS_04,
805 ARGS_05,
806 ARGS_06,
807 ARGS_07,
808 ARGS_08,
809 ARGS_09
810 > : bsl::false_type {
811};
812#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
813
814#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
815template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
816 class ARGS_02,
817 class ARGS_03,
818 class ARGS_04,
819 class ARGS_05,
820 class ARGS_06,
821 class ARGS_07,
822 class ARGS_08,
823 class ARGS_09,
824 class ARGS_10>
825struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
826 ARGS_02,
827 ARGS_03,
828 ARGS_04,
829 ARGS_05,
830 ARGS_06,
831 ARGS_07,
832 ARGS_08,
833 ARGS_09,
834 ARGS_10
835 > : bsl::false_type {
836};
837#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
838
839#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
840template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
841 class ARGS_02,
842 class ARGS_03,
843 class ARGS_04,
844 class ARGS_05,
845 class ARGS_06,
846 class ARGS_07,
847 class ARGS_08,
848 class ARGS_09,
849 class ARGS_10,
850 class ARGS_11>
851struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
852 ARGS_02,
853 ARGS_03,
854 ARGS_04,
855 ARGS_05,
856 ARGS_06,
857 ARGS_07,
858 ARGS_08,
859 ARGS_09,
860 ARGS_10,
861 ARGS_11
862 > : bsl::false_type {
863};
864#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
865
866#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
867template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
868 class ARGS_02,
869 class ARGS_03,
870 class ARGS_04,
871 class ARGS_05,
872 class ARGS_06,
873 class ARGS_07,
874 class ARGS_08,
875 class ARGS_09,
876 class ARGS_10,
877 class ARGS_11,
878 class ARGS_12>
879struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
880 ARGS_02,
881 ARGS_03,
882 ARGS_04,
883 ARGS_05,
884 ARGS_06,
885 ARGS_07,
886 ARGS_08,
887 ARGS_09,
888 ARGS_10,
889 ARGS_11,
890 ARGS_12
891 > : bsl::false_type {
892};
893#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
894
895#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
896template <class VOID_TYPE, class RET, class FUNC, class ARGS_01,
897 class ARGS_02,
898 class ARGS_03,
899 class ARGS_04,
900 class ARGS_05,
901 class ARGS_06,
902 class ARGS_07,
903 class ARGS_08,
904 class ARGS_09,
905 class ARGS_10,
906 class ARGS_11,
907 class ARGS_12,
908 class ARGS_13>
909struct Function_InvokerUtil_IsFuncInvocableImp<VOID_TYPE, RET, FUNC, ARGS_01,
910 ARGS_02,
911 ARGS_03,
912 ARGS_04,
913 ARGS_05,
914 ARGS_06,
915 ARGS_07,
916 ARGS_08,
917 ARGS_09,
918 ARGS_10,
919 ARGS_11,
920 ARGS_12,
921 ARGS_13
922 > : bsl::false_type {
923};
924#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
925
926
927#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
928template <class RET, class FUNC>
929struct Function_InvokerUtil_IsFuncInvocableImp<
930 typename bslmf::VoidType<
931 typename Function_InvokerUtil_ResultType<FUNC>::type>::type,
932 RET,
933 FUNC>
934: bsl::conditional<
935 bsl::is_void<RET>::value,
936 bsl::true_type,
937 Function_InvokerUtil_IsExplicitlyConvertible<
938 typename Function_InvokerUtil_ResultType<FUNC>::type,
939 RET> >::type {
940};
941#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
942
943#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
944template <class RET, class FUNC, class ARGS_01>
945struct Function_InvokerUtil_IsFuncInvocableImp<
946 typename bslmf::VoidType<
947 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01>::type>::type,
948 RET,
949 FUNC,
950 ARGS_01>
951: bsl::conditional<
952 bsl::is_void<RET>::value,
953 bsl::true_type,
954 Function_InvokerUtil_IsExplicitlyConvertible<
955 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01>::type,
956 RET> >::type {
957};
958#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
959
960#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
961template <class RET, class FUNC, class ARGS_01,
962 class ARGS_02>
963struct Function_InvokerUtil_IsFuncInvocableImp<
964 typename bslmf::VoidType<
965 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
966 ARGS_02>::type>::type,
967 RET,
968 FUNC,
969 ARGS_01,
970 ARGS_02>
971: bsl::conditional<
972 bsl::is_void<RET>::value,
973 bsl::true_type,
974 Function_InvokerUtil_IsExplicitlyConvertible<
975 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
976 ARGS_02>::type,
977 RET> >::type {
978};
979#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
980
981#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
982template <class RET, class FUNC, class ARGS_01,
983 class ARGS_02,
984 class ARGS_03>
985struct Function_InvokerUtil_IsFuncInvocableImp<
986 typename bslmf::VoidType<
987 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
988 ARGS_02,
989 ARGS_03>::type>::type,
990 RET,
991 FUNC,
992 ARGS_01,
993 ARGS_02,
994 ARGS_03>
995: bsl::conditional<
996 bsl::is_void<RET>::value,
997 bsl::true_type,
998 Function_InvokerUtil_IsExplicitlyConvertible<
999 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1000 ARGS_02,
1001 ARGS_03>::type,
1002 RET> >::type {
1003};
1004#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
1005
1006#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
1007template <class RET, class FUNC, class ARGS_01,
1008 class ARGS_02,
1009 class ARGS_03,
1010 class ARGS_04>
1011struct Function_InvokerUtil_IsFuncInvocableImp<
1012 typename bslmf::VoidType<
1013 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1014 ARGS_02,
1015 ARGS_03,
1016 ARGS_04>::type>::type,
1017 RET,
1018 FUNC,
1019 ARGS_01,
1020 ARGS_02,
1021 ARGS_03,
1022 ARGS_04>
1023: bsl::conditional<
1024 bsl::is_void<RET>::value,
1025 bsl::true_type,
1026 Function_InvokerUtil_IsExplicitlyConvertible<
1027 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1028 ARGS_02,
1029 ARGS_03,
1030 ARGS_04>::type,
1031 RET> >::type {
1032};
1033#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
1034
1035#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
1036template <class RET, class FUNC, class ARGS_01,
1037 class ARGS_02,
1038 class ARGS_03,
1039 class ARGS_04,
1040 class ARGS_05>
1041struct Function_InvokerUtil_IsFuncInvocableImp<
1042 typename bslmf::VoidType<
1043 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1044 ARGS_02,
1045 ARGS_03,
1046 ARGS_04,
1047 ARGS_05>::type>::type,
1048 RET,
1049 FUNC,
1050 ARGS_01,
1051 ARGS_02,
1052 ARGS_03,
1053 ARGS_04,
1054 ARGS_05>
1055: bsl::conditional<
1056 bsl::is_void<RET>::value,
1057 bsl::true_type,
1058 Function_InvokerUtil_IsExplicitlyConvertible<
1059 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1060 ARGS_02,
1061 ARGS_03,
1062 ARGS_04,
1063 ARGS_05>::type,
1064 RET> >::type {
1065};
1066#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
1067
1068#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
1069template <class RET, class FUNC, class ARGS_01,
1070 class ARGS_02,
1071 class ARGS_03,
1072 class ARGS_04,
1073 class ARGS_05,
1074 class ARGS_06>
1075struct Function_InvokerUtil_IsFuncInvocableImp<
1076 typename bslmf::VoidType<
1077 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1078 ARGS_02,
1079 ARGS_03,
1080 ARGS_04,
1081 ARGS_05,
1082 ARGS_06>::type>::type,
1083 RET,
1084 FUNC,
1085 ARGS_01,
1086 ARGS_02,
1087 ARGS_03,
1088 ARGS_04,
1089 ARGS_05,
1090 ARGS_06>
1091: bsl::conditional<
1092 bsl::is_void<RET>::value,
1093 bsl::true_type,
1094 Function_InvokerUtil_IsExplicitlyConvertible<
1095 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1096 ARGS_02,
1097 ARGS_03,
1098 ARGS_04,
1099 ARGS_05,
1100 ARGS_06>::type,
1101 RET> >::type {
1102};
1103#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
1104
1105#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
1106template <class RET, class FUNC, class ARGS_01,
1107 class ARGS_02,
1108 class ARGS_03,
1109 class ARGS_04,
1110 class ARGS_05,
1111 class ARGS_06,
1112 class ARGS_07>
1113struct Function_InvokerUtil_IsFuncInvocableImp<
1114 typename bslmf::VoidType<
1115 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1116 ARGS_02,
1117 ARGS_03,
1118 ARGS_04,
1119 ARGS_05,
1120 ARGS_06,
1121 ARGS_07>::type>::type,
1122 RET,
1123 FUNC,
1124 ARGS_01,
1125 ARGS_02,
1126 ARGS_03,
1127 ARGS_04,
1128 ARGS_05,
1129 ARGS_06,
1130 ARGS_07>
1131: bsl::conditional<
1132 bsl::is_void<RET>::value,
1133 bsl::true_type,
1134 Function_InvokerUtil_IsExplicitlyConvertible<
1135 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1136 ARGS_02,
1137 ARGS_03,
1138 ARGS_04,
1139 ARGS_05,
1140 ARGS_06,
1141 ARGS_07>::type,
1142 RET> >::type {
1143};
1144#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
1145
1146#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
1147template <class RET, class FUNC, class ARGS_01,
1148 class ARGS_02,
1149 class ARGS_03,
1150 class ARGS_04,
1151 class ARGS_05,
1152 class ARGS_06,
1153 class ARGS_07,
1154 class ARGS_08>
1155struct Function_InvokerUtil_IsFuncInvocableImp<
1156 typename bslmf::VoidType<
1157 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1158 ARGS_02,
1159 ARGS_03,
1160 ARGS_04,
1161 ARGS_05,
1162 ARGS_06,
1163 ARGS_07,
1164 ARGS_08>::type>::type,
1165 RET,
1166 FUNC,
1167 ARGS_01,
1168 ARGS_02,
1169 ARGS_03,
1170 ARGS_04,
1171 ARGS_05,
1172 ARGS_06,
1173 ARGS_07,
1174 ARGS_08>
1175: bsl::conditional<
1176 bsl::is_void<RET>::value,
1177 bsl::true_type,
1178 Function_InvokerUtil_IsExplicitlyConvertible<
1179 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1180 ARGS_02,
1181 ARGS_03,
1182 ARGS_04,
1183 ARGS_05,
1184 ARGS_06,
1185 ARGS_07,
1186 ARGS_08>::type,
1187 RET> >::type {
1188};
1189#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
1190
1191#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
1192template <class RET, class FUNC, class ARGS_01,
1193 class ARGS_02,
1194 class ARGS_03,
1195 class ARGS_04,
1196 class ARGS_05,
1197 class ARGS_06,
1198 class ARGS_07,
1199 class ARGS_08,
1200 class ARGS_09>
1201struct Function_InvokerUtil_IsFuncInvocableImp<
1202 typename bslmf::VoidType<
1203 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1204 ARGS_02,
1205 ARGS_03,
1206 ARGS_04,
1207 ARGS_05,
1208 ARGS_06,
1209 ARGS_07,
1210 ARGS_08,
1211 ARGS_09>::type>::type,
1212 RET,
1213 FUNC,
1214 ARGS_01,
1215 ARGS_02,
1216 ARGS_03,
1217 ARGS_04,
1218 ARGS_05,
1219 ARGS_06,
1220 ARGS_07,
1221 ARGS_08,
1222 ARGS_09>
1223: bsl::conditional<
1224 bsl::is_void<RET>::value,
1225 bsl::true_type,
1226 Function_InvokerUtil_IsExplicitlyConvertible<
1227 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1228 ARGS_02,
1229 ARGS_03,
1230 ARGS_04,
1231 ARGS_05,
1232 ARGS_06,
1233 ARGS_07,
1234 ARGS_08,
1235 ARGS_09>::type,
1236 RET> >::type {
1237};
1238#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
1239
1240#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
1241template <class RET, class FUNC, class ARGS_01,
1242 class ARGS_02,
1243 class ARGS_03,
1244 class ARGS_04,
1245 class ARGS_05,
1246 class ARGS_06,
1247 class ARGS_07,
1248 class ARGS_08,
1249 class ARGS_09,
1250 class ARGS_10>
1251struct Function_InvokerUtil_IsFuncInvocableImp<
1252 typename bslmf::VoidType<
1253 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1254 ARGS_02,
1255 ARGS_03,
1256 ARGS_04,
1257 ARGS_05,
1258 ARGS_06,
1259 ARGS_07,
1260 ARGS_08,
1261 ARGS_09,
1262 ARGS_10>::type>::type,
1263 RET,
1264 FUNC,
1265 ARGS_01,
1266 ARGS_02,
1267 ARGS_03,
1268 ARGS_04,
1269 ARGS_05,
1270 ARGS_06,
1271 ARGS_07,
1272 ARGS_08,
1273 ARGS_09,
1274 ARGS_10>
1275: bsl::conditional<
1276 bsl::is_void<RET>::value,
1277 bsl::true_type,
1278 Function_InvokerUtil_IsExplicitlyConvertible<
1279 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1280 ARGS_02,
1281 ARGS_03,
1282 ARGS_04,
1283 ARGS_05,
1284 ARGS_06,
1285 ARGS_07,
1286 ARGS_08,
1287 ARGS_09,
1288 ARGS_10>::type,
1289 RET> >::type {
1290};
1291#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
1292
1293#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
1294template <class RET, class FUNC, class ARGS_01,
1295 class ARGS_02,
1296 class ARGS_03,
1297 class ARGS_04,
1298 class ARGS_05,
1299 class ARGS_06,
1300 class ARGS_07,
1301 class ARGS_08,
1302 class ARGS_09,
1303 class ARGS_10,
1304 class ARGS_11>
1305struct Function_InvokerUtil_IsFuncInvocableImp<
1306 typename bslmf::VoidType<
1307 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1308 ARGS_02,
1309 ARGS_03,
1310 ARGS_04,
1311 ARGS_05,
1312 ARGS_06,
1313 ARGS_07,
1314 ARGS_08,
1315 ARGS_09,
1316 ARGS_10,
1317 ARGS_11>::type>::type,
1318 RET,
1319 FUNC,
1320 ARGS_01,
1321 ARGS_02,
1322 ARGS_03,
1323 ARGS_04,
1324 ARGS_05,
1325 ARGS_06,
1326 ARGS_07,
1327 ARGS_08,
1328 ARGS_09,
1329 ARGS_10,
1330 ARGS_11>
1331: bsl::conditional<
1332 bsl::is_void<RET>::value,
1333 bsl::true_type,
1334 Function_InvokerUtil_IsExplicitlyConvertible<
1335 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1336 ARGS_02,
1337 ARGS_03,
1338 ARGS_04,
1339 ARGS_05,
1340 ARGS_06,
1341 ARGS_07,
1342 ARGS_08,
1343 ARGS_09,
1344 ARGS_10,
1345 ARGS_11>::type,
1346 RET> >::type {
1347};
1348#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
1349
1350#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
1351template <class RET, class FUNC, class ARGS_01,
1352 class ARGS_02,
1353 class ARGS_03,
1354 class ARGS_04,
1355 class ARGS_05,
1356 class ARGS_06,
1357 class ARGS_07,
1358 class ARGS_08,
1359 class ARGS_09,
1360 class ARGS_10,
1361 class ARGS_11,
1362 class ARGS_12>
1363struct Function_InvokerUtil_IsFuncInvocableImp<
1364 typename bslmf::VoidType<
1365 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1366 ARGS_02,
1367 ARGS_03,
1368 ARGS_04,
1369 ARGS_05,
1370 ARGS_06,
1371 ARGS_07,
1372 ARGS_08,
1373 ARGS_09,
1374 ARGS_10,
1375 ARGS_11,
1376 ARGS_12>::type>::type,
1377 RET,
1378 FUNC,
1379 ARGS_01,
1380 ARGS_02,
1381 ARGS_03,
1382 ARGS_04,
1383 ARGS_05,
1384 ARGS_06,
1385 ARGS_07,
1386 ARGS_08,
1387 ARGS_09,
1388 ARGS_10,
1389 ARGS_11,
1390 ARGS_12>
1391: bsl::conditional<
1392 bsl::is_void<RET>::value,
1393 bsl::true_type,
1394 Function_InvokerUtil_IsExplicitlyConvertible<
1395 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1396 ARGS_02,
1397 ARGS_03,
1398 ARGS_04,
1399 ARGS_05,
1400 ARGS_06,
1401 ARGS_07,
1402 ARGS_08,
1403 ARGS_09,
1404 ARGS_10,
1405 ARGS_11,
1406 ARGS_12>::type,
1407 RET> >::type {
1408};
1409#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
1410
1411#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
1412template <class RET, class FUNC, class ARGS_01,
1413 class ARGS_02,
1414 class ARGS_03,
1415 class ARGS_04,
1416 class ARGS_05,
1417 class ARGS_06,
1418 class ARGS_07,
1419 class ARGS_08,
1420 class ARGS_09,
1421 class ARGS_10,
1422 class ARGS_11,
1423 class ARGS_12,
1424 class ARGS_13>
1425struct Function_InvokerUtil_IsFuncInvocableImp<
1426 typename bslmf::VoidType<
1427 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1428 ARGS_02,
1429 ARGS_03,
1430 ARGS_04,
1431 ARGS_05,
1432 ARGS_06,
1433 ARGS_07,
1434 ARGS_08,
1435 ARGS_09,
1436 ARGS_10,
1437 ARGS_11,
1438 ARGS_12,
1439 ARGS_13>::type>::type,
1440 RET,
1441 FUNC,
1442 ARGS_01,
1443 ARGS_02,
1444 ARGS_03,
1445 ARGS_04,
1446 ARGS_05,
1447 ARGS_06,
1448 ARGS_07,
1449 ARGS_08,
1450 ARGS_09,
1451 ARGS_10,
1452 ARGS_11,
1453 ARGS_12,
1454 ARGS_13>
1455: bsl::conditional<
1456 bsl::is_void<RET>::value,
1457 bsl::true_type,
1458 Function_InvokerUtil_IsExplicitlyConvertible<
1459 typename Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1460 ARGS_02,
1461 ARGS_03,
1462 ARGS_04,
1463 ARGS_05,
1464 ARGS_06,
1465 ARGS_07,
1466 ARGS_08,
1467 ARGS_09,
1468 ARGS_10,
1469 ARGS_11,
1470 ARGS_12,
1471 ARGS_13>::type,
1472 RET> >::type {
1473};
1474#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
1475
1476
1477
1478template <class VOID_TYPE,
1479 class FUNC
1480#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
1481 , class ARGS_0 = BSLS_COMPILERFEATURES_NILT
1482#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
1483
1484#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
1485 , class ARGS_1 = BSLS_COMPILERFEATURES_NILT
1486#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
1487
1488#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
1489 , class ARGS_2 = BSLS_COMPILERFEATURES_NILT
1490#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
1491
1492#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
1493 , class ARGS_3 = BSLS_COMPILERFEATURES_NILT
1494#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
1495
1496#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
1497 , class ARGS_4 = BSLS_COMPILERFEATURES_NILT
1498#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
1499
1500#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
1501 , class ARGS_5 = BSLS_COMPILERFEATURES_NILT
1502#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
1503
1504#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
1505 , class ARGS_6 = BSLS_COMPILERFEATURES_NILT
1506#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
1507
1508#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
1509 , class ARGS_7 = BSLS_COMPILERFEATURES_NILT
1510#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
1511
1512#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
1513 , class ARGS_8 = BSLS_COMPILERFEATURES_NILT
1514#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
1515
1516#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
1517 , class ARGS_9 = BSLS_COMPILERFEATURES_NILT
1518#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
1519
1520#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
1521 , class ARGS_10 = BSLS_COMPILERFEATURES_NILT
1522#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
1523
1524#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
1525 , class ARGS_11 = BSLS_COMPILERFEATURES_NILT
1526#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
1527
1528#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
1529 , class ARGS_12 = BSLS_COMPILERFEATURES_NILT
1530#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
1531 , class = BSLS_COMPILERFEATURES_NILT>
1532struct Function_InvokerUtil_ResultTypeImp;
1533
1534
1535#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
1536template <class FUNC>
1537struct Function_InvokerUtil_ResultType<FUNC>
1538: Function_InvokerUtil_ResultTypeImp<void, FUNC> {
1539};
1540#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
1541
1542#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
1543template <class FUNC, class ARGS_01>
1544struct Function_InvokerUtil_ResultType<FUNC, ARGS_01>
1545: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01> {
1546};
1547#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
1548
1549#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
1550template <class FUNC, class ARGS_01,
1551 class ARGS_02>
1552struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1553 ARGS_02>
1554: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1555 ARGS_02> {
1556};
1557#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
1558
1559#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
1560template <class FUNC, class ARGS_01,
1561 class ARGS_02,
1562 class ARGS_03>
1563struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1564 ARGS_02,
1565 ARGS_03>
1566: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1567 ARGS_02,
1568 ARGS_03> {
1569};
1570#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
1571
1572#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
1573template <class FUNC, class ARGS_01,
1574 class ARGS_02,
1575 class ARGS_03,
1576 class ARGS_04>
1577struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1578 ARGS_02,
1579 ARGS_03,
1580 ARGS_04>
1581: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1582 ARGS_02,
1583 ARGS_03,
1584 ARGS_04> {
1585};
1586#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
1587
1588#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
1589template <class FUNC, class ARGS_01,
1590 class ARGS_02,
1591 class ARGS_03,
1592 class ARGS_04,
1593 class ARGS_05>
1594struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1595 ARGS_02,
1596 ARGS_03,
1597 ARGS_04,
1598 ARGS_05>
1599: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1600 ARGS_02,
1601 ARGS_03,
1602 ARGS_04,
1603 ARGS_05> {
1604};
1605#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
1606
1607#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
1608template <class FUNC, class ARGS_01,
1609 class ARGS_02,
1610 class ARGS_03,
1611 class ARGS_04,
1612 class ARGS_05,
1613 class ARGS_06>
1614struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1615 ARGS_02,
1616 ARGS_03,
1617 ARGS_04,
1618 ARGS_05,
1619 ARGS_06>
1620: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1621 ARGS_02,
1622 ARGS_03,
1623 ARGS_04,
1624 ARGS_05,
1625 ARGS_06> {
1626};
1627#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
1628
1629#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
1630template <class FUNC, class ARGS_01,
1631 class ARGS_02,
1632 class ARGS_03,
1633 class ARGS_04,
1634 class ARGS_05,
1635 class ARGS_06,
1636 class ARGS_07>
1637struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1638 ARGS_02,
1639 ARGS_03,
1640 ARGS_04,
1641 ARGS_05,
1642 ARGS_06,
1643 ARGS_07>
1644: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1645 ARGS_02,
1646 ARGS_03,
1647 ARGS_04,
1648 ARGS_05,
1649 ARGS_06,
1650 ARGS_07> {
1651};
1652#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
1653
1654#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
1655template <class FUNC, class ARGS_01,
1656 class ARGS_02,
1657 class ARGS_03,
1658 class ARGS_04,
1659 class ARGS_05,
1660 class ARGS_06,
1661 class ARGS_07,
1662 class ARGS_08>
1663struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1664 ARGS_02,
1665 ARGS_03,
1666 ARGS_04,
1667 ARGS_05,
1668 ARGS_06,
1669 ARGS_07,
1670 ARGS_08>
1671: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1672 ARGS_02,
1673 ARGS_03,
1674 ARGS_04,
1675 ARGS_05,
1676 ARGS_06,
1677 ARGS_07,
1678 ARGS_08> {
1679};
1680#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
1681
1682#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
1683template <class FUNC, class ARGS_01,
1684 class ARGS_02,
1685 class ARGS_03,
1686 class ARGS_04,
1687 class ARGS_05,
1688 class ARGS_06,
1689 class ARGS_07,
1690 class ARGS_08,
1691 class ARGS_09>
1692struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1693 ARGS_02,
1694 ARGS_03,
1695 ARGS_04,
1696 ARGS_05,
1697 ARGS_06,
1698 ARGS_07,
1699 ARGS_08,
1700 ARGS_09>
1701: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1702 ARGS_02,
1703 ARGS_03,
1704 ARGS_04,
1705 ARGS_05,
1706 ARGS_06,
1707 ARGS_07,
1708 ARGS_08,
1709 ARGS_09> {
1710};
1711#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
1712
1713#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
1714template <class FUNC, class ARGS_01,
1715 class ARGS_02,
1716 class ARGS_03,
1717 class ARGS_04,
1718 class ARGS_05,
1719 class ARGS_06,
1720 class ARGS_07,
1721 class ARGS_08,
1722 class ARGS_09,
1723 class ARGS_10>
1724struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1725 ARGS_02,
1726 ARGS_03,
1727 ARGS_04,
1728 ARGS_05,
1729 ARGS_06,
1730 ARGS_07,
1731 ARGS_08,
1732 ARGS_09,
1733 ARGS_10>
1734: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1735 ARGS_02,
1736 ARGS_03,
1737 ARGS_04,
1738 ARGS_05,
1739 ARGS_06,
1740 ARGS_07,
1741 ARGS_08,
1742 ARGS_09,
1743 ARGS_10> {
1744};
1745#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
1746
1747#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
1748template <class FUNC, class ARGS_01,
1749 class ARGS_02,
1750 class ARGS_03,
1751 class ARGS_04,
1752 class ARGS_05,
1753 class ARGS_06,
1754 class ARGS_07,
1755 class ARGS_08,
1756 class ARGS_09,
1757 class ARGS_10,
1758 class ARGS_11>
1759struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1760 ARGS_02,
1761 ARGS_03,
1762 ARGS_04,
1763 ARGS_05,
1764 ARGS_06,
1765 ARGS_07,
1766 ARGS_08,
1767 ARGS_09,
1768 ARGS_10,
1769 ARGS_11>
1770: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1771 ARGS_02,
1772 ARGS_03,
1773 ARGS_04,
1774 ARGS_05,
1775 ARGS_06,
1776 ARGS_07,
1777 ARGS_08,
1778 ARGS_09,
1779 ARGS_10,
1780 ARGS_11> {
1781};
1782#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
1783
1784#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
1785template <class FUNC, class ARGS_01,
1786 class ARGS_02,
1787 class ARGS_03,
1788 class ARGS_04,
1789 class ARGS_05,
1790 class ARGS_06,
1791 class ARGS_07,
1792 class ARGS_08,
1793 class ARGS_09,
1794 class ARGS_10,
1795 class ARGS_11,
1796 class ARGS_12>
1797struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1798 ARGS_02,
1799 ARGS_03,
1800 ARGS_04,
1801 ARGS_05,
1802 ARGS_06,
1803 ARGS_07,
1804 ARGS_08,
1805 ARGS_09,
1806 ARGS_10,
1807 ARGS_11,
1808 ARGS_12>
1809: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1810 ARGS_02,
1811 ARGS_03,
1812 ARGS_04,
1813 ARGS_05,
1814 ARGS_06,
1815 ARGS_07,
1816 ARGS_08,
1817 ARGS_09,
1818 ARGS_10,
1819 ARGS_11,
1820 ARGS_12> {
1821};
1822#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
1823
1824#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
1825template <class FUNC, class ARGS_01,
1826 class ARGS_02,
1827 class ARGS_03,
1828 class ARGS_04,
1829 class ARGS_05,
1830 class ARGS_06,
1831 class ARGS_07,
1832 class ARGS_08,
1833 class ARGS_09,
1834 class ARGS_10,
1835 class ARGS_11,
1836 class ARGS_12,
1837 class ARGS_13>
1838struct Function_InvokerUtil_ResultType<FUNC, ARGS_01,
1839 ARGS_02,
1840 ARGS_03,
1841 ARGS_04,
1842 ARGS_05,
1843 ARGS_06,
1844 ARGS_07,
1845 ARGS_08,
1846 ARGS_09,
1847 ARGS_10,
1848 ARGS_11,
1849 ARGS_12,
1850 ARGS_13>
1851: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS_01,
1852 ARGS_02,
1853 ARGS_03,
1854 ARGS_04,
1855 ARGS_05,
1856 ARGS_06,
1857 ARGS_07,
1858 ARGS_08,
1859 ARGS_09,
1860 ARGS_10,
1861 ARGS_11,
1862 ARGS_12,
1863 ARGS_13> {
1864};
1865#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
1866
1867
1868
1869#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
1870template <class VOID_TYPE, class FUNC>
1871struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC> {
1872};
1873#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
1874
1875#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
1876template <class VOID_TYPE, class FUNC, class ARGS_01>
1877struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01> {
1878};
1879#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
1880
1881#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
1882template <class VOID_TYPE, class FUNC, class ARGS_01,
1883 class ARGS_02>
1884struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
1885 ARGS_02> {
1886};
1887#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
1888
1889#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
1890template <class VOID_TYPE, class FUNC, class ARGS_01,
1891 class ARGS_02,
1892 class ARGS_03>
1893struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
1894 ARGS_02,
1895 ARGS_03> {
1896};
1897#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
1898
1899#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
1900template <class VOID_TYPE, class FUNC, class ARGS_01,
1901 class ARGS_02,
1902 class ARGS_03,
1903 class ARGS_04>
1904struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
1905 ARGS_02,
1906 ARGS_03,
1907 ARGS_04> {
1908};
1909#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
1910
1911#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
1912template <class VOID_TYPE, class FUNC, class ARGS_01,
1913 class ARGS_02,
1914 class ARGS_03,
1915 class ARGS_04,
1916 class ARGS_05>
1917struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
1918 ARGS_02,
1919 ARGS_03,
1920 ARGS_04,
1921 ARGS_05> {
1922};
1923#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
1924
1925#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
1926template <class VOID_TYPE, class FUNC, class ARGS_01,
1927 class ARGS_02,
1928 class ARGS_03,
1929 class ARGS_04,
1930 class ARGS_05,
1931 class ARGS_06>
1932struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
1933 ARGS_02,
1934 ARGS_03,
1935 ARGS_04,
1936 ARGS_05,
1937 ARGS_06> {
1938};
1939#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
1940
1941#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
1942template <class VOID_TYPE, class FUNC, class ARGS_01,
1943 class ARGS_02,
1944 class ARGS_03,
1945 class ARGS_04,
1946 class ARGS_05,
1947 class ARGS_06,
1948 class ARGS_07>
1949struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
1950 ARGS_02,
1951 ARGS_03,
1952 ARGS_04,
1953 ARGS_05,
1954 ARGS_06,
1955 ARGS_07> {
1956};
1957#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
1958
1959#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
1960template <class VOID_TYPE, class FUNC, class ARGS_01,
1961 class ARGS_02,
1962 class ARGS_03,
1963 class ARGS_04,
1964 class ARGS_05,
1965 class ARGS_06,
1966 class ARGS_07,
1967 class ARGS_08>
1968struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
1969 ARGS_02,
1970 ARGS_03,
1971 ARGS_04,
1972 ARGS_05,
1973 ARGS_06,
1974 ARGS_07,
1975 ARGS_08> {
1976};
1977#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
1978
1979#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
1980template <class VOID_TYPE, class FUNC, class ARGS_01,
1981 class ARGS_02,
1982 class ARGS_03,
1983 class ARGS_04,
1984 class ARGS_05,
1985 class ARGS_06,
1986 class ARGS_07,
1987 class ARGS_08,
1988 class ARGS_09>
1989struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
1990 ARGS_02,
1991 ARGS_03,
1992 ARGS_04,
1993 ARGS_05,
1994 ARGS_06,
1995 ARGS_07,
1996 ARGS_08,
1997 ARGS_09> {
1998};
1999#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
2000
2001#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
2002template <class VOID_TYPE, class FUNC, class ARGS_01,
2003 class ARGS_02,
2004 class ARGS_03,
2005 class ARGS_04,
2006 class ARGS_05,
2007 class ARGS_06,
2008 class ARGS_07,
2009 class ARGS_08,
2010 class ARGS_09,
2011 class ARGS_10>
2012struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
2013 ARGS_02,
2014 ARGS_03,
2015 ARGS_04,
2016 ARGS_05,
2017 ARGS_06,
2018 ARGS_07,
2019 ARGS_08,
2020 ARGS_09,
2021 ARGS_10> {
2022};
2023#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
2024
2025#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
2026template <class VOID_TYPE, class FUNC, class ARGS_01,
2027 class ARGS_02,
2028 class ARGS_03,
2029 class ARGS_04,
2030 class ARGS_05,
2031 class ARGS_06,
2032 class ARGS_07,
2033 class ARGS_08,
2034 class ARGS_09,
2035 class ARGS_10,
2036 class ARGS_11>
2037struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
2038 ARGS_02,
2039 ARGS_03,
2040 ARGS_04,
2041 ARGS_05,
2042 ARGS_06,
2043 ARGS_07,
2044 ARGS_08,
2045 ARGS_09,
2046 ARGS_10,
2047 ARGS_11> {
2048};
2049#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
2050
2051#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
2052template <class VOID_TYPE, class FUNC, class ARGS_01,
2053 class ARGS_02,
2054 class ARGS_03,
2055 class ARGS_04,
2056 class ARGS_05,
2057 class ARGS_06,
2058 class ARGS_07,
2059 class ARGS_08,
2060 class ARGS_09,
2061 class ARGS_10,
2062 class ARGS_11,
2063 class ARGS_12>
2064struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
2065 ARGS_02,
2066 ARGS_03,
2067 ARGS_04,
2068 ARGS_05,
2069 ARGS_06,
2070 ARGS_07,
2071 ARGS_08,
2072 ARGS_09,
2073 ARGS_10,
2074 ARGS_11,
2075 ARGS_12> {
2076};
2077#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
2078
2079#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
2080template <class VOID_TYPE, class FUNC, class ARGS_01,
2081 class ARGS_02,
2082 class ARGS_03,
2083 class ARGS_04,
2084 class ARGS_05,
2085 class ARGS_06,
2086 class ARGS_07,
2087 class ARGS_08,
2088 class ARGS_09,
2089 class ARGS_10,
2090 class ARGS_11,
2091 class ARGS_12,
2092 class ARGS_13>
2093struct Function_InvokerUtil_ResultTypeImp<VOID_TYPE, FUNC, ARGS_01,
2094 ARGS_02,
2095 ARGS_03,
2096 ARGS_04,
2097 ARGS_05,
2098 ARGS_06,
2099 ARGS_07,
2100 ARGS_08,
2101 ARGS_09,
2102 ARGS_10,
2103 ARGS_11,
2104 ARGS_12,
2105 ARGS_13> {
2106};
2107#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
2108
2109
2110#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
2111template <class FUNC>
2112struct Function_InvokerUtil_ResultTypeImp<
2113 typename bslmf::VoidType<
2114 >::type,
2115 FUNC>
2116: bsl::invoke_result<
2117 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2118 UnwrappedType<FUNC>::type>::type> {
2119
2120};
2121#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 0
2122
2123#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
2124template <class FUNC, class ARGS_01>
2125struct Function_InvokerUtil_ResultTypeImp<
2126 typename bslmf::VoidType<
2127 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type>::type,
2128 FUNC,
2129 ARGS_01>
2130: bsl::invoke_result<
2131 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2132 UnwrappedType<FUNC>::type>::type,
2133 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type> {
2134
2135};
2136#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 1
2137
2138#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
2139template <class FUNC, class ARGS_01,
2140 class ARGS_02>
2141struct Function_InvokerUtil_ResultTypeImp<
2142 typename bslmf::VoidType<
2143 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2144 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type>::type,
2145 FUNC,
2146 ARGS_01,
2147 ARGS_02>
2148: bsl::invoke_result<
2149 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2150 UnwrappedType<FUNC>::type>::type,
2151 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2152 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type> {
2153
2154};
2155#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 2
2156
2157#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
2158template <class FUNC, class ARGS_01,
2159 class ARGS_02,
2160 class ARGS_03>
2161struct Function_InvokerUtil_ResultTypeImp<
2162 typename bslmf::VoidType<
2163 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2164 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2165 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type>::type,
2166 FUNC,
2167 ARGS_01,
2168 ARGS_02,
2169 ARGS_03>
2170: bsl::invoke_result<
2171 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2172 UnwrappedType<FUNC>::type>::type,
2173 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2174 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2175 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type> {
2176
2177};
2178#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 3
2179
2180#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
2181template <class FUNC, class ARGS_01,
2182 class ARGS_02,
2183 class ARGS_03,
2184 class ARGS_04>
2185struct Function_InvokerUtil_ResultTypeImp<
2186 typename bslmf::VoidType<
2187 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2188 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2189 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2190 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type>::type,
2191 FUNC,
2192 ARGS_01,
2193 ARGS_02,
2194 ARGS_03,
2195 ARGS_04>
2196: bsl::invoke_result<
2197 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2198 UnwrappedType<FUNC>::type>::type,
2199 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2200 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2201 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2202 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type> {
2203
2204};
2205#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 4
2206
2207#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
2208template <class FUNC, class ARGS_01,
2209 class ARGS_02,
2210 class ARGS_03,
2211 class ARGS_04,
2212 class ARGS_05>
2213struct Function_InvokerUtil_ResultTypeImp<
2214 typename bslmf::VoidType<
2215 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2216 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2217 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2218 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2219 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type>::type,
2220 FUNC,
2221 ARGS_01,
2222 ARGS_02,
2223 ARGS_03,
2224 ARGS_04,
2225 ARGS_05>
2226: bsl::invoke_result<
2227 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2228 UnwrappedType<FUNC>::type>::type,
2229 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2230 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2231 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2232 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2233 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type> {
2234
2235};
2236#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 5
2237
2238#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
2239template <class FUNC, class ARGS_01,
2240 class ARGS_02,
2241 class ARGS_03,
2242 class ARGS_04,
2243 class ARGS_05,
2244 class ARGS_06>
2245struct Function_InvokerUtil_ResultTypeImp<
2246 typename bslmf::VoidType<
2247 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2248 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2249 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2250 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2251 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2252 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type>::type,
2253 FUNC,
2254 ARGS_01,
2255 ARGS_02,
2256 ARGS_03,
2257 ARGS_04,
2258 ARGS_05,
2259 ARGS_06>
2260: bsl::invoke_result<
2261 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2262 UnwrappedType<FUNC>::type>::type,
2263 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2264 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2265 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2266 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2267 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2268 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type> {
2269
2270};
2271#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 6
2272
2273#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
2274template <class FUNC, class ARGS_01,
2275 class ARGS_02,
2276 class ARGS_03,
2277 class ARGS_04,
2278 class ARGS_05,
2279 class ARGS_06,
2280 class ARGS_07>
2281struct Function_InvokerUtil_ResultTypeImp<
2282 typename bslmf::VoidType<
2283 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2284 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2285 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2286 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2287 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2288 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2289 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type>::type,
2290 FUNC,
2291 ARGS_01,
2292 ARGS_02,
2293 ARGS_03,
2294 ARGS_04,
2295 ARGS_05,
2296 ARGS_06,
2297 ARGS_07>
2298: bsl::invoke_result<
2299 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2300 UnwrappedType<FUNC>::type>::type,
2301 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2302 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2303 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2304 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2305 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2306 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2307 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type> {
2308
2309};
2310#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 7
2311
2312#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
2313template <class FUNC, class ARGS_01,
2314 class ARGS_02,
2315 class ARGS_03,
2316 class ARGS_04,
2317 class ARGS_05,
2318 class ARGS_06,
2319 class ARGS_07,
2320 class ARGS_08>
2321struct Function_InvokerUtil_ResultTypeImp<
2322 typename bslmf::VoidType<
2323 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2324 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2325 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2326 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2327 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2328 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2329 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2330 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type>::type,
2331 FUNC,
2332 ARGS_01,
2333 ARGS_02,
2334 ARGS_03,
2335 ARGS_04,
2336 ARGS_05,
2337 ARGS_06,
2338 ARGS_07,
2339 ARGS_08>
2340: bsl::invoke_result<
2341 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2342 UnwrappedType<FUNC>::type>::type,
2343 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2344 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2345 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2346 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2347 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2348 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2349 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2350 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type> {
2351
2352};
2353#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 8
2354
2355#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
2356template <class FUNC, class ARGS_01,
2357 class ARGS_02,
2358 class ARGS_03,
2359 class ARGS_04,
2360 class ARGS_05,
2361 class ARGS_06,
2362 class ARGS_07,
2363 class ARGS_08,
2364 class ARGS_09>
2365struct Function_InvokerUtil_ResultTypeImp<
2366 typename bslmf::VoidType<
2367 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2368 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2369 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2370 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2371 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2372 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2373 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2374 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2375 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type>::type,
2376 FUNC,
2377 ARGS_01,
2378 ARGS_02,
2379 ARGS_03,
2380 ARGS_04,
2381 ARGS_05,
2382 ARGS_06,
2383 ARGS_07,
2384 ARGS_08,
2385 ARGS_09>
2386: bsl::invoke_result<
2387 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2388 UnwrappedType<FUNC>::type>::type,
2389 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2390 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2391 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2392 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2393 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2394 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2395 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2396 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2397 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type> {
2398
2399};
2400#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 9
2401
2402#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
2403template <class FUNC, class ARGS_01,
2404 class ARGS_02,
2405 class ARGS_03,
2406 class ARGS_04,
2407 class ARGS_05,
2408 class ARGS_06,
2409 class ARGS_07,
2410 class ARGS_08,
2411 class ARGS_09,
2412 class ARGS_10>
2413struct Function_InvokerUtil_ResultTypeImp<
2414 typename bslmf::VoidType<
2415 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2416 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2417 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2418 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2419 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2420 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2421 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2422 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2423 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type,
2424 typename Function_InvokerUtil_ForwardType<ARGS_10>::Type>::type,
2425 FUNC,
2426 ARGS_01,
2427 ARGS_02,
2428 ARGS_03,
2429 ARGS_04,
2430 ARGS_05,
2431 ARGS_06,
2432 ARGS_07,
2433 ARGS_08,
2434 ARGS_09,
2435 ARGS_10>
2436: bsl::invoke_result<
2437 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2438 UnwrappedType<FUNC>::type>::type,
2439 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2440 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2441 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2442 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2443 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2444 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2445 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2446 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2447 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type,
2448 typename Function_InvokerUtil_ForwardType<ARGS_10>::Type> {
2449
2450};
2451#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 10
2452
2453#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
2454template <class FUNC, class ARGS_01,
2455 class ARGS_02,
2456 class ARGS_03,
2457 class ARGS_04,
2458 class ARGS_05,
2459 class ARGS_06,
2460 class ARGS_07,
2461 class ARGS_08,
2462 class ARGS_09,
2463 class ARGS_10,
2464 class ARGS_11>
2465struct Function_InvokerUtil_ResultTypeImp<
2466 typename bslmf::VoidType<
2467 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2468 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2469 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2470 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2471 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2472 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2473 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2474 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2475 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type,
2476 typename Function_InvokerUtil_ForwardType<ARGS_10>::Type,
2477 typename Function_InvokerUtil_ForwardType<ARGS_11>::Type>::type,
2478 FUNC,
2479 ARGS_01,
2480 ARGS_02,
2481 ARGS_03,
2482 ARGS_04,
2483 ARGS_05,
2484 ARGS_06,
2485 ARGS_07,
2486 ARGS_08,
2487 ARGS_09,
2488 ARGS_10,
2489 ARGS_11>
2490: bsl::invoke_result<
2491 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2492 UnwrappedType<FUNC>::type>::type,
2493 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2494 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2495 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2496 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2497 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2498 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2499 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2500 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2501 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type,
2502 typename Function_InvokerUtil_ForwardType<ARGS_10>::Type,
2503 typename Function_InvokerUtil_ForwardType<ARGS_11>::Type> {
2504
2505};
2506#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 11
2507
2508#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
2509template <class FUNC, class ARGS_01,
2510 class ARGS_02,
2511 class ARGS_03,
2512 class ARGS_04,
2513 class ARGS_05,
2514 class ARGS_06,
2515 class ARGS_07,
2516 class ARGS_08,
2517 class ARGS_09,
2518 class ARGS_10,
2519 class ARGS_11,
2520 class ARGS_12>
2521struct Function_InvokerUtil_ResultTypeImp<
2522 typename bslmf::VoidType<
2523 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2524 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2525 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2526 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2527 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2528 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2529 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2530 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2531 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type,
2532 typename Function_InvokerUtil_ForwardType<ARGS_10>::Type,
2533 typename Function_InvokerUtil_ForwardType<ARGS_11>::Type,
2534 typename Function_InvokerUtil_ForwardType<ARGS_12>::Type>::type,
2535 FUNC,
2536 ARGS_01,
2537 ARGS_02,
2538 ARGS_03,
2539 ARGS_04,
2540 ARGS_05,
2541 ARGS_06,
2542 ARGS_07,
2543 ARGS_08,
2544 ARGS_09,
2545 ARGS_10,
2546 ARGS_11,
2547 ARGS_12>
2548: bsl::invoke_result<
2549 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2550 UnwrappedType<FUNC>::type>::type,
2551 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2552 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2553 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2554 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2555 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2556 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2557 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2558 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2559 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type,
2560 typename Function_InvokerUtil_ForwardType<ARGS_10>::Type,
2561 typename Function_InvokerUtil_ForwardType<ARGS_11>::Type,
2562 typename Function_InvokerUtil_ForwardType<ARGS_12>::Type> {
2563
2564};
2565#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 12
2566
2567#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
2568template <class FUNC, class ARGS_01,
2569 class ARGS_02,
2570 class ARGS_03,
2571 class ARGS_04,
2572 class ARGS_05,
2573 class ARGS_06,
2574 class ARGS_07,
2575 class ARGS_08,
2576 class ARGS_09,
2577 class ARGS_10,
2578 class ARGS_11,
2579 class ARGS_12,
2580 class ARGS_13>
2581struct Function_InvokerUtil_ResultTypeImp<
2582 typename bslmf::VoidType<
2583 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2584 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2585 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2586 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2587 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2588 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2589 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2590 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2591 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type,
2592 typename Function_InvokerUtil_ForwardType<ARGS_10>::Type,
2593 typename Function_InvokerUtil_ForwardType<ARGS_11>::Type,
2594 typename Function_InvokerUtil_ForwardType<ARGS_12>::Type,
2595 typename Function_InvokerUtil_ForwardType<ARGS_13>::Type>::type,
2596 FUNC,
2597 ARGS_01,
2598 ARGS_02,
2599 ARGS_03,
2600 ARGS_04,
2601 ARGS_05,
2602 ARGS_06,
2603 ARGS_07,
2604 ARGS_08,
2605 ARGS_09,
2606 ARGS_10,
2607 ARGS_11,
2608 ARGS_12,
2609 ARGS_13>
2610: bsl::invoke_result<
2611 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2612 UnwrappedType<FUNC>::type>::type,
2613 typename Function_InvokerUtil_ForwardType<ARGS_01>::Type,
2614 typename Function_InvokerUtil_ForwardType<ARGS_02>::Type,
2615 typename Function_InvokerUtil_ForwardType<ARGS_03>::Type,
2616 typename Function_InvokerUtil_ForwardType<ARGS_04>::Type,
2617 typename Function_InvokerUtil_ForwardType<ARGS_05>::Type,
2618 typename Function_InvokerUtil_ForwardType<ARGS_06>::Type,
2619 typename Function_InvokerUtil_ForwardType<ARGS_07>::Type,
2620 typename Function_InvokerUtil_ForwardType<ARGS_08>::Type,
2621 typename Function_InvokerUtil_ForwardType<ARGS_09>::Type,
2622 typename Function_InvokerUtil_ForwardType<ARGS_10>::Type,
2623 typename Function_InvokerUtil_ForwardType<ARGS_11>::Type,
2624 typename Function_InvokerUtil_ForwardType<ARGS_12>::Type,
2625 typename Function_InvokerUtil_ForwardType<ARGS_13>::Type> {
2626
2627};
2628#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_A >= 13
2629
2630
2631
2632template <class VOID_TYPE, class ARG>
2633struct Function_InvokerUtil_ForwardTypeImp;
2634
2635template <class ARG>
2636struct Function_InvokerUtil_ForwardType
2637: Function_InvokerUtil_ForwardTypeImp<void, ARG> {
2638};
2639
2640
2641template <class VOID_TYPE, class ARG>
2642struct Function_InvokerUtil_ForwardTypeImp {
2643};
2644
2645template <class ARG>
2646struct Function_InvokerUtil_ForwardTypeImp<
2647 typename bslmf::VoidType<decltype(
2648 bslmf::ForwardingTypeUtil<ARG>::forwardToTarget(
2649 std::declval<typename bsl::add_lvalue_reference<
2650 typename bslmf::ForwardingType<ARG>::Type>::type>()))>::type,
2651 ARG> {
2652
2653
2654 typedef decltype(bslmf::ForwardingTypeUtil<ARG>::forwardToTarget(
2655 std::declval<typename bsl::add_lvalue_reference<
2656 typename bslmf::ForwardingType<ARG>::Type>::type>())) Type;
2657};
2658
2659
2660template <class VOID_TYPE, class FROM, class TO>
2661struct Function_InvokerUtil_IsExplicitlyConvertibleImp;
2662
2663template <class FROM, class TO>
2664struct Function_InvokerUtil_IsExplicitlyConvertible
2665: Function_InvokerUtil_IsExplicitlyConvertibleImp<void, FROM, TO> {
2666};
2667
2668template <class FROM_TO>
2669struct Function_InvokerUtil_IsExplicitlyConvertible<FROM_TO, FROM_TO>
2670: bsl::true_type {
2671};
2672
2673
2674template <class VOID_TYPE, class FROM, class TO>
2675struct Function_InvokerUtil_IsExplicitlyConvertibleImp : bsl::false_type {
2676};
2677
2678template <class FROM, class TO>
2679struct Function_InvokerUtil_IsExplicitlyConvertibleImp<
2680 typename bslmf::VoidType<decltype(
2681 static_cast<TO>(std::declval<FROM>()))>::type,
2682 FROM,
2683 TO> : bsl::true_type {
2684};
2685
2686#endif
2687#else
2688// The generated code below is a workaround for the absence of perfect
2689// forwarding in some compilers.
2690
2691
2692#ifdef BSLSTL_FUNCTION_INVOKERUTIL_SUPPORT_IS_FUNC_INVOCABLE
2693
2694template <class VOID_TYPE, class RET, class FUNC, class... ARGS>
2695struct Function_InvokerUtil_IsFuncInvocableImp;
2696
2697template <class RET, class FUNC, class... ARGS>
2698struct Function_InvokerUtil_IsFuncInvocable<RET(ARGS...), FUNC>
2699: Function_InvokerUtil_IsFuncInvocableImp<void, RET, FUNC, ARGS...> {
2700};
2701
2702
2703template <class ARG>
2704struct Function_InvokerUtil_ForwardType;
2705
2706template <class FROM, class TO>
2707struct Function_InvokerUtil_IsExplicitlyConvertible;
2708
2709template <class FUNC, class... ARGS>
2710struct Function_InvokerUtil_ResultType;
2711
2712template <class VOID_TYPE, class RET, class FUNC, class... ARGS>
2713struct Function_InvokerUtil_IsFuncInvocableImp : bsl::false_type {
2714};
2715
2716template <class RET, class FUNC, class... ARGS>
2717struct Function_InvokerUtil_IsFuncInvocableImp<
2718 typename bslmf::VoidType<
2719 typename Function_InvokerUtil_ResultType<FUNC, ARGS...>::type>::type,
2720 RET,
2721 FUNC,
2722 ARGS...>
2723: bsl::conditional<
2724 bsl::is_void<RET>::value,
2725 bsl::true_type,
2726 Function_InvokerUtil_IsExplicitlyConvertible<
2727 typename Function_InvokerUtil_ResultType<FUNC, ARGS...>::type,
2728 RET> >::type {
2729};
2730
2731
2732template <class VOID_TYPE, class FUNC, class... ARGS>
2733struct Function_InvokerUtil_ResultTypeImp;
2734
2735template <class FUNC, class... ARGS>
2736struct Function_InvokerUtil_ResultType
2737: Function_InvokerUtil_ResultTypeImp<void, FUNC, ARGS...> {
2738};
2739
2740
2741template <class VOID_TYPE, class FUNC, class... ARGS>
2742struct Function_InvokerUtil_ResultTypeImp {
2743};
2744
2745template <class FUNC, class... ARGS>
2746struct Function_InvokerUtil_ResultTypeImp<
2747 typename bslmf::VoidType<
2748 typename Function_InvokerUtil_ForwardType<ARGS>::Type...>::type,
2749 FUNC,
2750 ARGS...>
2751: bsl::invoke_result<
2752 typename bsl::add_lvalue_reference<typename bslalg::NothrowMovableUtil::
2753 UnwrappedType<FUNC>::type>::type,
2754 typename Function_InvokerUtil_ForwardType<ARGS>::Type...> {
2755
2756};
2757
2758
2759template <class VOID_TYPE, class ARG>
2760struct Function_InvokerUtil_ForwardTypeImp;
2761
2762template <class ARG>
2763struct Function_InvokerUtil_ForwardType
2764: Function_InvokerUtil_ForwardTypeImp<void, ARG> {
2765};
2766
2767
2768template <class VOID_TYPE, class ARG>
2769struct Function_InvokerUtil_ForwardTypeImp {
2770};
2771
2772template <class ARG>
2773struct Function_InvokerUtil_ForwardTypeImp<
2774 typename bslmf::VoidType<decltype(
2775 bslmf::ForwardingTypeUtil<ARG>::forwardToTarget(
2776 std::declval<typename bsl::add_lvalue_reference<
2777 typename bslmf::ForwardingType<ARG>::Type>::type>()))>::type,
2778 ARG> {
2779
2780
2781 typedef decltype(bslmf::ForwardingTypeUtil<ARG>::forwardToTarget(
2782 std::declval<typename bsl::add_lvalue_reference<
2783 typename bslmf::ForwardingType<ARG>::Type>::type>())) Type;
2784};
2785
2786
2787template <class VOID_TYPE, class FROM, class TO>
2788struct Function_InvokerUtil_IsExplicitlyConvertibleImp;
2789
2790template <class FROM, class TO>
2791struct Function_InvokerUtil_IsExplicitlyConvertible
2792: Function_InvokerUtil_IsExplicitlyConvertibleImp<void, FROM, TO> {
2793};
2794
2795template <class FROM_TO>
2796struct Function_InvokerUtil_IsExplicitlyConvertible<FROM_TO, FROM_TO>
2797: bsl::true_type {
2798};
2799
2800
2801template <class VOID_TYPE, class FROM, class TO>
2802struct Function_InvokerUtil_IsExplicitlyConvertibleImp : bsl::false_type {
2803};
2804
2805template <class FROM, class TO>
2806struct Function_InvokerUtil_IsExplicitlyConvertibleImp<
2807 typename bslmf::VoidType<decltype(
2808 static_cast<TO>(std::declval<FROM>()))>::type,
2809 FROM,
2810 TO> : bsl::true_type {
2811};
2812
2813#endif
2814// }}} END GENERATED CODE
2815#endif
2816
2817 // =============================================
2818 // template struct Function_InvokerUtil_Dispatch
2819 // =============================================
2820
2821/// Specializations of this class contain a static `invoke` method that can
2822/// invoke a callable object of type `FUNC`, converting each argument in
2823/// `PROTOTYPE` (a function prototype) to the corresponding argument in the
2824/// invocation of the callable object and converting the return value of the
2825/// invocation to the return type of `PROTOTYPE`. The `INVOCATION_TYPE`
2826/// specifies the category of callable object: pointer to function, pointer
2827/// to member function, pointer to data member, inplace functor (i.e., one
2828/// that qualifies for the small-object optimization) and out-of-place
2829/// functor (i.e., one that is not stored in the small-object buffer).
2830template <int INVOCATION_TYPE, class PROTOTYPE, class FUNC>
2831struct Function_InvokerUtil_Dispatch;
2832
2833#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
2834// {{{ BEGIN GENERATED CODE
2835// Command line: sim_cpp11_features.pl bslstl_function_invokerutil.h
2836#ifndef BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT
2837#define BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT 13
2838#endif
2839#ifndef BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B
2840#define BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT
2841#endif
2842
2843
2844#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 0
2845template <class FUNC, class RET>
2846struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
2847 RET(), FUNC> {
2848
2849
2850 static RET invoke(const Function_Rep *rep);
2851};
2852#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 0
2853
2854#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 1
2855template <class FUNC, class RET, class ARGS_01>
2856struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
2857 RET(ARGS_01), FUNC> {
2858
2859
2860 static RET invoke(const Function_Rep *rep,
2861 typename bslmf::ForwardingType<ARGS_01>::Type args_01);
2862};
2863#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 1
2864
2865#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 2
2866template <class FUNC, class RET, class ARGS_01,
2867 class ARGS_02>
2868struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
2869 RET(ARGS_01,
2870 ARGS_02), FUNC> {
2871
2872
2873 static RET invoke(const Function_Rep *rep,
2874 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
2875 typename bslmf::ForwardingType<ARGS_02>::Type args_02);
2876};
2877#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 2
2878
2879#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 3
2880template <class FUNC, class RET, class ARGS_01,
2881 class ARGS_02,
2882 class ARGS_03>
2883struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
2884 RET(ARGS_01,
2885 ARGS_02,
2886 ARGS_03), FUNC> {
2887
2888
2889 static RET invoke(const Function_Rep *rep,
2890 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
2891 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
2892 typename bslmf::ForwardingType<ARGS_03>::Type args_03);
2893};
2894#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 3
2895
2896#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 4
2897template <class FUNC, class RET, class ARGS_01,
2898 class ARGS_02,
2899 class ARGS_03,
2900 class ARGS_04>
2901struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
2902 RET(ARGS_01,
2903 ARGS_02,
2904 ARGS_03,
2905 ARGS_04), FUNC> {
2906
2907
2908 static RET invoke(const Function_Rep *rep,
2909 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
2910 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
2911 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
2912 typename bslmf::ForwardingType<ARGS_04>::Type args_04);
2913};
2914#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 4
2915
2916#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 5
2917template <class FUNC, class RET, class ARGS_01,
2918 class ARGS_02,
2919 class ARGS_03,
2920 class ARGS_04,
2921 class ARGS_05>
2922struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
2923 RET(ARGS_01,
2924 ARGS_02,
2925 ARGS_03,
2926 ARGS_04,
2927 ARGS_05), FUNC> {
2928
2929
2930 static RET invoke(const Function_Rep *rep,
2931 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
2932 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
2933 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
2934 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
2935 typename bslmf::ForwardingType<ARGS_05>::Type args_05);
2936};
2937#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 5
2938
2939#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 6
2940template <class FUNC, class RET, class ARGS_01,
2941 class ARGS_02,
2942 class ARGS_03,
2943 class ARGS_04,
2944 class ARGS_05,
2945 class ARGS_06>
2946struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
2947 RET(ARGS_01,
2948 ARGS_02,
2949 ARGS_03,
2950 ARGS_04,
2951 ARGS_05,
2952 ARGS_06), FUNC> {
2953
2954
2955 static RET invoke(const Function_Rep *rep,
2956 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
2957 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
2958 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
2959 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
2960 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
2961 typename bslmf::ForwardingType<ARGS_06>::Type args_06);
2962};
2963#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 6
2964
2965#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 7
2966template <class FUNC, class RET, class ARGS_01,
2967 class ARGS_02,
2968 class ARGS_03,
2969 class ARGS_04,
2970 class ARGS_05,
2971 class ARGS_06,
2972 class ARGS_07>
2973struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
2974 RET(ARGS_01,
2975 ARGS_02,
2976 ARGS_03,
2977 ARGS_04,
2978 ARGS_05,
2979 ARGS_06,
2980 ARGS_07), FUNC> {
2981
2982
2983 static RET invoke(const Function_Rep *rep,
2984 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
2985 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
2986 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
2987 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
2988 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
2989 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
2990 typename bslmf::ForwardingType<ARGS_07>::Type args_07);
2991};
2992#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 7
2993
2994#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 8
2995template <class FUNC, class RET, class ARGS_01,
2996 class ARGS_02,
2997 class ARGS_03,
2998 class ARGS_04,
2999 class ARGS_05,
3000 class ARGS_06,
3001 class ARGS_07,
3002 class ARGS_08>
3003struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
3004 RET(ARGS_01,
3005 ARGS_02,
3006 ARGS_03,
3007 ARGS_04,
3008 ARGS_05,
3009 ARGS_06,
3010 ARGS_07,
3011 ARGS_08), FUNC> {
3012
3013
3014 static RET invoke(const Function_Rep *rep,
3015 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3016 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3017 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3018 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3019 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3020 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3021 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3022 typename bslmf::ForwardingType<ARGS_08>::Type args_08);
3023};
3024#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 8
3025
3026#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 9
3027template <class FUNC, class RET, class ARGS_01,
3028 class ARGS_02,
3029 class ARGS_03,
3030 class ARGS_04,
3031 class ARGS_05,
3032 class ARGS_06,
3033 class ARGS_07,
3034 class ARGS_08,
3035 class ARGS_09>
3036struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
3037 RET(ARGS_01,
3038 ARGS_02,
3039 ARGS_03,
3040 ARGS_04,
3041 ARGS_05,
3042 ARGS_06,
3043 ARGS_07,
3044 ARGS_08,
3045 ARGS_09), FUNC> {
3046
3047
3048 static RET invoke(const Function_Rep *rep,
3049 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3050 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3051 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3052 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3053 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3054 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3055 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3056 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3057 typename bslmf::ForwardingType<ARGS_09>::Type args_09);
3058};
3059#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 9
3060
3061#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 10
3062template <class FUNC, class RET, class ARGS_01,
3063 class ARGS_02,
3064 class ARGS_03,
3065 class ARGS_04,
3066 class ARGS_05,
3067 class ARGS_06,
3068 class ARGS_07,
3069 class ARGS_08,
3070 class ARGS_09,
3071 class ARGS_10>
3072struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
3073 RET(ARGS_01,
3074 ARGS_02,
3075 ARGS_03,
3076 ARGS_04,
3077 ARGS_05,
3078 ARGS_06,
3079 ARGS_07,
3080 ARGS_08,
3081 ARGS_09,
3082 ARGS_10), FUNC> {
3083
3084
3085 static RET invoke(const Function_Rep *rep,
3086 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3087 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3088 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3089 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3090 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3091 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3092 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3093 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3094 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3095 typename bslmf::ForwardingType<ARGS_10>::Type args_10);
3096};
3097#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 10
3098
3099#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 11
3100template <class FUNC, class RET, class ARGS_01,
3101 class ARGS_02,
3102 class ARGS_03,
3103 class ARGS_04,
3104 class ARGS_05,
3105 class ARGS_06,
3106 class ARGS_07,
3107 class ARGS_08,
3108 class ARGS_09,
3109 class ARGS_10,
3110 class ARGS_11>
3111struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
3112 RET(ARGS_01,
3113 ARGS_02,
3114 ARGS_03,
3115 ARGS_04,
3116 ARGS_05,
3117 ARGS_06,
3118 ARGS_07,
3119 ARGS_08,
3120 ARGS_09,
3121 ARGS_10,
3122 ARGS_11), FUNC> {
3123
3124
3125 static RET invoke(const Function_Rep *rep,
3126 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3127 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3128 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3129 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3130 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3131 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3132 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3133 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3134 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3135 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3136 typename bslmf::ForwardingType<ARGS_11>::Type args_11);
3137};
3138#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 11
3139
3140#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 12
3141template <class FUNC, class RET, class ARGS_01,
3142 class ARGS_02,
3143 class ARGS_03,
3144 class ARGS_04,
3145 class ARGS_05,
3146 class ARGS_06,
3147 class ARGS_07,
3148 class ARGS_08,
3149 class ARGS_09,
3150 class ARGS_10,
3151 class ARGS_11,
3152 class ARGS_12>
3153struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
3154 RET(ARGS_01,
3155 ARGS_02,
3156 ARGS_03,
3157 ARGS_04,
3158 ARGS_05,
3159 ARGS_06,
3160 ARGS_07,
3161 ARGS_08,
3162 ARGS_09,
3163 ARGS_10,
3164 ARGS_11,
3165 ARGS_12), FUNC> {
3166
3167
3168 static RET invoke(const Function_Rep *rep,
3169 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3170 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3171 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3172 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3173 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3174 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3175 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3176 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3177 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3178 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3179 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
3180 typename bslmf::ForwardingType<ARGS_12>::Type args_12);
3181};
3182#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 12
3183
3184#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 13
3185template <class FUNC, class RET, class ARGS_01,
3186 class ARGS_02,
3187 class ARGS_03,
3188 class ARGS_04,
3189 class ARGS_05,
3190 class ARGS_06,
3191 class ARGS_07,
3192 class ARGS_08,
3193 class ARGS_09,
3194 class ARGS_10,
3195 class ARGS_11,
3196 class ARGS_12,
3197 class ARGS_13>
3198struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
3199 RET(ARGS_01,
3200 ARGS_02,
3201 ARGS_03,
3202 ARGS_04,
3203 ARGS_05,
3204 ARGS_06,
3205 ARGS_07,
3206 ARGS_08,
3207 ARGS_09,
3208 ARGS_10,
3209 ARGS_11,
3210 ARGS_12,
3211 ARGS_13), FUNC> {
3212
3213
3214 static RET invoke(const Function_Rep *rep,
3215 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3216 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3217 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3218 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3219 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3220 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3221 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3222 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3223 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3224 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3225 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
3226 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
3227 typename bslmf::ForwardingType<ARGS_13>::Type args_13);
3228};
3229#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 13
3230
3231
3232#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 0
3233template <class FUNC, class RET, class ARG0>
3234struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3235 RET(ARG0), FUNC> {
3236
3237 private:
3238
3239 static RET invokeImp(bsl::true_type ,
3240 FUNC f,
3241 typename bslmf::ForwardingType<ARG0>::Type obj);
3242
3243 static RET invokeImp(bsl::false_type ,
3244 FUNC f,
3245 typename bslmf::ForwardingType<ARG0>::Type obj);
3246
3247 public:
3248
3249 static RET invoke(const Function_Rep *rep,
3250 typename bslmf::ForwardingType<ARG0>::Type obj);
3251};
3252#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 0
3253
3254#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 1
3255template <class FUNC, class RET, class ARG0, class ARGS_01>
3256struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3257 RET(ARG0, ARGS_01), FUNC> {
3258
3259 private:
3260
3261 static RET invokeImp(bsl::true_type ,
3262 FUNC f,
3263 typename bslmf::ForwardingType<ARG0>::Type obj,
3264 typename bslmf::ForwardingType<ARGS_01>::Type args_01);
3265
3266 static RET invokeImp(bsl::false_type ,
3267 FUNC f,
3268 typename bslmf::ForwardingType<ARG0>::Type obj,
3269 typename bslmf::ForwardingType<ARGS_01>::Type args_01);
3270
3271 public:
3272
3273 static RET invoke(const Function_Rep *rep,
3274 typename bslmf::ForwardingType<ARG0>::Type obj,
3275 typename bslmf::ForwardingType<ARGS_01>::Type args_01);
3276};
3277#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 1
3278
3279#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 2
3280template <class FUNC, class RET, class ARG0, class ARGS_01,
3281 class ARGS_02>
3282struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3283 RET(ARG0, ARGS_01,
3284 ARGS_02), FUNC> {
3285
3286 private:
3287
3288 static RET invokeImp(bsl::true_type ,
3289 FUNC f,
3290 typename bslmf::ForwardingType<ARG0>::Type obj,
3291 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3292 typename bslmf::ForwardingType<ARGS_02>::Type args_02);
3293
3294 static RET invokeImp(bsl::false_type ,
3295 FUNC f,
3296 typename bslmf::ForwardingType<ARG0>::Type obj,
3297 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3298 typename bslmf::ForwardingType<ARGS_02>::Type args_02);
3299
3300 public:
3301
3302 static RET invoke(const Function_Rep *rep,
3303 typename bslmf::ForwardingType<ARG0>::Type obj,
3304 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3305 typename bslmf::ForwardingType<ARGS_02>::Type args_02);
3306};
3307#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 2
3308
3309#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 3
3310template <class FUNC, class RET, class ARG0, class ARGS_01,
3311 class ARGS_02,
3312 class ARGS_03>
3313struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3314 RET(ARG0, ARGS_01,
3315 ARGS_02,
3316 ARGS_03), FUNC> {
3317
3318 private:
3319
3320 static RET invokeImp(bsl::true_type ,
3321 FUNC f,
3322 typename bslmf::ForwardingType<ARG0>::Type obj,
3323 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3324 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3325 typename bslmf::ForwardingType<ARGS_03>::Type args_03);
3326
3327 static RET invokeImp(bsl::false_type ,
3328 FUNC f,
3329 typename bslmf::ForwardingType<ARG0>::Type obj,
3330 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3331 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3332 typename bslmf::ForwardingType<ARGS_03>::Type args_03);
3333
3334 public:
3335
3336 static RET invoke(const Function_Rep *rep,
3337 typename bslmf::ForwardingType<ARG0>::Type obj,
3338 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3339 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3340 typename bslmf::ForwardingType<ARGS_03>::Type args_03);
3341};
3342#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 3
3343
3344#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 4
3345template <class FUNC, class RET, class ARG0, class ARGS_01,
3346 class ARGS_02,
3347 class ARGS_03,
3348 class ARGS_04>
3349struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3350 RET(ARG0, ARGS_01,
3351 ARGS_02,
3352 ARGS_03,
3353 ARGS_04), FUNC> {
3354
3355 private:
3356
3357 static RET invokeImp(bsl::true_type ,
3358 FUNC f,
3359 typename bslmf::ForwardingType<ARG0>::Type obj,
3360 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3361 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3362 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3363 typename bslmf::ForwardingType<ARGS_04>::Type args_04);
3364
3365 static RET invokeImp(bsl::false_type ,
3366 FUNC f,
3367 typename bslmf::ForwardingType<ARG0>::Type obj,
3368 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3369 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3370 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3371 typename bslmf::ForwardingType<ARGS_04>::Type args_04);
3372
3373 public:
3374
3375 static RET invoke(const Function_Rep *rep,
3376 typename bslmf::ForwardingType<ARG0>::Type obj,
3377 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3378 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3379 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3380 typename bslmf::ForwardingType<ARGS_04>::Type args_04);
3381};
3382#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 4
3383
3384#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 5
3385template <class FUNC, class RET, class ARG0, class ARGS_01,
3386 class ARGS_02,
3387 class ARGS_03,
3388 class ARGS_04,
3389 class ARGS_05>
3390struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3391 RET(ARG0, ARGS_01,
3392 ARGS_02,
3393 ARGS_03,
3394 ARGS_04,
3395 ARGS_05), FUNC> {
3396
3397 private:
3398
3399 static RET invokeImp(bsl::true_type ,
3400 FUNC f,
3401 typename bslmf::ForwardingType<ARG0>::Type obj,
3402 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3403 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3404 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3405 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3406 typename bslmf::ForwardingType<ARGS_05>::Type args_05);
3407
3408 static RET invokeImp(bsl::false_type ,
3409 FUNC f,
3410 typename bslmf::ForwardingType<ARG0>::Type obj,
3411 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3412 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3413 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3414 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3415 typename bslmf::ForwardingType<ARGS_05>::Type args_05);
3416
3417 public:
3418
3419 static RET invoke(const Function_Rep *rep,
3420 typename bslmf::ForwardingType<ARG0>::Type obj,
3421 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3422 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3423 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3424 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3425 typename bslmf::ForwardingType<ARGS_05>::Type args_05);
3426};
3427#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 5
3428
3429#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 6
3430template <class FUNC, class RET, class ARG0, class ARGS_01,
3431 class ARGS_02,
3432 class ARGS_03,
3433 class ARGS_04,
3434 class ARGS_05,
3435 class ARGS_06>
3436struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3437 RET(ARG0, ARGS_01,
3438 ARGS_02,
3439 ARGS_03,
3440 ARGS_04,
3441 ARGS_05,
3442 ARGS_06), FUNC> {
3443
3444 private:
3445
3446 static RET invokeImp(bsl::true_type ,
3447 FUNC f,
3448 typename bslmf::ForwardingType<ARG0>::Type obj,
3449 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3450 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3451 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3452 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3453 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3454 typename bslmf::ForwardingType<ARGS_06>::Type args_06);
3455
3456 static RET invokeImp(bsl::false_type ,
3457 FUNC f,
3458 typename bslmf::ForwardingType<ARG0>::Type obj,
3459 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3460 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3461 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3462 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3463 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3464 typename bslmf::ForwardingType<ARGS_06>::Type args_06);
3465
3466 public:
3467
3468 static RET invoke(const Function_Rep *rep,
3469 typename bslmf::ForwardingType<ARG0>::Type obj,
3470 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3471 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3472 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3473 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3474 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3475 typename bslmf::ForwardingType<ARGS_06>::Type args_06);
3476};
3477#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 6
3478
3479#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 7
3480template <class FUNC, class RET, class ARG0, class ARGS_01,
3481 class ARGS_02,
3482 class ARGS_03,
3483 class ARGS_04,
3484 class ARGS_05,
3485 class ARGS_06,
3486 class ARGS_07>
3487struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3488 RET(ARG0, ARGS_01,
3489 ARGS_02,
3490 ARGS_03,
3491 ARGS_04,
3492 ARGS_05,
3493 ARGS_06,
3494 ARGS_07), FUNC> {
3495
3496 private:
3497
3498 static RET invokeImp(bsl::true_type ,
3499 FUNC f,
3500 typename bslmf::ForwardingType<ARG0>::Type obj,
3501 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3502 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3503 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3504 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3505 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3506 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3507 typename bslmf::ForwardingType<ARGS_07>::Type args_07);
3508
3509 static RET invokeImp(bsl::false_type ,
3510 FUNC f,
3511 typename bslmf::ForwardingType<ARG0>::Type obj,
3512 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3513 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3514 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3515 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3516 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3517 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3518 typename bslmf::ForwardingType<ARGS_07>::Type args_07);
3519
3520 public:
3521
3522 static RET invoke(const Function_Rep *rep,
3523 typename bslmf::ForwardingType<ARG0>::Type obj,
3524 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3525 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3526 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3527 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3528 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3529 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3530 typename bslmf::ForwardingType<ARGS_07>::Type args_07);
3531};
3532#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 7
3533
3534#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 8
3535template <class FUNC, class RET, class ARG0, class ARGS_01,
3536 class ARGS_02,
3537 class ARGS_03,
3538 class ARGS_04,
3539 class ARGS_05,
3540 class ARGS_06,
3541 class ARGS_07,
3542 class ARGS_08>
3543struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3544 RET(ARG0, ARGS_01,
3545 ARGS_02,
3546 ARGS_03,
3547 ARGS_04,
3548 ARGS_05,
3549 ARGS_06,
3550 ARGS_07,
3551 ARGS_08), FUNC> {
3552
3553 private:
3554
3555 static RET invokeImp(bsl::true_type ,
3556 FUNC f,
3557 typename bslmf::ForwardingType<ARG0>::Type obj,
3558 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3559 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3560 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3561 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3562 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3563 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3564 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3565 typename bslmf::ForwardingType<ARGS_08>::Type args_08);
3566
3567 static RET invokeImp(bsl::false_type ,
3568 FUNC f,
3569 typename bslmf::ForwardingType<ARG0>::Type obj,
3570 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3571 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3572 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3573 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3574 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3575 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3576 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3577 typename bslmf::ForwardingType<ARGS_08>::Type args_08);
3578
3579 public:
3580
3581 static RET invoke(const Function_Rep *rep,
3582 typename bslmf::ForwardingType<ARG0>::Type obj,
3583 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3584 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3585 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3586 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3587 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3588 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3589 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3590 typename bslmf::ForwardingType<ARGS_08>::Type args_08);
3591};
3592#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 8
3593
3594#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 9
3595template <class FUNC, class RET, class ARG0, class ARGS_01,
3596 class ARGS_02,
3597 class ARGS_03,
3598 class ARGS_04,
3599 class ARGS_05,
3600 class ARGS_06,
3601 class ARGS_07,
3602 class ARGS_08,
3603 class ARGS_09>
3604struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3605 RET(ARG0, ARGS_01,
3606 ARGS_02,
3607 ARGS_03,
3608 ARGS_04,
3609 ARGS_05,
3610 ARGS_06,
3611 ARGS_07,
3612 ARGS_08,
3613 ARGS_09), FUNC> {
3614
3615 private:
3616
3617 static RET invokeImp(bsl::true_type ,
3618 FUNC f,
3619 typename bslmf::ForwardingType<ARG0>::Type obj,
3620 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3621 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3622 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3623 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3624 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3625 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3626 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3627 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3628 typename bslmf::ForwardingType<ARGS_09>::Type args_09);
3629
3630 static RET invokeImp(bsl::false_type ,
3631 FUNC f,
3632 typename bslmf::ForwardingType<ARG0>::Type obj,
3633 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3634 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3635 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3636 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3637 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3638 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3639 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3640 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3641 typename bslmf::ForwardingType<ARGS_09>::Type args_09);
3642
3643 public:
3644
3645 static RET invoke(const Function_Rep *rep,
3646 typename bslmf::ForwardingType<ARG0>::Type obj,
3647 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3648 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3649 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3650 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3651 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3652 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3653 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3654 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3655 typename bslmf::ForwardingType<ARGS_09>::Type args_09);
3656};
3657#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 9
3658
3659#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 10
3660template <class FUNC, class RET, class ARG0, class ARGS_01,
3661 class ARGS_02,
3662 class ARGS_03,
3663 class ARGS_04,
3664 class ARGS_05,
3665 class ARGS_06,
3666 class ARGS_07,
3667 class ARGS_08,
3668 class ARGS_09,
3669 class ARGS_10>
3670struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3671 RET(ARG0, ARGS_01,
3672 ARGS_02,
3673 ARGS_03,
3674 ARGS_04,
3675 ARGS_05,
3676 ARGS_06,
3677 ARGS_07,
3678 ARGS_08,
3679 ARGS_09,
3680 ARGS_10), FUNC> {
3681
3682 private:
3683
3684 static RET invokeImp(bsl::true_type ,
3685 FUNC f,
3686 typename bslmf::ForwardingType<ARG0>::Type obj,
3687 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3688 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3689 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3690 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3691 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3692 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3693 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3694 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3695 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3696 typename bslmf::ForwardingType<ARGS_10>::Type args_10);
3697
3698 static RET invokeImp(bsl::false_type ,
3699 FUNC f,
3700 typename bslmf::ForwardingType<ARG0>::Type obj,
3701 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3702 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3703 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3704 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3705 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3706 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3707 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3708 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3709 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3710 typename bslmf::ForwardingType<ARGS_10>::Type args_10);
3711
3712 public:
3713
3714 static RET invoke(const Function_Rep *rep,
3715 typename bslmf::ForwardingType<ARG0>::Type obj,
3716 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3717 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3718 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3719 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3720 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3721 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3722 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3723 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3724 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3725 typename bslmf::ForwardingType<ARGS_10>::Type args_10);
3726};
3727#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 10
3728
3729#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 11
3730template <class FUNC, class RET, class ARG0, class ARGS_01,
3731 class ARGS_02,
3732 class ARGS_03,
3733 class ARGS_04,
3734 class ARGS_05,
3735 class ARGS_06,
3736 class ARGS_07,
3737 class ARGS_08,
3738 class ARGS_09,
3739 class ARGS_10,
3740 class ARGS_11>
3741struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3742 RET(ARG0, ARGS_01,
3743 ARGS_02,
3744 ARGS_03,
3745 ARGS_04,
3746 ARGS_05,
3747 ARGS_06,
3748 ARGS_07,
3749 ARGS_08,
3750 ARGS_09,
3751 ARGS_10,
3752 ARGS_11), FUNC> {
3753
3754 private:
3755
3756 static RET invokeImp(bsl::true_type ,
3757 FUNC f,
3758 typename bslmf::ForwardingType<ARG0>::Type obj,
3759 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3760 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3761 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3762 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3763 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3764 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3765 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3766 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3767 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3768 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3769 typename bslmf::ForwardingType<ARGS_11>::Type args_11);
3770
3771 static RET invokeImp(bsl::false_type ,
3772 FUNC f,
3773 typename bslmf::ForwardingType<ARG0>::Type obj,
3774 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3775 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3776 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3777 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3778 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3779 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3780 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3781 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3782 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3783 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3784 typename bslmf::ForwardingType<ARGS_11>::Type args_11);
3785
3786 public:
3787
3788 static RET invoke(const Function_Rep *rep,
3789 typename bslmf::ForwardingType<ARG0>::Type obj,
3790 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3791 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3792 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3793 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3794 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3795 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3796 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3797 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3798 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3799 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3800 typename bslmf::ForwardingType<ARGS_11>::Type args_11);
3801};
3802#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 11
3803
3804#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 12
3805template <class FUNC, class RET, class ARG0, class ARGS_01,
3806 class ARGS_02,
3807 class ARGS_03,
3808 class ARGS_04,
3809 class ARGS_05,
3810 class ARGS_06,
3811 class ARGS_07,
3812 class ARGS_08,
3813 class ARGS_09,
3814 class ARGS_10,
3815 class ARGS_11,
3816 class ARGS_12>
3817struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3818 RET(ARG0, ARGS_01,
3819 ARGS_02,
3820 ARGS_03,
3821 ARGS_04,
3822 ARGS_05,
3823 ARGS_06,
3824 ARGS_07,
3825 ARGS_08,
3826 ARGS_09,
3827 ARGS_10,
3828 ARGS_11,
3829 ARGS_12), FUNC> {
3830
3831 private:
3832
3833 static RET invokeImp(bsl::true_type ,
3834 FUNC f,
3835 typename bslmf::ForwardingType<ARG0>::Type obj,
3836 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3837 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3838 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3839 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3840 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3841 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3842 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3843 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3844 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3845 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3846 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
3847 typename bslmf::ForwardingType<ARGS_12>::Type args_12);
3848
3849 static RET invokeImp(bsl::false_type ,
3850 FUNC f,
3851 typename bslmf::ForwardingType<ARG0>::Type obj,
3852 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3853 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3854 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3855 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3856 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3857 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3858 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3859 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3860 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3861 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3862 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
3863 typename bslmf::ForwardingType<ARGS_12>::Type args_12);
3864
3865 public:
3866
3867 static RET invoke(const Function_Rep *rep,
3868 typename bslmf::ForwardingType<ARG0>::Type obj,
3869 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3870 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3871 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3872 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3873 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3874 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3875 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3876 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3877 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3878 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3879 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
3880 typename bslmf::ForwardingType<ARGS_12>::Type args_12);
3881};
3882#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 12
3883
3884#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 13
3885template <class FUNC, class RET, class ARG0, class ARGS_01,
3886 class ARGS_02,
3887 class ARGS_03,
3888 class ARGS_04,
3889 class ARGS_05,
3890 class ARGS_06,
3891 class ARGS_07,
3892 class ARGS_08,
3893 class ARGS_09,
3894 class ARGS_10,
3895 class ARGS_11,
3896 class ARGS_12,
3897 class ARGS_13>
3898struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
3899 RET(ARG0, ARGS_01,
3900 ARGS_02,
3901 ARGS_03,
3902 ARGS_04,
3903 ARGS_05,
3904 ARGS_06,
3905 ARGS_07,
3906 ARGS_08,
3907 ARGS_09,
3908 ARGS_10,
3909 ARGS_11,
3910 ARGS_12,
3911 ARGS_13), FUNC> {
3912
3913 private:
3914
3915 static RET invokeImp(bsl::true_type ,
3916 FUNC f,
3917 typename bslmf::ForwardingType<ARG0>::Type obj,
3918 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3919 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3920 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3921 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3922 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3923 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3924 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3925 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3926 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3927 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3928 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
3929 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
3930 typename bslmf::ForwardingType<ARGS_13>::Type args_13);
3931
3932 static RET invokeImp(bsl::false_type ,
3933 FUNC f,
3934 typename bslmf::ForwardingType<ARG0>::Type obj,
3935 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3936 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3937 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3938 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3939 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3940 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3941 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3942 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3943 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3944 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3945 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
3946 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
3947 typename bslmf::ForwardingType<ARGS_13>::Type args_13);
3948
3949 public:
3950
3951 static RET invoke(const Function_Rep *rep,
3952 typename bslmf::ForwardingType<ARG0>::Type obj,
3953 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
3954 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
3955 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
3956 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
3957 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
3958 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
3959 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
3960 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
3961 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
3962 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
3963 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
3964 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
3965 typename bslmf::ForwardingType<ARGS_13>::Type args_13);
3966};
3967#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 13
3968
3969
3970template <class MEMBER_TYPE, class CLASS_TYPE, class RET, class ARG0>
3971struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemDataPtr,
3972 RET(ARG0), MEMBER_TYPE CLASS_TYPE::*> {
3973 private:
3974 typedef MEMBER_TYPE CLASS_TYPE::* Func;
3975
3976 static RET invokeImp(bsl::true_type ,
3977 Func f,
3978 typename bslmf::ForwardingType<ARG0>::Type obj);
3979
3980 static RET invokeImp(bsl::false_type ,
3981 Func f,
3982 typename bslmf::ForwardingType<ARG0>::Type obj);
3983
3984 public:
3985
3986 static RET invoke(const Function_Rep *rep,
3987 typename bslmf::ForwardingType<ARG0>::Type obj);
3988};
3989
3990#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 0
3991template <class FUNC, class RET>
3992struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
3993 RET(), FUNC> {
3994
3995
3996 static RET invoke(const Function_Rep *rep);
3997};
3998#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 0
3999
4000#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 1
4001template <class FUNC, class RET, class ARGS_01>
4002struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4003 RET(ARGS_01), FUNC> {
4004
4005
4006 static RET invoke(const Function_Rep *rep,
4007 typename bslmf::ForwardingType<ARGS_01>::Type args_01);
4008};
4009#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 1
4010
4011#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 2
4012template <class FUNC, class RET, class ARGS_01,
4013 class ARGS_02>
4014struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4015 RET(ARGS_01,
4016 ARGS_02), FUNC> {
4017
4018
4019 static RET invoke(const Function_Rep *rep,
4020 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4021 typename bslmf::ForwardingType<ARGS_02>::Type args_02);
4022};
4023#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 2
4024
4025#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 3
4026template <class FUNC, class RET, class ARGS_01,
4027 class ARGS_02,
4028 class ARGS_03>
4029struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4030 RET(ARGS_01,
4031 ARGS_02,
4032 ARGS_03), FUNC> {
4033
4034
4035 static RET invoke(const Function_Rep *rep,
4036 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4037 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4038 typename bslmf::ForwardingType<ARGS_03>::Type args_03);
4039};
4040#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 3
4041
4042#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 4
4043template <class FUNC, class RET, class ARGS_01,
4044 class ARGS_02,
4045 class ARGS_03,
4046 class ARGS_04>
4047struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4048 RET(ARGS_01,
4049 ARGS_02,
4050 ARGS_03,
4051 ARGS_04), FUNC> {
4052
4053
4054 static RET invoke(const Function_Rep *rep,
4055 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4056 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4057 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4058 typename bslmf::ForwardingType<ARGS_04>::Type args_04);
4059};
4060#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 4
4061
4062#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 5
4063template <class FUNC, class RET, class ARGS_01,
4064 class ARGS_02,
4065 class ARGS_03,
4066 class ARGS_04,
4067 class ARGS_05>
4068struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4069 RET(ARGS_01,
4070 ARGS_02,
4071 ARGS_03,
4072 ARGS_04,
4073 ARGS_05), FUNC> {
4074
4075
4076 static RET invoke(const Function_Rep *rep,
4077 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4078 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4079 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4080 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4081 typename bslmf::ForwardingType<ARGS_05>::Type args_05);
4082};
4083#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 5
4084
4085#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 6
4086template <class FUNC, class RET, class ARGS_01,
4087 class ARGS_02,
4088 class ARGS_03,
4089 class ARGS_04,
4090 class ARGS_05,
4091 class ARGS_06>
4092struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4093 RET(ARGS_01,
4094 ARGS_02,
4095 ARGS_03,
4096 ARGS_04,
4097 ARGS_05,
4098 ARGS_06), FUNC> {
4099
4100
4101 static RET invoke(const Function_Rep *rep,
4102 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4103 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4104 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4105 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4106 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4107 typename bslmf::ForwardingType<ARGS_06>::Type args_06);
4108};
4109#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 6
4110
4111#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 7
4112template <class FUNC, class RET, class ARGS_01,
4113 class ARGS_02,
4114 class ARGS_03,
4115 class ARGS_04,
4116 class ARGS_05,
4117 class ARGS_06,
4118 class ARGS_07>
4119struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4120 RET(ARGS_01,
4121 ARGS_02,
4122 ARGS_03,
4123 ARGS_04,
4124 ARGS_05,
4125 ARGS_06,
4126 ARGS_07), FUNC> {
4127
4128
4129 static RET invoke(const Function_Rep *rep,
4130 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4131 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4132 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4133 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4134 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4135 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4136 typename bslmf::ForwardingType<ARGS_07>::Type args_07);
4137};
4138#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 7
4139
4140#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 8
4141template <class FUNC, class RET, class ARGS_01,
4142 class ARGS_02,
4143 class ARGS_03,
4144 class ARGS_04,
4145 class ARGS_05,
4146 class ARGS_06,
4147 class ARGS_07,
4148 class ARGS_08>
4149struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4150 RET(ARGS_01,
4151 ARGS_02,
4152 ARGS_03,
4153 ARGS_04,
4154 ARGS_05,
4155 ARGS_06,
4156 ARGS_07,
4157 ARGS_08), FUNC> {
4158
4159
4160 static RET invoke(const Function_Rep *rep,
4161 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4162 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4163 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4164 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4165 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4166 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4167 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4168 typename bslmf::ForwardingType<ARGS_08>::Type args_08);
4169};
4170#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 8
4171
4172#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 9
4173template <class FUNC, class RET, class ARGS_01,
4174 class ARGS_02,
4175 class ARGS_03,
4176 class ARGS_04,
4177 class ARGS_05,
4178 class ARGS_06,
4179 class ARGS_07,
4180 class ARGS_08,
4181 class ARGS_09>
4182struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4183 RET(ARGS_01,
4184 ARGS_02,
4185 ARGS_03,
4186 ARGS_04,
4187 ARGS_05,
4188 ARGS_06,
4189 ARGS_07,
4190 ARGS_08,
4191 ARGS_09), FUNC> {
4192
4193
4194 static RET invoke(const Function_Rep *rep,
4195 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4196 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4197 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4198 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4199 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4200 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4201 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4202 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4203 typename bslmf::ForwardingType<ARGS_09>::Type args_09);
4204};
4205#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 9
4206
4207#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 10
4208template <class FUNC, class RET, class ARGS_01,
4209 class ARGS_02,
4210 class ARGS_03,
4211 class ARGS_04,
4212 class ARGS_05,
4213 class ARGS_06,
4214 class ARGS_07,
4215 class ARGS_08,
4216 class ARGS_09,
4217 class ARGS_10>
4218struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4219 RET(ARGS_01,
4220 ARGS_02,
4221 ARGS_03,
4222 ARGS_04,
4223 ARGS_05,
4224 ARGS_06,
4225 ARGS_07,
4226 ARGS_08,
4227 ARGS_09,
4228 ARGS_10), FUNC> {
4229
4230
4231 static RET invoke(const Function_Rep *rep,
4232 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4233 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4234 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4235 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4236 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4237 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4238 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4239 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4240 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
4241 typename bslmf::ForwardingType<ARGS_10>::Type args_10);
4242};
4243#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 10
4244
4245#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 11
4246template <class FUNC, class RET, class ARGS_01,
4247 class ARGS_02,
4248 class ARGS_03,
4249 class ARGS_04,
4250 class ARGS_05,
4251 class ARGS_06,
4252 class ARGS_07,
4253 class ARGS_08,
4254 class ARGS_09,
4255 class ARGS_10,
4256 class ARGS_11>
4257struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4258 RET(ARGS_01,
4259 ARGS_02,
4260 ARGS_03,
4261 ARGS_04,
4262 ARGS_05,
4263 ARGS_06,
4264 ARGS_07,
4265 ARGS_08,
4266 ARGS_09,
4267 ARGS_10,
4268 ARGS_11), FUNC> {
4269
4270
4271 static RET invoke(const Function_Rep *rep,
4272 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4273 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4274 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4275 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4276 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4277 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4278 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4279 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4280 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
4281 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
4282 typename bslmf::ForwardingType<ARGS_11>::Type args_11);
4283};
4284#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 11
4285
4286#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 12
4287template <class FUNC, class RET, class ARGS_01,
4288 class ARGS_02,
4289 class ARGS_03,
4290 class ARGS_04,
4291 class ARGS_05,
4292 class ARGS_06,
4293 class ARGS_07,
4294 class ARGS_08,
4295 class ARGS_09,
4296 class ARGS_10,
4297 class ARGS_11,
4298 class ARGS_12>
4299struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4300 RET(ARGS_01,
4301 ARGS_02,
4302 ARGS_03,
4303 ARGS_04,
4304 ARGS_05,
4305 ARGS_06,
4306 ARGS_07,
4307 ARGS_08,
4308 ARGS_09,
4309 ARGS_10,
4310 ARGS_11,
4311 ARGS_12), FUNC> {
4312
4313
4314 static RET invoke(const Function_Rep *rep,
4315 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4316 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4317 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4318 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4319 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4320 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4321 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4322 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4323 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
4324 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
4325 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
4326 typename bslmf::ForwardingType<ARGS_12>::Type args_12);
4327};
4328#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 12
4329
4330#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 13
4331template <class FUNC, class RET, class ARGS_01,
4332 class ARGS_02,
4333 class ARGS_03,
4334 class ARGS_04,
4335 class ARGS_05,
4336 class ARGS_06,
4337 class ARGS_07,
4338 class ARGS_08,
4339 class ARGS_09,
4340 class ARGS_10,
4341 class ARGS_11,
4342 class ARGS_12,
4343 class ARGS_13>
4344struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4345 RET(ARGS_01,
4346 ARGS_02,
4347 ARGS_03,
4348 ARGS_04,
4349 ARGS_05,
4350 ARGS_06,
4351 ARGS_07,
4352 ARGS_08,
4353 ARGS_09,
4354 ARGS_10,
4355 ARGS_11,
4356 ARGS_12,
4357 ARGS_13), FUNC> {
4358
4359
4360 static RET invoke(const Function_Rep *rep,
4361 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4362 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4363 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4364 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4365 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4366 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4367 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4368 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4369 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
4370 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
4371 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
4372 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
4373 typename bslmf::ForwardingType<ARGS_13>::Type args_13);
4374};
4375#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 13
4376
4377
4378#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 0
4379template <class FUNC, class RET>
4380struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4381 RET(), FUNC> {
4382
4383
4384 static RET invoke(const Function_Rep *rep);
4385};
4386#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 0
4387
4388#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 1
4389template <class FUNC, class RET, class ARGS_01>
4390struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4391 RET(ARGS_01), FUNC> {
4392
4393
4394 static RET invoke(const Function_Rep *rep,
4395 typename bslmf::ForwardingType<ARGS_01>::Type args_01);
4396};
4397#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 1
4398
4399#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 2
4400template <class FUNC, class RET, class ARGS_01,
4401 class ARGS_02>
4402struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4403 RET(ARGS_01,
4404 ARGS_02), FUNC> {
4405
4406
4407 static RET invoke(const Function_Rep *rep,
4408 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4409 typename bslmf::ForwardingType<ARGS_02>::Type args_02);
4410};
4411#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 2
4412
4413#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 3
4414template <class FUNC, class RET, class ARGS_01,
4415 class ARGS_02,
4416 class ARGS_03>
4417struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4418 RET(ARGS_01,
4419 ARGS_02,
4420 ARGS_03), FUNC> {
4421
4422
4423 static RET invoke(const Function_Rep *rep,
4424 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4425 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4426 typename bslmf::ForwardingType<ARGS_03>::Type args_03);
4427};
4428#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 3
4429
4430#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 4
4431template <class FUNC, class RET, class ARGS_01,
4432 class ARGS_02,
4433 class ARGS_03,
4434 class ARGS_04>
4435struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4436 RET(ARGS_01,
4437 ARGS_02,
4438 ARGS_03,
4439 ARGS_04), FUNC> {
4440
4441
4442 static RET invoke(const Function_Rep *rep,
4443 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4444 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4445 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4446 typename bslmf::ForwardingType<ARGS_04>::Type args_04);
4447};
4448#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 4
4449
4450#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 5
4451template <class FUNC, class RET, class ARGS_01,
4452 class ARGS_02,
4453 class ARGS_03,
4454 class ARGS_04,
4455 class ARGS_05>
4456struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4457 RET(ARGS_01,
4458 ARGS_02,
4459 ARGS_03,
4460 ARGS_04,
4461 ARGS_05), FUNC> {
4462
4463
4464 static RET invoke(const Function_Rep *rep,
4465 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4466 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4467 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4468 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4469 typename bslmf::ForwardingType<ARGS_05>::Type args_05);
4470};
4471#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 5
4472
4473#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 6
4474template <class FUNC, class RET, class ARGS_01,
4475 class ARGS_02,
4476 class ARGS_03,
4477 class ARGS_04,
4478 class ARGS_05,
4479 class ARGS_06>
4480struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4481 RET(ARGS_01,
4482 ARGS_02,
4483 ARGS_03,
4484 ARGS_04,
4485 ARGS_05,
4486 ARGS_06), FUNC> {
4487
4488
4489 static RET invoke(const Function_Rep *rep,
4490 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4491 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4492 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4493 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4494 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4495 typename bslmf::ForwardingType<ARGS_06>::Type args_06);
4496};
4497#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 6
4498
4499#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 7
4500template <class FUNC, class RET, class ARGS_01,
4501 class ARGS_02,
4502 class ARGS_03,
4503 class ARGS_04,
4504 class ARGS_05,
4505 class ARGS_06,
4506 class ARGS_07>
4507struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4508 RET(ARGS_01,
4509 ARGS_02,
4510 ARGS_03,
4511 ARGS_04,
4512 ARGS_05,
4513 ARGS_06,
4514 ARGS_07), FUNC> {
4515
4516
4517 static RET invoke(const Function_Rep *rep,
4518 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4519 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4520 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4521 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4522 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4523 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4524 typename bslmf::ForwardingType<ARGS_07>::Type args_07);
4525};
4526#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 7
4527
4528#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 8
4529template <class FUNC, class RET, class ARGS_01,
4530 class ARGS_02,
4531 class ARGS_03,
4532 class ARGS_04,
4533 class ARGS_05,
4534 class ARGS_06,
4535 class ARGS_07,
4536 class ARGS_08>
4537struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4538 RET(ARGS_01,
4539 ARGS_02,
4540 ARGS_03,
4541 ARGS_04,
4542 ARGS_05,
4543 ARGS_06,
4544 ARGS_07,
4545 ARGS_08), FUNC> {
4546
4547
4548 static RET invoke(const Function_Rep *rep,
4549 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4550 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4551 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4552 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4553 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4554 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4555 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4556 typename bslmf::ForwardingType<ARGS_08>::Type args_08);
4557};
4558#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 8
4559
4560#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 9
4561template <class FUNC, class RET, class ARGS_01,
4562 class ARGS_02,
4563 class ARGS_03,
4564 class ARGS_04,
4565 class ARGS_05,
4566 class ARGS_06,
4567 class ARGS_07,
4568 class ARGS_08,
4569 class ARGS_09>
4570struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4571 RET(ARGS_01,
4572 ARGS_02,
4573 ARGS_03,
4574 ARGS_04,
4575 ARGS_05,
4576 ARGS_06,
4577 ARGS_07,
4578 ARGS_08,
4579 ARGS_09), FUNC> {
4580
4581
4582 static RET invoke(const Function_Rep *rep,
4583 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4584 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4585 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4586 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4587 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4588 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4589 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4590 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4591 typename bslmf::ForwardingType<ARGS_09>::Type args_09);
4592};
4593#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 9
4594
4595#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 10
4596template <class FUNC, class RET, class ARGS_01,
4597 class ARGS_02,
4598 class ARGS_03,
4599 class ARGS_04,
4600 class ARGS_05,
4601 class ARGS_06,
4602 class ARGS_07,
4603 class ARGS_08,
4604 class ARGS_09,
4605 class ARGS_10>
4606struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4607 RET(ARGS_01,
4608 ARGS_02,
4609 ARGS_03,
4610 ARGS_04,
4611 ARGS_05,
4612 ARGS_06,
4613 ARGS_07,
4614 ARGS_08,
4615 ARGS_09,
4616 ARGS_10), FUNC> {
4617
4618
4619 static RET invoke(const Function_Rep *rep,
4620 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4621 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4622 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4623 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4624 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4625 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4626 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4627 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4628 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
4629 typename bslmf::ForwardingType<ARGS_10>::Type args_10);
4630};
4631#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 10
4632
4633#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 11
4634template <class FUNC, class RET, class ARGS_01,
4635 class ARGS_02,
4636 class ARGS_03,
4637 class ARGS_04,
4638 class ARGS_05,
4639 class ARGS_06,
4640 class ARGS_07,
4641 class ARGS_08,
4642 class ARGS_09,
4643 class ARGS_10,
4644 class ARGS_11>
4645struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4646 RET(ARGS_01,
4647 ARGS_02,
4648 ARGS_03,
4649 ARGS_04,
4650 ARGS_05,
4651 ARGS_06,
4652 ARGS_07,
4653 ARGS_08,
4654 ARGS_09,
4655 ARGS_10,
4656 ARGS_11), FUNC> {
4657
4658
4659 static RET invoke(const Function_Rep *rep,
4660 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4661 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4662 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4663 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4664 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4665 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4666 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4667 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4668 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
4669 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
4670 typename bslmf::ForwardingType<ARGS_11>::Type args_11);
4671};
4672#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 11
4673
4674#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 12
4675template <class FUNC, class RET, class ARGS_01,
4676 class ARGS_02,
4677 class ARGS_03,
4678 class ARGS_04,
4679 class ARGS_05,
4680 class ARGS_06,
4681 class ARGS_07,
4682 class ARGS_08,
4683 class ARGS_09,
4684 class ARGS_10,
4685 class ARGS_11,
4686 class ARGS_12>
4687struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4688 RET(ARGS_01,
4689 ARGS_02,
4690 ARGS_03,
4691 ARGS_04,
4692 ARGS_05,
4693 ARGS_06,
4694 ARGS_07,
4695 ARGS_08,
4696 ARGS_09,
4697 ARGS_10,
4698 ARGS_11,
4699 ARGS_12), FUNC> {
4700
4701
4702 static RET invoke(const Function_Rep *rep,
4703 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4704 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4705 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4706 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4707 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4708 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4709 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4710 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4711 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
4712 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
4713 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
4714 typename bslmf::ForwardingType<ARGS_12>::Type args_12);
4715};
4716#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 12
4717
4718#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 13
4719template <class FUNC, class RET, class ARGS_01,
4720 class ARGS_02,
4721 class ARGS_03,
4722 class ARGS_04,
4723 class ARGS_05,
4724 class ARGS_06,
4725 class ARGS_07,
4726 class ARGS_08,
4727 class ARGS_09,
4728 class ARGS_10,
4729 class ARGS_11,
4730 class ARGS_12,
4731 class ARGS_13>
4732struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4733 RET(ARGS_01,
4734 ARGS_02,
4735 ARGS_03,
4736 ARGS_04,
4737 ARGS_05,
4738 ARGS_06,
4739 ARGS_07,
4740 ARGS_08,
4741 ARGS_09,
4742 ARGS_10,
4743 ARGS_11,
4744 ARGS_12,
4745 ARGS_13), FUNC> {
4746
4747
4748 static RET invoke(const Function_Rep *rep,
4749 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4750 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
4751 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
4752 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
4753 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
4754 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
4755 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
4756 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
4757 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
4758 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
4759 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
4760 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
4761 typename bslmf::ForwardingType<ARGS_13>::Type args_13);
4762};
4763#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_B >= 13
4764
4765#else
4766// The generated code below is a workaround for the absence of perfect
4767// forwarding in some compilers.
4768
4769
4770template <class FUNC, class RET, class... ARGS>
4771struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
4772 RET(ARGS...), FUNC> {
4773
4774
4775 static RET invoke(const Function_Rep *rep,
4776 typename bslmf::ForwardingType<ARGS>::Type... args);
4777};
4778
4779template <class FUNC, class RET, class ARG0, class... ARGS>
4780struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
4781 RET(ARG0, ARGS...), FUNC> {
4782
4783 private:
4784
4785 static RET invokeImp(bsl::true_type ,
4786 FUNC f,
4787 typename bslmf::ForwardingType<ARG0>::Type obj,
4788 typename bslmf::ForwardingType<ARGS>::Type... args);
4789
4790 static RET invokeImp(bsl::false_type ,
4791 FUNC f,
4792 typename bslmf::ForwardingType<ARG0>::Type obj,
4793 typename bslmf::ForwardingType<ARGS>::Type... args);
4794
4795 public:
4796
4797 static RET invoke(const Function_Rep *rep,
4798 typename bslmf::ForwardingType<ARG0>::Type obj,
4799 typename bslmf::ForwardingType<ARGS>::Type... args);
4800};
4801
4802template <class MEMBER_TYPE, class CLASS_TYPE, class RET, class ARG0>
4803struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemDataPtr,
4804 RET(ARG0), MEMBER_TYPE CLASS_TYPE::*> {
4805 private:
4806 typedef MEMBER_TYPE CLASS_TYPE::* Func;
4807
4808 static RET invokeImp(bsl::true_type ,
4809 Func f,
4810 typename bslmf::ForwardingType<ARG0>::Type obj);
4811
4812 static RET invokeImp(bsl::false_type ,
4813 Func f,
4814 typename bslmf::ForwardingType<ARG0>::Type obj);
4815
4816 public:
4817
4818 static RET invoke(const Function_Rep *rep,
4819 typename bslmf::ForwardingType<ARG0>::Type obj);
4820};
4821
4822template <class FUNC, class RET, class... ARGS>
4823struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
4824 RET(ARGS...), FUNC> {
4825
4826
4827 static RET invoke(const Function_Rep *rep,
4828 typename bslmf::ForwardingType<ARGS>::Type... args);
4829};
4830
4831template <class FUNC, class RET, class... ARGS>
4832struct Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
4833 RET(ARGS...), FUNC> {
4834
4835
4836 static RET invoke(const Function_Rep *rep,
4837 typename bslmf::ForwardingType<ARGS>::Type... args);
4838};
4839
4840// }}} END GENERATED CODE
4841#endif
4842
4843// ===========================================================================
4844// TEMPLATE AND INLINE FUNCTION IMPLEMENTATIONS
4845// ===========================================================================
4846
4847 // ---------------------------
4848 // struct Function_InvokerUtil
4849 // ---------------------------
4850
4851template <class PROTOTYPE>
4852inline
4853bslstl::Function_InvokerUtil::GenericInvoker *
4854bslstl::Function_InvokerUtil::invokerForFunc(const bsl::nullptr_t&)
4855{
4856 return 0;
4857}
4858
4859template <class PROTOTYPE, class FUNC>
4860bslstl::Function_InvokerUtil::GenericInvoker *
4861bslstl::Function_InvokerUtil::invokerForFunc(const FUNC& f)
4862{
4863 typedef bslstl::Function_SmallObjectOptimization Soo;
4864
4865 // Strip 'NothrowMovableWrapper' (if any) off of 'FUNC' type.
4866 typedef typename
4867 bslalg::NothrowMovableUtil::UnwrappedType<FUNC>::type UwFuncType;
4868
4869 // Categorize the type of invocable corresponding to 'FUNC'. Note that the
4870 // parameter to 'Soo::Inplace' is 'FUNC', not 'UwFuncType'. That is
4871 // because 'Soo::Inplace' takes the wrapper into account when determining
4872 // whether the type should be inplace or not.
4873 static const int k_INVOCATION_TYPE =
4874 bslmf::IsFunctionPointer<UwFuncType>::value ? e_FunctionPtr :
4875 bslmf::IsMemberFunctionPointer<UwFuncType>::value ? e_MemFunctionPtr :
4876 bsl::is_member_pointer<UwFuncType>::value ? e_MemDataPtr :
4877 Soo::IsInplaceFunc<FUNC>::value ? e_InplaceFunctor :
4878 e_OutofplaceFunctor;
4879
4880 // Instantiate the class for checking for null object
4881 typedef Function_InvokerUtilNullCheck<UwFuncType> NullCheckerClass;
4882
4883 // Instantiate the class for dispatching the invoker
4884 typedef Function_InvokerUtil_Dispatch<k_INVOCATION_TYPE,
4885 PROTOTYPE,
4886 UwFuncType> DispatcherClass;
4887
4888 // If a the object is "null", e.g., for a pointer, then return null.
4889 if (NullCheckerClass::isNull(bslalg::NothrowMovableUtil::unwrap(f)))
4890 {
4891 return 0; // RETURN
4892 }
4893
4894 // Verify the assumption that all function pointers are the same size.
4895 BSLMF_ASSERT(sizeof(&DispatcherClass::invoke) ==
4896 sizeof(Function_Rep::GenericInvoker *));
4897
4898 // Return a pointer to the actual invoker function
4899 return reinterpret_cast<Function_Rep::GenericInvoker *>(
4900 &DispatcherClass::invoke);
4901}
4902
4903 // ---------------------------------------------
4904 // struct template Function_InvokerUtilNullCheck
4905 // ---------------------------------------------
4906
4907// STATIC MEMBER FUNCTIONS
4908
4909template <class FUNC>
4910inline
4911bool Function_InvokerUtilNullCheck<FUNC>::isNull(const FUNC&)
4912{
4913 return false;
4914}
4915
4916template <class FUNC>
4917inline
4918bool Function_InvokerUtilNullCheck<FUNC *>::isNull(FUNC* f)
4919{
4920 return 0 == f;
4921}
4922
4923template <class CLASS, class MEMTYPE>
4924inline
4925bool
4926Function_InvokerUtilNullCheck<MEMTYPE CLASS::*>::isNull(MEMTYPE CLASS::* f)
4927{
4928 return 0 == f;
4929}
4930
4931
4932 // ---------------------------------------------
4933 // struct template Function_InvokerUtil_Dispatch
4934 // ---------------------------------------------
4935
4936#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
4937// {{{ BEGIN GENERATED CODE
4938// Command line: sim_cpp11_features.pl bslstl_function_invokerutil.h
4939#ifndef BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT
4940#define BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT 13
4941#endif
4942#ifndef BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C
4943#define BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT
4944#endif
4945
4946#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
4947template <class FUNC, class RET>
4948RET
4949Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
4950 RET(), FUNC>::
4951invoke(const Function_Rep *rep)
4952{
4953 FUNC f = *rep->targetRaw<FUNC, true>();
4954
4955
4956 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
4957 RET,
4958 f());
4959}
4960#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
4961
4962#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
4963template <class FUNC, class RET, class ARGS_01>
4964RET
4965Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
4966 RET(ARGS_01), FUNC>::
4967invoke(const Function_Rep *rep,
4968 typename bslmf::ForwardingType<ARGS_01>::Type args_01)
4969{
4970 FUNC f = *rep->targetRaw<FUNC, true>();
4971
4972
4973 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
4974 RET,
4975 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01)));
4976}
4977#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
4978
4979#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
4980template <class FUNC, class RET, class ARGS_01,
4981 class ARGS_02>
4982RET
4983Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
4984 RET(ARGS_01,
4985 ARGS_02), FUNC>::
4986invoke(const Function_Rep *rep,
4987 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
4988 typename bslmf::ForwardingType<ARGS_02>::Type args_02)
4989{
4990 FUNC f = *rep->targetRaw<FUNC, true>();
4991
4992
4993 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
4994 RET,
4995 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
4996 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02)));
4997}
4998#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
4999
5000#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
5001template <class FUNC, class RET, class ARGS_01,
5002 class ARGS_02,
5003 class ARGS_03>
5004RET
5005Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5006 RET(ARGS_01,
5007 ARGS_02,
5008 ARGS_03), FUNC>::
5009invoke(const Function_Rep *rep,
5010 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5011 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5012 typename bslmf::ForwardingType<ARGS_03>::Type args_03)
5013{
5014 FUNC f = *rep->targetRaw<FUNC, true>();
5015
5016
5017 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5018 RET,
5019 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5020 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5021 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03)));
5022}
5023#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
5024
5025#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
5026template <class FUNC, class RET, class ARGS_01,
5027 class ARGS_02,
5028 class ARGS_03,
5029 class ARGS_04>
5030RET
5031Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5032 RET(ARGS_01,
5033 ARGS_02,
5034 ARGS_03,
5035 ARGS_04), FUNC>::
5036invoke(const Function_Rep *rep,
5037 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5038 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5039 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5040 typename bslmf::ForwardingType<ARGS_04>::Type args_04)
5041{
5042 FUNC f = *rep->targetRaw<FUNC, true>();
5043
5044
5045 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5046 RET,
5047 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5048 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5049 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5050 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04)));
5051}
5052#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
5053
5054#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
5055template <class FUNC, class RET, class ARGS_01,
5056 class ARGS_02,
5057 class ARGS_03,
5058 class ARGS_04,
5059 class ARGS_05>
5060RET
5061Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5062 RET(ARGS_01,
5063 ARGS_02,
5064 ARGS_03,
5065 ARGS_04,
5066 ARGS_05), FUNC>::
5067invoke(const Function_Rep *rep,
5068 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5069 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5070 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5071 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5072 typename bslmf::ForwardingType<ARGS_05>::Type args_05)
5073{
5074 FUNC f = *rep->targetRaw<FUNC, true>();
5075
5076
5077 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5078 RET,
5079 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5080 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5081 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5082 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5083 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05)));
5084}
5085#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
5086
5087#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
5088template <class FUNC, class RET, class ARGS_01,
5089 class ARGS_02,
5090 class ARGS_03,
5091 class ARGS_04,
5092 class ARGS_05,
5093 class ARGS_06>
5094RET
5095Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5096 RET(ARGS_01,
5097 ARGS_02,
5098 ARGS_03,
5099 ARGS_04,
5100 ARGS_05,
5101 ARGS_06), FUNC>::
5102invoke(const Function_Rep *rep,
5103 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5104 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5105 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5106 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5107 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5108 typename bslmf::ForwardingType<ARGS_06>::Type args_06)
5109{
5110 FUNC f = *rep->targetRaw<FUNC, true>();
5111
5112
5113 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5114 RET,
5115 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5116 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5117 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5118 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5119 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5120 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06)));
5121}
5122#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
5123
5124#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
5125template <class FUNC, class RET, class ARGS_01,
5126 class ARGS_02,
5127 class ARGS_03,
5128 class ARGS_04,
5129 class ARGS_05,
5130 class ARGS_06,
5131 class ARGS_07>
5132RET
5133Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5134 RET(ARGS_01,
5135 ARGS_02,
5136 ARGS_03,
5137 ARGS_04,
5138 ARGS_05,
5139 ARGS_06,
5140 ARGS_07), FUNC>::
5141invoke(const Function_Rep *rep,
5142 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5143 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5144 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5145 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5146 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5147 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5148 typename bslmf::ForwardingType<ARGS_07>::Type args_07)
5149{
5150 FUNC f = *rep->targetRaw<FUNC, true>();
5151
5152
5153 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5154 RET,
5155 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5156 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5157 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5158 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5159 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5160 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5161 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07)));
5162}
5163#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
5164
5165#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
5166template <class FUNC, class RET, class ARGS_01,
5167 class ARGS_02,
5168 class ARGS_03,
5169 class ARGS_04,
5170 class ARGS_05,
5171 class ARGS_06,
5172 class ARGS_07,
5173 class ARGS_08>
5174RET
5175Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5176 RET(ARGS_01,
5177 ARGS_02,
5178 ARGS_03,
5179 ARGS_04,
5180 ARGS_05,
5181 ARGS_06,
5182 ARGS_07,
5183 ARGS_08), FUNC>::
5184invoke(const Function_Rep *rep,
5185 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5186 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5187 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5188 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5189 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5190 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5191 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5192 typename bslmf::ForwardingType<ARGS_08>::Type args_08)
5193{
5194 FUNC f = *rep->targetRaw<FUNC, true>();
5195
5196
5197 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5198 RET,
5199 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5200 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5201 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5202 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5203 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5204 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5205 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5206 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08)));
5207}
5208#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
5209
5210#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
5211template <class FUNC, class RET, class ARGS_01,
5212 class ARGS_02,
5213 class ARGS_03,
5214 class ARGS_04,
5215 class ARGS_05,
5216 class ARGS_06,
5217 class ARGS_07,
5218 class ARGS_08,
5219 class ARGS_09>
5220RET
5221Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5222 RET(ARGS_01,
5223 ARGS_02,
5224 ARGS_03,
5225 ARGS_04,
5226 ARGS_05,
5227 ARGS_06,
5228 ARGS_07,
5229 ARGS_08,
5230 ARGS_09), FUNC>::
5231invoke(const Function_Rep *rep,
5232 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5233 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5234 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5235 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5236 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5237 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5238 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5239 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
5240 typename bslmf::ForwardingType<ARGS_09>::Type args_09)
5241{
5242 FUNC f = *rep->targetRaw<FUNC, true>();
5243
5244
5245 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5246 RET,
5247 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5248 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5249 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5250 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5251 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5252 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5253 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5254 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
5255 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09)));
5256}
5257#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
5258
5259#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
5260template <class FUNC, class RET, class ARGS_01,
5261 class ARGS_02,
5262 class ARGS_03,
5263 class ARGS_04,
5264 class ARGS_05,
5265 class ARGS_06,
5266 class ARGS_07,
5267 class ARGS_08,
5268 class ARGS_09,
5269 class ARGS_10>
5270RET
5271Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5272 RET(ARGS_01,
5273 ARGS_02,
5274 ARGS_03,
5275 ARGS_04,
5276 ARGS_05,
5277 ARGS_06,
5278 ARGS_07,
5279 ARGS_08,
5280 ARGS_09,
5281 ARGS_10), FUNC>::
5282invoke(const Function_Rep *rep,
5283 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5284 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5285 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5286 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5287 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5288 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5289 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5290 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
5291 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
5292 typename bslmf::ForwardingType<ARGS_10>::Type args_10)
5293{
5294 FUNC f = *rep->targetRaw<FUNC, true>();
5295
5296
5297 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5298 RET,
5299 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5300 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5301 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5302 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5303 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5304 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5305 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5306 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
5307 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
5308 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10)));
5309}
5310#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
5311
5312#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
5313template <class FUNC, class RET, class ARGS_01,
5314 class ARGS_02,
5315 class ARGS_03,
5316 class ARGS_04,
5317 class ARGS_05,
5318 class ARGS_06,
5319 class ARGS_07,
5320 class ARGS_08,
5321 class ARGS_09,
5322 class ARGS_10,
5323 class ARGS_11>
5324RET
5325Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5326 RET(ARGS_01,
5327 ARGS_02,
5328 ARGS_03,
5329 ARGS_04,
5330 ARGS_05,
5331 ARGS_06,
5332 ARGS_07,
5333 ARGS_08,
5334 ARGS_09,
5335 ARGS_10,
5336 ARGS_11), FUNC>::
5337invoke(const Function_Rep *rep,
5338 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5339 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5340 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5341 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5342 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5343 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5344 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5345 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
5346 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
5347 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
5348 typename bslmf::ForwardingType<ARGS_11>::Type args_11)
5349{
5350 FUNC f = *rep->targetRaw<FUNC, true>();
5351
5352
5353 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5354 RET,
5355 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5356 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5357 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5358 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5359 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5360 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5361 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5362 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
5363 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
5364 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
5365 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11)));
5366}
5367#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
5368
5369#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
5370template <class FUNC, class RET, class ARGS_01,
5371 class ARGS_02,
5372 class ARGS_03,
5373 class ARGS_04,
5374 class ARGS_05,
5375 class ARGS_06,
5376 class ARGS_07,
5377 class ARGS_08,
5378 class ARGS_09,
5379 class ARGS_10,
5380 class ARGS_11,
5381 class ARGS_12>
5382RET
5383Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5384 RET(ARGS_01,
5385 ARGS_02,
5386 ARGS_03,
5387 ARGS_04,
5388 ARGS_05,
5389 ARGS_06,
5390 ARGS_07,
5391 ARGS_08,
5392 ARGS_09,
5393 ARGS_10,
5394 ARGS_11,
5395 ARGS_12), FUNC>::
5396invoke(const Function_Rep *rep,
5397 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5398 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5399 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5400 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5401 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5402 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5403 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5404 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
5405 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
5406 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
5407 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
5408 typename bslmf::ForwardingType<ARGS_12>::Type args_12)
5409{
5410 FUNC f = *rep->targetRaw<FUNC, true>();
5411
5412
5413 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5414 RET,
5415 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5416 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5417 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5418 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5419 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5420 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5421 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5422 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
5423 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
5424 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
5425 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
5426 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12)));
5427}
5428#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
5429
5430#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
5431template <class FUNC, class RET, class ARGS_01,
5432 class ARGS_02,
5433 class ARGS_03,
5434 class ARGS_04,
5435 class ARGS_05,
5436 class ARGS_06,
5437 class ARGS_07,
5438 class ARGS_08,
5439 class ARGS_09,
5440 class ARGS_10,
5441 class ARGS_11,
5442 class ARGS_12,
5443 class ARGS_13>
5444RET
5445Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
5446 RET(ARGS_01,
5447 ARGS_02,
5448 ARGS_03,
5449 ARGS_04,
5450 ARGS_05,
5451 ARGS_06,
5452 ARGS_07,
5453 ARGS_08,
5454 ARGS_09,
5455 ARGS_10,
5456 ARGS_11,
5457 ARGS_12,
5458 ARGS_13), FUNC>::
5459invoke(const Function_Rep *rep,
5460 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5461 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5462 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5463 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5464 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5465 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5466 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5467 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
5468 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
5469 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
5470 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
5471 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
5472 typename bslmf::ForwardingType<ARGS_13>::Type args_13)
5473{
5474 FUNC f = *rep->targetRaw<FUNC, true>();
5475
5476
5477 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5478 RET,
5479 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5480 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5481 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5482 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5483 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5484 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5485 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5486 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
5487 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
5488 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
5489 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
5490 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12),
5491 bslmf::ForwardingTypeUtil<ARGS_13>::forwardToTarget(args_13)));
5492}
5493#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
5494
5495
5496#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
5497template <class FUNC, class RET, class ARG0>
5498inline
5499RET
5500Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5501 RET(ARG0), FUNC>::
5502invokeImp(bsl::true_type ,
5503 FUNC f,
5504 typename bslmf::ForwardingType<ARG0>::Type obj)
5505{
5506 typedef typename
5507 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5508
5509 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5510 RET, (const_cast<Arg0Ref>(obj).*f)(
5511 ));
5512}
5513#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
5514
5515#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
5516template <class FUNC, class RET, class ARG0, class ARGS_01>
5517inline
5518RET
5519Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5520 RET(ARG0, ARGS_01), FUNC>::
5521invokeImp(bsl::true_type ,
5522 FUNC f,
5523 typename bslmf::ForwardingType<ARG0>::Type obj,
5524 typename bslmf::ForwardingType<ARGS_01>::Type args_01)
5525{
5526 typedef typename
5527 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5528
5529 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5530 RET, (const_cast<Arg0Ref>(obj).*f)(
5531 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01)));
5532}
5533#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
5534
5535#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
5536template <class FUNC, class RET, class ARG0, class ARGS_01,
5537 class ARGS_02>
5538inline
5539RET
5540Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5541 RET(ARG0, ARGS_01,
5542 ARGS_02), FUNC>::
5543invokeImp(bsl::true_type ,
5544 FUNC f,
5545 typename bslmf::ForwardingType<ARG0>::Type obj,
5546 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5547 typename bslmf::ForwardingType<ARGS_02>::Type args_02)
5548{
5549 typedef typename
5550 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5551
5552 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5553 RET, (const_cast<Arg0Ref>(obj).*f)(
5554 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5555 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02)));
5556}
5557#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
5558
5559#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
5560template <class FUNC, class RET, class ARG0, class ARGS_01,
5561 class ARGS_02,
5562 class ARGS_03>
5563inline
5564RET
5565Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5566 RET(ARG0, ARGS_01,
5567 ARGS_02,
5568 ARGS_03), FUNC>::
5569invokeImp(bsl::true_type ,
5570 FUNC f,
5571 typename bslmf::ForwardingType<ARG0>::Type obj,
5572 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5573 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5574 typename bslmf::ForwardingType<ARGS_03>::Type args_03)
5575{
5576 typedef typename
5577 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5578
5579 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5580 RET, (const_cast<Arg0Ref>(obj).*f)(
5581 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5582 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5583 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03)));
5584}
5585#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
5586
5587#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
5588template <class FUNC, class RET, class ARG0, class ARGS_01,
5589 class ARGS_02,
5590 class ARGS_03,
5591 class ARGS_04>
5592inline
5593RET
5594Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5595 RET(ARG0, ARGS_01,
5596 ARGS_02,
5597 ARGS_03,
5598 ARGS_04), FUNC>::
5599invokeImp(bsl::true_type ,
5600 FUNC f,
5601 typename bslmf::ForwardingType<ARG0>::Type obj,
5602 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5603 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5604 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5605 typename bslmf::ForwardingType<ARGS_04>::Type args_04)
5606{
5607 typedef typename
5608 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5609
5610 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5611 RET, (const_cast<Arg0Ref>(obj).*f)(
5612 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5613 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5614 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5615 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04)));
5616}
5617#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
5618
5619#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
5620template <class FUNC, class RET, class ARG0, class ARGS_01,
5621 class ARGS_02,
5622 class ARGS_03,
5623 class ARGS_04,
5624 class ARGS_05>
5625inline
5626RET
5627Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5628 RET(ARG0, ARGS_01,
5629 ARGS_02,
5630 ARGS_03,
5631 ARGS_04,
5632 ARGS_05), FUNC>::
5633invokeImp(bsl::true_type ,
5634 FUNC f,
5635 typename bslmf::ForwardingType<ARG0>::Type obj,
5636 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5637 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5638 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5639 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5640 typename bslmf::ForwardingType<ARGS_05>::Type args_05)
5641{
5642 typedef typename
5643 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5644
5645 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5646 RET, (const_cast<Arg0Ref>(obj).*f)(
5647 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5648 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5649 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5650 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5651 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05)));
5652}
5653#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
5654
5655#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
5656template <class FUNC, class RET, class ARG0, class ARGS_01,
5657 class ARGS_02,
5658 class ARGS_03,
5659 class ARGS_04,
5660 class ARGS_05,
5661 class ARGS_06>
5662inline
5663RET
5664Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5665 RET(ARG0, ARGS_01,
5666 ARGS_02,
5667 ARGS_03,
5668 ARGS_04,
5669 ARGS_05,
5670 ARGS_06), FUNC>::
5671invokeImp(bsl::true_type ,
5672 FUNC f,
5673 typename bslmf::ForwardingType<ARG0>::Type obj,
5674 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5675 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5676 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5677 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5678 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5679 typename bslmf::ForwardingType<ARGS_06>::Type args_06)
5680{
5681 typedef typename
5682 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5683
5684 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5685 RET, (const_cast<Arg0Ref>(obj).*f)(
5686 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5687 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5688 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5689 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5690 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5691 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06)));
5692}
5693#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
5694
5695#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
5696template <class FUNC, class RET, class ARG0, class ARGS_01,
5697 class ARGS_02,
5698 class ARGS_03,
5699 class ARGS_04,
5700 class ARGS_05,
5701 class ARGS_06,
5702 class ARGS_07>
5703inline
5704RET
5705Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5706 RET(ARG0, ARGS_01,
5707 ARGS_02,
5708 ARGS_03,
5709 ARGS_04,
5710 ARGS_05,
5711 ARGS_06,
5712 ARGS_07), FUNC>::
5713invokeImp(bsl::true_type ,
5714 FUNC f,
5715 typename bslmf::ForwardingType<ARG0>::Type obj,
5716 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5717 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5718 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5719 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5720 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5721 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5722 typename bslmf::ForwardingType<ARGS_07>::Type args_07)
5723{
5724 typedef typename
5725 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5726
5727 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5728 RET, (const_cast<Arg0Ref>(obj).*f)(
5729 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5730 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5731 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5732 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5733 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5734 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5735 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07)));
5736}
5737#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
5738
5739#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
5740template <class FUNC, class RET, class ARG0, class ARGS_01,
5741 class ARGS_02,
5742 class ARGS_03,
5743 class ARGS_04,
5744 class ARGS_05,
5745 class ARGS_06,
5746 class ARGS_07,
5747 class ARGS_08>
5748inline
5749RET
5750Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5751 RET(ARG0, ARGS_01,
5752 ARGS_02,
5753 ARGS_03,
5754 ARGS_04,
5755 ARGS_05,
5756 ARGS_06,
5757 ARGS_07,
5758 ARGS_08), FUNC>::
5759invokeImp(bsl::true_type ,
5760 FUNC f,
5761 typename bslmf::ForwardingType<ARG0>::Type obj,
5762 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5763 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5764 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5765 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5766 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5767 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5768 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5769 typename bslmf::ForwardingType<ARGS_08>::Type args_08)
5770{
5771 typedef typename
5772 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5773
5774 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5775 RET, (const_cast<Arg0Ref>(obj).*f)(
5776 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5777 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5778 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5779 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5780 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5781 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5782 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5783 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08)));
5784}
5785#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
5786
5787#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
5788template <class FUNC, class RET, class ARG0, class ARGS_01,
5789 class ARGS_02,
5790 class ARGS_03,
5791 class ARGS_04,
5792 class ARGS_05,
5793 class ARGS_06,
5794 class ARGS_07,
5795 class ARGS_08,
5796 class ARGS_09>
5797inline
5798RET
5799Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5800 RET(ARG0, ARGS_01,
5801 ARGS_02,
5802 ARGS_03,
5803 ARGS_04,
5804 ARGS_05,
5805 ARGS_06,
5806 ARGS_07,
5807 ARGS_08,
5808 ARGS_09), FUNC>::
5809invokeImp(bsl::true_type ,
5810 FUNC f,
5811 typename bslmf::ForwardingType<ARG0>::Type obj,
5812 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5813 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5814 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5815 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5816 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5817 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5818 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5819 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
5820 typename bslmf::ForwardingType<ARGS_09>::Type args_09)
5821{
5822 typedef typename
5823 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5824
5825 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5826 RET, (const_cast<Arg0Ref>(obj).*f)(
5827 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5828 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5829 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5830 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5831 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5832 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5833 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5834 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
5835 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09)));
5836}
5837#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
5838
5839#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
5840template <class FUNC, class RET, class ARG0, class ARGS_01,
5841 class ARGS_02,
5842 class ARGS_03,
5843 class ARGS_04,
5844 class ARGS_05,
5845 class ARGS_06,
5846 class ARGS_07,
5847 class ARGS_08,
5848 class ARGS_09,
5849 class ARGS_10>
5850inline
5851RET
5852Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5853 RET(ARG0, ARGS_01,
5854 ARGS_02,
5855 ARGS_03,
5856 ARGS_04,
5857 ARGS_05,
5858 ARGS_06,
5859 ARGS_07,
5860 ARGS_08,
5861 ARGS_09,
5862 ARGS_10), FUNC>::
5863invokeImp(bsl::true_type ,
5864 FUNC f,
5865 typename bslmf::ForwardingType<ARG0>::Type obj,
5866 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5867 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5868 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5869 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5870 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5871 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5872 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5873 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
5874 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
5875 typename bslmf::ForwardingType<ARGS_10>::Type args_10)
5876{
5877 typedef typename
5878 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5879
5880 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5881 RET, (const_cast<Arg0Ref>(obj).*f)(
5882 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5883 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5884 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5885 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5886 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5887 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5888 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5889 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
5890 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
5891 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10)));
5892}
5893#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
5894
5895#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
5896template <class FUNC, class RET, class ARG0, class ARGS_01,
5897 class ARGS_02,
5898 class ARGS_03,
5899 class ARGS_04,
5900 class ARGS_05,
5901 class ARGS_06,
5902 class ARGS_07,
5903 class ARGS_08,
5904 class ARGS_09,
5905 class ARGS_10,
5906 class ARGS_11>
5907inline
5908RET
5909Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5910 RET(ARG0, ARGS_01,
5911 ARGS_02,
5912 ARGS_03,
5913 ARGS_04,
5914 ARGS_05,
5915 ARGS_06,
5916 ARGS_07,
5917 ARGS_08,
5918 ARGS_09,
5919 ARGS_10,
5920 ARGS_11), FUNC>::
5921invokeImp(bsl::true_type ,
5922 FUNC f,
5923 typename bslmf::ForwardingType<ARG0>::Type obj,
5924 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5925 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5926 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5927 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5928 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5929 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5930 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5931 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
5932 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
5933 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
5934 typename bslmf::ForwardingType<ARGS_11>::Type args_11)
5935{
5936 typedef typename
5937 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
5938
5939 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
5940 RET, (const_cast<Arg0Ref>(obj).*f)(
5941 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
5942 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
5943 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
5944 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
5945 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
5946 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
5947 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
5948 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
5949 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
5950 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
5951 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11)));
5952}
5953#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
5954
5955#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
5956template <class FUNC, class RET, class ARG0, class ARGS_01,
5957 class ARGS_02,
5958 class ARGS_03,
5959 class ARGS_04,
5960 class ARGS_05,
5961 class ARGS_06,
5962 class ARGS_07,
5963 class ARGS_08,
5964 class ARGS_09,
5965 class ARGS_10,
5966 class ARGS_11,
5967 class ARGS_12>
5968inline
5969RET
5970Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
5971 RET(ARG0, ARGS_01,
5972 ARGS_02,
5973 ARGS_03,
5974 ARGS_04,
5975 ARGS_05,
5976 ARGS_06,
5977 ARGS_07,
5978 ARGS_08,
5979 ARGS_09,
5980 ARGS_10,
5981 ARGS_11,
5982 ARGS_12), FUNC>::
5983invokeImp(bsl::true_type ,
5984 FUNC f,
5985 typename bslmf::ForwardingType<ARG0>::Type obj,
5986 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
5987 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
5988 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
5989 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
5990 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
5991 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
5992 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
5993 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
5994 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
5995 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
5996 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
5997 typename bslmf::ForwardingType<ARGS_12>::Type args_12)
5998{
5999 typedef typename
6000 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6001
6002 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6003 RET, (const_cast<Arg0Ref>(obj).*f)(
6004 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6005 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6006 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6007 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6008 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6009 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
6010 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
6011 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
6012 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
6013 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
6014 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
6015 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12)));
6016}
6017#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
6018
6019#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
6020template <class FUNC, class RET, class ARG0, class ARGS_01,
6021 class ARGS_02,
6022 class ARGS_03,
6023 class ARGS_04,
6024 class ARGS_05,
6025 class ARGS_06,
6026 class ARGS_07,
6027 class ARGS_08,
6028 class ARGS_09,
6029 class ARGS_10,
6030 class ARGS_11,
6031 class ARGS_12,
6032 class ARGS_13>
6033inline
6034RET
6035Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6036 RET(ARG0, ARGS_01,
6037 ARGS_02,
6038 ARGS_03,
6039 ARGS_04,
6040 ARGS_05,
6041 ARGS_06,
6042 ARGS_07,
6043 ARGS_08,
6044 ARGS_09,
6045 ARGS_10,
6046 ARGS_11,
6047 ARGS_12,
6048 ARGS_13), FUNC>::
6049invokeImp(bsl::true_type ,
6050 FUNC f,
6051 typename bslmf::ForwardingType<ARG0>::Type obj,
6052 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6053 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6054 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6055 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6056 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6057 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6058 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
6059 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
6060 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
6061 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
6062 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
6063 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
6064 typename bslmf::ForwardingType<ARGS_13>::Type args_13)
6065{
6066 typedef typename
6067 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6068
6069 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6070 RET, (const_cast<Arg0Ref>(obj).*f)(
6071 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6072 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6073 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6074 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6075 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6076 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
6077 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
6078 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
6079 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
6080 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
6081 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
6082 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12),
6083 bslmf::ForwardingTypeUtil<ARGS_13>::forwardToTarget(args_13)));
6084}
6085#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
6086
6087
6088#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
6089template <class FUNC, class RET, class ARG0>
6090inline
6091RET
6092Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6093 RET(ARG0), FUNC>::
6094invokeImp(bsl::false_type ,
6095 FUNC f,
6096 typename bslmf::ForwardingType<ARG0>::Type obj)
6097{
6098 typedef typename
6099 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6100
6101 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6102 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6103 ));
6104}
6105#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
6106
6107#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
6108template <class FUNC, class RET, class ARG0, class ARGS_01>
6109inline
6110RET
6111Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6112 RET(ARG0, ARGS_01), FUNC>::
6113invokeImp(bsl::false_type ,
6114 FUNC f,
6115 typename bslmf::ForwardingType<ARG0>::Type obj,
6116 typename bslmf::ForwardingType<ARGS_01>::Type args_01)
6117{
6118 typedef typename
6119 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6120
6121 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6122 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6123 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01)));
6124}
6125#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
6126
6127#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
6128template <class FUNC, class RET, class ARG0, class ARGS_01,
6129 class ARGS_02>
6130inline
6131RET
6132Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6133 RET(ARG0, ARGS_01,
6134 ARGS_02), FUNC>::
6135invokeImp(bsl::false_type ,
6136 FUNC f,
6137 typename bslmf::ForwardingType<ARG0>::Type obj,
6138 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6139 typename bslmf::ForwardingType<ARGS_02>::Type args_02)
6140{
6141 typedef typename
6142 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6143
6144 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6145 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6146 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6147 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02)));
6148}
6149#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
6150
6151#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
6152template <class FUNC, class RET, class ARG0, class ARGS_01,
6153 class ARGS_02,
6154 class ARGS_03>
6155inline
6156RET
6157Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6158 RET(ARG0, ARGS_01,
6159 ARGS_02,
6160 ARGS_03), FUNC>::
6161invokeImp(bsl::false_type ,
6162 FUNC f,
6163 typename bslmf::ForwardingType<ARG0>::Type obj,
6164 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6165 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6166 typename bslmf::ForwardingType<ARGS_03>::Type args_03)
6167{
6168 typedef typename
6169 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6170
6171 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6172 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6173 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6174 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6175 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03)));
6176}
6177#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
6178
6179#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
6180template <class FUNC, class RET, class ARG0, class ARGS_01,
6181 class ARGS_02,
6182 class ARGS_03,
6183 class ARGS_04>
6184inline
6185RET
6186Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6187 RET(ARG0, ARGS_01,
6188 ARGS_02,
6189 ARGS_03,
6190 ARGS_04), FUNC>::
6191invokeImp(bsl::false_type ,
6192 FUNC f,
6193 typename bslmf::ForwardingType<ARG0>::Type obj,
6194 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6195 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6196 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6197 typename bslmf::ForwardingType<ARGS_04>::Type args_04)
6198{
6199 typedef typename
6200 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6201
6202 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6203 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6204 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6205 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6206 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6207 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04)));
6208}
6209#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
6210
6211#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
6212template <class FUNC, class RET, class ARG0, class ARGS_01,
6213 class ARGS_02,
6214 class ARGS_03,
6215 class ARGS_04,
6216 class ARGS_05>
6217inline
6218RET
6219Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6220 RET(ARG0, ARGS_01,
6221 ARGS_02,
6222 ARGS_03,
6223 ARGS_04,
6224 ARGS_05), FUNC>::
6225invokeImp(bsl::false_type ,
6226 FUNC f,
6227 typename bslmf::ForwardingType<ARG0>::Type obj,
6228 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6229 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6230 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6231 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6232 typename bslmf::ForwardingType<ARGS_05>::Type args_05)
6233{
6234 typedef typename
6235 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6236
6237 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6238 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6239 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6240 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6241 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6242 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6243 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05)));
6244}
6245#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
6246
6247#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
6248template <class FUNC, class RET, class ARG0, class ARGS_01,
6249 class ARGS_02,
6250 class ARGS_03,
6251 class ARGS_04,
6252 class ARGS_05,
6253 class ARGS_06>
6254inline
6255RET
6256Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6257 RET(ARG0, ARGS_01,
6258 ARGS_02,
6259 ARGS_03,
6260 ARGS_04,
6261 ARGS_05,
6262 ARGS_06), FUNC>::
6263invokeImp(bsl::false_type ,
6264 FUNC f,
6265 typename bslmf::ForwardingType<ARG0>::Type obj,
6266 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6267 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6268 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6269 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6270 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6271 typename bslmf::ForwardingType<ARGS_06>::Type args_06)
6272{
6273 typedef typename
6274 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6275
6276 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6277 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6278 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6279 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6280 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6281 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6282 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6283 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06)));
6284}
6285#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
6286
6287#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
6288template <class FUNC, class RET, class ARG0, class ARGS_01,
6289 class ARGS_02,
6290 class ARGS_03,
6291 class ARGS_04,
6292 class ARGS_05,
6293 class ARGS_06,
6294 class ARGS_07>
6295inline
6296RET
6297Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6298 RET(ARG0, ARGS_01,
6299 ARGS_02,
6300 ARGS_03,
6301 ARGS_04,
6302 ARGS_05,
6303 ARGS_06,
6304 ARGS_07), FUNC>::
6305invokeImp(bsl::false_type ,
6306 FUNC f,
6307 typename bslmf::ForwardingType<ARG0>::Type obj,
6308 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6309 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6310 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6311 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6312 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6313 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6314 typename bslmf::ForwardingType<ARGS_07>::Type args_07)
6315{
6316 typedef typename
6317 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6318
6319 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6320 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6321 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6322 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6323 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6324 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6325 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6326 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
6327 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07)));
6328}
6329#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
6330
6331#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
6332template <class FUNC, class RET, class ARG0, class ARGS_01,
6333 class ARGS_02,
6334 class ARGS_03,
6335 class ARGS_04,
6336 class ARGS_05,
6337 class ARGS_06,
6338 class ARGS_07,
6339 class ARGS_08>
6340inline
6341RET
6342Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6343 RET(ARG0, ARGS_01,
6344 ARGS_02,
6345 ARGS_03,
6346 ARGS_04,
6347 ARGS_05,
6348 ARGS_06,
6349 ARGS_07,
6350 ARGS_08), FUNC>::
6351invokeImp(bsl::false_type ,
6352 FUNC f,
6353 typename bslmf::ForwardingType<ARG0>::Type obj,
6354 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6355 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6356 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6357 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6358 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6359 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6360 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
6361 typename bslmf::ForwardingType<ARGS_08>::Type args_08)
6362{
6363 typedef typename
6364 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6365
6366 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6367 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6368 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6369 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6370 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6371 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6372 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6373 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
6374 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
6375 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08)));
6376}
6377#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
6378
6379#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
6380template <class FUNC, class RET, class ARG0, class ARGS_01,
6381 class ARGS_02,
6382 class ARGS_03,
6383 class ARGS_04,
6384 class ARGS_05,
6385 class ARGS_06,
6386 class ARGS_07,
6387 class ARGS_08,
6388 class ARGS_09>
6389inline
6390RET
6391Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6392 RET(ARG0, ARGS_01,
6393 ARGS_02,
6394 ARGS_03,
6395 ARGS_04,
6396 ARGS_05,
6397 ARGS_06,
6398 ARGS_07,
6399 ARGS_08,
6400 ARGS_09), FUNC>::
6401invokeImp(bsl::false_type ,
6402 FUNC f,
6403 typename bslmf::ForwardingType<ARG0>::Type obj,
6404 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6405 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6406 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6407 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6408 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6409 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6410 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
6411 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
6412 typename bslmf::ForwardingType<ARGS_09>::Type args_09)
6413{
6414 typedef typename
6415 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6416
6417 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6418 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6419 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6420 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6421 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6422 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6423 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6424 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
6425 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
6426 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
6427 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09)));
6428}
6429#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
6430
6431#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
6432template <class FUNC, class RET, class ARG0, class ARGS_01,
6433 class ARGS_02,
6434 class ARGS_03,
6435 class ARGS_04,
6436 class ARGS_05,
6437 class ARGS_06,
6438 class ARGS_07,
6439 class ARGS_08,
6440 class ARGS_09,
6441 class ARGS_10>
6442inline
6443RET
6444Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6445 RET(ARG0, ARGS_01,
6446 ARGS_02,
6447 ARGS_03,
6448 ARGS_04,
6449 ARGS_05,
6450 ARGS_06,
6451 ARGS_07,
6452 ARGS_08,
6453 ARGS_09,
6454 ARGS_10), FUNC>::
6455invokeImp(bsl::false_type ,
6456 FUNC f,
6457 typename bslmf::ForwardingType<ARG0>::Type obj,
6458 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6459 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6460 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6461 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6462 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6463 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6464 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
6465 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
6466 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
6467 typename bslmf::ForwardingType<ARGS_10>::Type args_10)
6468{
6469 typedef typename
6470 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6471
6472 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6473 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6474 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6475 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6476 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6477 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6478 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6479 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
6480 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
6481 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
6482 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
6483 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10)));
6484}
6485#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
6486
6487#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
6488template <class FUNC, class RET, class ARG0, class ARGS_01,
6489 class ARGS_02,
6490 class ARGS_03,
6491 class ARGS_04,
6492 class ARGS_05,
6493 class ARGS_06,
6494 class ARGS_07,
6495 class ARGS_08,
6496 class ARGS_09,
6497 class ARGS_10,
6498 class ARGS_11>
6499inline
6500RET
6501Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6502 RET(ARG0, ARGS_01,
6503 ARGS_02,
6504 ARGS_03,
6505 ARGS_04,
6506 ARGS_05,
6507 ARGS_06,
6508 ARGS_07,
6509 ARGS_08,
6510 ARGS_09,
6511 ARGS_10,
6512 ARGS_11), FUNC>::
6513invokeImp(bsl::false_type ,
6514 FUNC f,
6515 typename bslmf::ForwardingType<ARG0>::Type obj,
6516 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6517 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6518 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6519 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6520 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6521 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6522 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
6523 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
6524 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
6525 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
6526 typename bslmf::ForwardingType<ARGS_11>::Type args_11)
6527{
6528 typedef typename
6529 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6530
6531 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6532 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6533 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6534 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6535 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6536 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6537 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6538 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
6539 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
6540 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
6541 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
6542 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
6543 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11)));
6544}
6545#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
6546
6547#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
6548template <class FUNC, class RET, class ARG0, class ARGS_01,
6549 class ARGS_02,
6550 class ARGS_03,
6551 class ARGS_04,
6552 class ARGS_05,
6553 class ARGS_06,
6554 class ARGS_07,
6555 class ARGS_08,
6556 class ARGS_09,
6557 class ARGS_10,
6558 class ARGS_11,
6559 class ARGS_12>
6560inline
6561RET
6562Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6563 RET(ARG0, ARGS_01,
6564 ARGS_02,
6565 ARGS_03,
6566 ARGS_04,
6567 ARGS_05,
6568 ARGS_06,
6569 ARGS_07,
6570 ARGS_08,
6571 ARGS_09,
6572 ARGS_10,
6573 ARGS_11,
6574 ARGS_12), FUNC>::
6575invokeImp(bsl::false_type ,
6576 FUNC f,
6577 typename bslmf::ForwardingType<ARG0>::Type obj,
6578 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6579 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6580 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6581 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6582 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6583 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6584 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
6585 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
6586 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
6587 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
6588 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
6589 typename bslmf::ForwardingType<ARGS_12>::Type args_12)
6590{
6591 typedef typename
6592 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6593
6594 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6595 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6596 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6597 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6598 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6599 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6600 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6601 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
6602 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
6603 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
6604 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
6605 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
6606 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
6607 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12)));
6608}
6609#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
6610
6611#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
6612template <class FUNC, class RET, class ARG0, class ARGS_01,
6613 class ARGS_02,
6614 class ARGS_03,
6615 class ARGS_04,
6616 class ARGS_05,
6617 class ARGS_06,
6618 class ARGS_07,
6619 class ARGS_08,
6620 class ARGS_09,
6621 class ARGS_10,
6622 class ARGS_11,
6623 class ARGS_12,
6624 class ARGS_13>
6625inline
6626RET
6627Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6628 RET(ARG0, ARGS_01,
6629 ARGS_02,
6630 ARGS_03,
6631 ARGS_04,
6632 ARGS_05,
6633 ARGS_06,
6634 ARGS_07,
6635 ARGS_08,
6636 ARGS_09,
6637 ARGS_10,
6638 ARGS_11,
6639 ARGS_12,
6640 ARGS_13), FUNC>::
6641invokeImp(bsl::false_type ,
6642 FUNC f,
6643 typename bslmf::ForwardingType<ARG0>::Type obj,
6644 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6645 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6646 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6647 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6648 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6649 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6650 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
6651 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
6652 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
6653 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
6654 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
6655 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
6656 typename bslmf::ForwardingType<ARGS_13>::Type args_13)
6657{
6658 typedef typename
6659 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
6660
6661 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
6662 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
6663 bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
6664 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
6665 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
6666 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
6667 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
6668 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
6669 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
6670 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
6671 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
6672 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
6673 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
6674 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12),
6675 bslmf::ForwardingTypeUtil<ARGS_13>::forwardToTarget(args_13)));
6676}
6677#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
6678
6679
6680#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
6681template <class FUNC, class RET, class ARG0>
6682RET
6683Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6684 RET(ARG0), FUNC>::
6685invoke(const Function_Rep *rep,
6686 typename bslmf::ForwardingType<ARG0>::Type obj)
6687{
6688 typedef typename
6689 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
6690
6691 typedef typename bsl::is_convertible<
6692 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
6693 ClassType *
6694 >::type IsDirect;
6695
6696 FUNC f = *rep->targetRaw<FUNC, true>();
6697
6698 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
6699 invokeImp(IsDirect(), f, obj));
6700}
6701#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
6702
6703#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
6704template <class FUNC, class RET, class ARG0, class ARGS_01>
6705RET
6706Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6707 RET(ARG0, ARGS_01), FUNC>::
6708invoke(const Function_Rep *rep,
6709 typename bslmf::ForwardingType<ARG0>::Type obj,
6710 typename bslmf::ForwardingType<ARGS_01>::Type args_01)
6711{
6712 typedef typename
6713 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
6714
6715 typedef typename bsl::is_convertible<
6716 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
6717 ClassType *
6718 >::type IsDirect;
6719
6720 FUNC f = *rep->targetRaw<FUNC, true>();
6721
6722 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
6723 invokeImp(IsDirect(), f, obj,
6724 args_01));
6725}
6726#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
6727
6728#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
6729template <class FUNC, class RET, class ARG0, class ARGS_01,
6730 class ARGS_02>
6731RET
6732Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6733 RET(ARG0, ARGS_01,
6734 ARGS_02), FUNC>::
6735invoke(const Function_Rep *rep,
6736 typename bslmf::ForwardingType<ARG0>::Type obj,
6737 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6738 typename bslmf::ForwardingType<ARGS_02>::Type args_02)
6739{
6740 typedef typename
6741 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
6742
6743 typedef typename bsl::is_convertible<
6744 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
6745 ClassType *
6746 >::type IsDirect;
6747
6748 FUNC f = *rep->targetRaw<FUNC, true>();
6749
6750 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
6751 invokeImp(IsDirect(), f, obj,
6752 args_01,
6753 args_02));
6754}
6755#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
6756
6757#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
6758template <class FUNC, class RET, class ARG0, class ARGS_01,
6759 class ARGS_02,
6760 class ARGS_03>
6761RET
6762Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6763 RET(ARG0, ARGS_01,
6764 ARGS_02,
6765 ARGS_03), FUNC>::
6766invoke(const Function_Rep *rep,
6767 typename bslmf::ForwardingType<ARG0>::Type obj,
6768 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6769 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6770 typename bslmf::ForwardingType<ARGS_03>::Type args_03)
6771{
6772 typedef typename
6773 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
6774
6775 typedef typename bsl::is_convertible<
6776 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
6777 ClassType *
6778 >::type IsDirect;
6779
6780 FUNC f = *rep->targetRaw<FUNC, true>();
6781
6782 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
6783 invokeImp(IsDirect(), f, obj,
6784 args_01,
6785 args_02,
6786 args_03));
6787}
6788#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
6789
6790#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
6791template <class FUNC, class RET, class ARG0, class ARGS_01,
6792 class ARGS_02,
6793 class ARGS_03,
6794 class ARGS_04>
6795RET
6796Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6797 RET(ARG0, ARGS_01,
6798 ARGS_02,
6799 ARGS_03,
6800 ARGS_04), FUNC>::
6801invoke(const Function_Rep *rep,
6802 typename bslmf::ForwardingType<ARG0>::Type obj,
6803 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6804 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6805 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6806 typename bslmf::ForwardingType<ARGS_04>::Type args_04)
6807{
6808 typedef typename
6809 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
6810
6811 typedef typename bsl::is_convertible<
6812 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
6813 ClassType *
6814 >::type IsDirect;
6815
6816 FUNC f = *rep->targetRaw<FUNC, true>();
6817
6818 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
6819 invokeImp(IsDirect(), f, obj,
6820 args_01,
6821 args_02,
6822 args_03,
6823 args_04));
6824}
6825#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
6826
6827#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
6828template <class FUNC, class RET, class ARG0, class ARGS_01,
6829 class ARGS_02,
6830 class ARGS_03,
6831 class ARGS_04,
6832 class ARGS_05>
6833RET
6834Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6835 RET(ARG0, ARGS_01,
6836 ARGS_02,
6837 ARGS_03,
6838 ARGS_04,
6839 ARGS_05), FUNC>::
6840invoke(const Function_Rep *rep,
6841 typename bslmf::ForwardingType<ARG0>::Type obj,
6842 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6843 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6844 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6845 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6846 typename bslmf::ForwardingType<ARGS_05>::Type args_05)
6847{
6848 typedef typename
6849 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
6850
6851 typedef typename bsl::is_convertible<
6852 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
6853 ClassType *
6854 >::type IsDirect;
6855
6856 FUNC f = *rep->targetRaw<FUNC, true>();
6857
6858 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
6859 invokeImp(IsDirect(), f, obj,
6860 args_01,
6861 args_02,
6862 args_03,
6863 args_04,
6864 args_05));
6865}
6866#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
6867
6868#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
6869template <class FUNC, class RET, class ARG0, class ARGS_01,
6870 class ARGS_02,
6871 class ARGS_03,
6872 class ARGS_04,
6873 class ARGS_05,
6874 class ARGS_06>
6875RET
6876Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6877 RET(ARG0, ARGS_01,
6878 ARGS_02,
6879 ARGS_03,
6880 ARGS_04,
6881 ARGS_05,
6882 ARGS_06), FUNC>::
6883invoke(const Function_Rep *rep,
6884 typename bslmf::ForwardingType<ARG0>::Type obj,
6885 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6886 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6887 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6888 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6889 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6890 typename bslmf::ForwardingType<ARGS_06>::Type args_06)
6891{
6892 typedef typename
6893 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
6894
6895 typedef typename bsl::is_convertible<
6896 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
6897 ClassType *
6898 >::type IsDirect;
6899
6900 FUNC f = *rep->targetRaw<FUNC, true>();
6901
6902 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
6903 invokeImp(IsDirect(), f, obj,
6904 args_01,
6905 args_02,
6906 args_03,
6907 args_04,
6908 args_05,
6909 args_06));
6910}
6911#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
6912
6913#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
6914template <class FUNC, class RET, class ARG0, class ARGS_01,
6915 class ARGS_02,
6916 class ARGS_03,
6917 class ARGS_04,
6918 class ARGS_05,
6919 class ARGS_06,
6920 class ARGS_07>
6921RET
6922Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6923 RET(ARG0, ARGS_01,
6924 ARGS_02,
6925 ARGS_03,
6926 ARGS_04,
6927 ARGS_05,
6928 ARGS_06,
6929 ARGS_07), FUNC>::
6930invoke(const Function_Rep *rep,
6931 typename bslmf::ForwardingType<ARG0>::Type obj,
6932 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6933 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6934 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6935 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6936 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6937 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6938 typename bslmf::ForwardingType<ARGS_07>::Type args_07)
6939{
6940 typedef typename
6941 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
6942
6943 typedef typename bsl::is_convertible<
6944 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
6945 ClassType *
6946 >::type IsDirect;
6947
6948 FUNC f = *rep->targetRaw<FUNC, true>();
6949
6950 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
6951 invokeImp(IsDirect(), f, obj,
6952 args_01,
6953 args_02,
6954 args_03,
6955 args_04,
6956 args_05,
6957 args_06,
6958 args_07));
6959}
6960#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
6961
6962#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
6963template <class FUNC, class RET, class ARG0, class ARGS_01,
6964 class ARGS_02,
6965 class ARGS_03,
6966 class ARGS_04,
6967 class ARGS_05,
6968 class ARGS_06,
6969 class ARGS_07,
6970 class ARGS_08>
6971RET
6972Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
6973 RET(ARG0, ARGS_01,
6974 ARGS_02,
6975 ARGS_03,
6976 ARGS_04,
6977 ARGS_05,
6978 ARGS_06,
6979 ARGS_07,
6980 ARGS_08), FUNC>::
6981invoke(const Function_Rep *rep,
6982 typename bslmf::ForwardingType<ARG0>::Type obj,
6983 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
6984 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
6985 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
6986 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
6987 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
6988 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
6989 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
6990 typename bslmf::ForwardingType<ARGS_08>::Type args_08)
6991{
6992 typedef typename
6993 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
6994
6995 typedef typename bsl::is_convertible<
6996 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
6997 ClassType *
6998 >::type IsDirect;
6999
7000 FUNC f = *rep->targetRaw<FUNC, true>();
7001
7002 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
7003 invokeImp(IsDirect(), f, obj,
7004 args_01,
7005 args_02,
7006 args_03,
7007 args_04,
7008 args_05,
7009 args_06,
7010 args_07,
7011 args_08));
7012}
7013#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
7014
7015#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
7016template <class FUNC, class RET, class ARG0, class ARGS_01,
7017 class ARGS_02,
7018 class ARGS_03,
7019 class ARGS_04,
7020 class ARGS_05,
7021 class ARGS_06,
7022 class ARGS_07,
7023 class ARGS_08,
7024 class ARGS_09>
7025RET
7026Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
7027 RET(ARG0, ARGS_01,
7028 ARGS_02,
7029 ARGS_03,
7030 ARGS_04,
7031 ARGS_05,
7032 ARGS_06,
7033 ARGS_07,
7034 ARGS_08,
7035 ARGS_09), FUNC>::
7036invoke(const Function_Rep *rep,
7037 typename bslmf::ForwardingType<ARG0>::Type obj,
7038 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7039 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7040 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7041 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7042 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7043 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7044 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7045 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7046 typename bslmf::ForwardingType<ARGS_09>::Type args_09)
7047{
7048 typedef typename
7049 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
7050
7051 typedef typename bsl::is_convertible<
7052 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
7053 ClassType *
7054 >::type IsDirect;
7055
7056 FUNC f = *rep->targetRaw<FUNC, true>();
7057
7058 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
7059 invokeImp(IsDirect(), f, obj,
7060 args_01,
7061 args_02,
7062 args_03,
7063 args_04,
7064 args_05,
7065 args_06,
7066 args_07,
7067 args_08,
7068 args_09));
7069}
7070#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
7071
7072#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
7073template <class FUNC, class RET, class ARG0, class ARGS_01,
7074 class ARGS_02,
7075 class ARGS_03,
7076 class ARGS_04,
7077 class ARGS_05,
7078 class ARGS_06,
7079 class ARGS_07,
7080 class ARGS_08,
7081 class ARGS_09,
7082 class ARGS_10>
7083RET
7084Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
7085 RET(ARG0, ARGS_01,
7086 ARGS_02,
7087 ARGS_03,
7088 ARGS_04,
7089 ARGS_05,
7090 ARGS_06,
7091 ARGS_07,
7092 ARGS_08,
7093 ARGS_09,
7094 ARGS_10), FUNC>::
7095invoke(const Function_Rep *rep,
7096 typename bslmf::ForwardingType<ARG0>::Type obj,
7097 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7098 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7099 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7100 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7101 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7102 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7103 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7104 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7105 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
7106 typename bslmf::ForwardingType<ARGS_10>::Type args_10)
7107{
7108 typedef typename
7109 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
7110
7111 typedef typename bsl::is_convertible<
7112 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
7113 ClassType *
7114 >::type IsDirect;
7115
7116 FUNC f = *rep->targetRaw<FUNC, true>();
7117
7118 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
7119 invokeImp(IsDirect(), f, obj,
7120 args_01,
7121 args_02,
7122 args_03,
7123 args_04,
7124 args_05,
7125 args_06,
7126 args_07,
7127 args_08,
7128 args_09,
7129 args_10));
7130}
7131#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
7132
7133#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
7134template <class FUNC, class RET, class ARG0, class ARGS_01,
7135 class ARGS_02,
7136 class ARGS_03,
7137 class ARGS_04,
7138 class ARGS_05,
7139 class ARGS_06,
7140 class ARGS_07,
7141 class ARGS_08,
7142 class ARGS_09,
7143 class ARGS_10,
7144 class ARGS_11>
7145RET
7146Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
7147 RET(ARG0, ARGS_01,
7148 ARGS_02,
7149 ARGS_03,
7150 ARGS_04,
7151 ARGS_05,
7152 ARGS_06,
7153 ARGS_07,
7154 ARGS_08,
7155 ARGS_09,
7156 ARGS_10,
7157 ARGS_11), FUNC>::
7158invoke(const Function_Rep *rep,
7159 typename bslmf::ForwardingType<ARG0>::Type obj,
7160 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7161 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7162 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7163 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7164 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7165 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7166 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7167 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7168 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
7169 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
7170 typename bslmf::ForwardingType<ARGS_11>::Type args_11)
7171{
7172 typedef typename
7173 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
7174
7175 typedef typename bsl::is_convertible<
7176 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
7177 ClassType *
7178 >::type IsDirect;
7179
7180 FUNC f = *rep->targetRaw<FUNC, true>();
7181
7182 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
7183 invokeImp(IsDirect(), f, obj,
7184 args_01,
7185 args_02,
7186 args_03,
7187 args_04,
7188 args_05,
7189 args_06,
7190 args_07,
7191 args_08,
7192 args_09,
7193 args_10,
7194 args_11));
7195}
7196#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
7197
7198#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
7199template <class FUNC, class RET, class ARG0, class ARGS_01,
7200 class ARGS_02,
7201 class ARGS_03,
7202 class ARGS_04,
7203 class ARGS_05,
7204 class ARGS_06,
7205 class ARGS_07,
7206 class ARGS_08,
7207 class ARGS_09,
7208 class ARGS_10,
7209 class ARGS_11,
7210 class ARGS_12>
7211RET
7212Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
7213 RET(ARG0, ARGS_01,
7214 ARGS_02,
7215 ARGS_03,
7216 ARGS_04,
7217 ARGS_05,
7218 ARGS_06,
7219 ARGS_07,
7220 ARGS_08,
7221 ARGS_09,
7222 ARGS_10,
7223 ARGS_11,
7224 ARGS_12), FUNC>::
7225invoke(const Function_Rep *rep,
7226 typename bslmf::ForwardingType<ARG0>::Type obj,
7227 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7228 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7229 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7230 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7231 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7232 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7233 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7234 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7235 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
7236 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
7237 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
7238 typename bslmf::ForwardingType<ARGS_12>::Type args_12)
7239{
7240 typedef typename
7241 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
7242
7243 typedef typename bsl::is_convertible<
7244 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
7245 ClassType *
7246 >::type IsDirect;
7247
7248 FUNC f = *rep->targetRaw<FUNC, true>();
7249
7250 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
7251 invokeImp(IsDirect(), f, obj,
7252 args_01,
7253 args_02,
7254 args_03,
7255 args_04,
7256 args_05,
7257 args_06,
7258 args_07,
7259 args_08,
7260 args_09,
7261 args_10,
7262 args_11,
7263 args_12));
7264}
7265#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
7266
7267#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
7268template <class FUNC, class RET, class ARG0, class ARGS_01,
7269 class ARGS_02,
7270 class ARGS_03,
7271 class ARGS_04,
7272 class ARGS_05,
7273 class ARGS_06,
7274 class ARGS_07,
7275 class ARGS_08,
7276 class ARGS_09,
7277 class ARGS_10,
7278 class ARGS_11,
7279 class ARGS_12,
7280 class ARGS_13>
7281RET
7282Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
7283 RET(ARG0, ARGS_01,
7284 ARGS_02,
7285 ARGS_03,
7286 ARGS_04,
7287 ARGS_05,
7288 ARGS_06,
7289 ARGS_07,
7290 ARGS_08,
7291 ARGS_09,
7292 ARGS_10,
7293 ARGS_11,
7294 ARGS_12,
7295 ARGS_13), FUNC>::
7296invoke(const Function_Rep *rep,
7297 typename bslmf::ForwardingType<ARG0>::Type obj,
7298 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7299 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7300 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7301 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7302 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7303 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7304 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7305 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7306 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
7307 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
7308 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
7309 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
7310 typename bslmf::ForwardingType<ARGS_13>::Type args_13)
7311{
7312 typedef typename
7313 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
7314
7315 typedef typename bsl::is_convertible<
7316 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
7317 ClassType *
7318 >::type IsDirect;
7319
7320 FUNC f = *rep->targetRaw<FUNC, true>();
7321
7322 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
7323 invokeImp(IsDirect(), f, obj,
7324 args_01,
7325 args_02,
7326 args_03,
7327 args_04,
7328 args_05,
7329 args_06,
7330 args_07,
7331 args_08,
7332 args_09,
7333 args_10,
7334 args_11,
7335 args_12,
7336 args_13));
7337}
7338#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
7339
7340
7341template <class MEMBER_TYPE, class CLASS_TYPE, class RET, class ARG0>
7342inline
7343RET
7344Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemDataPtr,
7345 RET(ARG0), MEMBER_TYPE CLASS_TYPE::*>::
7346invokeImp(bsl::true_type ,
7347 Func f,
7348 typename bslmf::ForwardingType<ARG0>::Type obj)
7349{
7350 typedef typename
7351 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
7352
7353 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7354 RET, (const_cast<Arg0Ref>(obj).*f));
7355}
7356
7357template <class MEMBER_TYPE, class CLASS_TYPE, class RET, class ARG0>
7358inline
7359RET
7360Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemDataPtr,
7361 RET(ARG0), MEMBER_TYPE CLASS_TYPE::*>::
7362invokeImp(bsl::false_type ,
7363 Func f,
7364 typename bslmf::ForwardingType<ARG0>::Type obj)
7365{
7366 typedef typename
7367 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
7368
7369 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7370 RET, ((*const_cast<Arg0Ref>(obj)).*f));
7371}
7372
7373template <class MEMBER_TYPE, class CLASS_TYPE, class RET, class ARG0>
7374RET
7375Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemDataPtr,
7376 RET(ARG0), MEMBER_TYPE CLASS_TYPE::*>::
7377invoke(const Function_Rep *rep,
7378 typename bslmf::ForwardingType<ARG0>::Type obj)
7379{
7380 typedef typename bsl::is_convertible<
7381 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
7382 const volatile CLASS_TYPE *
7383 >::type IsDirect;
7384
7385 Func f = *rep->targetRaw<Func, true>();
7386
7387 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7388 RET, invokeImp(IsDirect(), f, obj));
7389}
7390
7391#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
7392template <class FUNC, class RET>
7393RET
7394Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7395 RET(), FUNC>::
7396invoke(const Function_Rep *rep)
7397{
7398 FUNC& f = *rep->targetRaw<FUNC, true>();
7399
7400 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7401 RET,
7402 f());
7403}
7404#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
7405
7406#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
7407template <class FUNC, class RET, class ARGS_01>
7408RET
7409Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7410 RET(ARGS_01), FUNC>::
7411invoke(const Function_Rep *rep,
7412 typename bslmf::ForwardingType<ARGS_01>::Type args_01)
7413{
7414 FUNC& f = *rep->targetRaw<FUNC, true>();
7415
7416 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7417 RET,
7418 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01)));
7419}
7420#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
7421
7422#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
7423template <class FUNC, class RET, class ARGS_01,
7424 class ARGS_02>
7425RET
7426Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7427 RET(ARGS_01,
7428 ARGS_02), FUNC>::
7429invoke(const Function_Rep *rep,
7430 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7431 typename bslmf::ForwardingType<ARGS_02>::Type args_02)
7432{
7433 FUNC& f = *rep->targetRaw<FUNC, true>();
7434
7435 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7436 RET,
7437 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7438 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02)));
7439}
7440#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
7441
7442#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
7443template <class FUNC, class RET, class ARGS_01,
7444 class ARGS_02,
7445 class ARGS_03>
7446RET
7447Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7448 RET(ARGS_01,
7449 ARGS_02,
7450 ARGS_03), FUNC>::
7451invoke(const Function_Rep *rep,
7452 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7453 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7454 typename bslmf::ForwardingType<ARGS_03>::Type args_03)
7455{
7456 FUNC& f = *rep->targetRaw<FUNC, true>();
7457
7458 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7459 RET,
7460 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7461 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7462 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03)));
7463}
7464#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
7465
7466#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
7467template <class FUNC, class RET, class ARGS_01,
7468 class ARGS_02,
7469 class ARGS_03,
7470 class ARGS_04>
7471RET
7472Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7473 RET(ARGS_01,
7474 ARGS_02,
7475 ARGS_03,
7476 ARGS_04), FUNC>::
7477invoke(const Function_Rep *rep,
7478 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7479 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7480 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7481 typename bslmf::ForwardingType<ARGS_04>::Type args_04)
7482{
7483 FUNC& f = *rep->targetRaw<FUNC, true>();
7484
7485 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7486 RET,
7487 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7488 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7489 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7490 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04)));
7491}
7492#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
7493
7494#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
7495template <class FUNC, class RET, class ARGS_01,
7496 class ARGS_02,
7497 class ARGS_03,
7498 class ARGS_04,
7499 class ARGS_05>
7500RET
7501Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7502 RET(ARGS_01,
7503 ARGS_02,
7504 ARGS_03,
7505 ARGS_04,
7506 ARGS_05), FUNC>::
7507invoke(const Function_Rep *rep,
7508 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7509 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7510 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7511 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7512 typename bslmf::ForwardingType<ARGS_05>::Type args_05)
7513{
7514 FUNC& f = *rep->targetRaw<FUNC, true>();
7515
7516 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7517 RET,
7518 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7519 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7520 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7521 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
7522 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05)));
7523}
7524#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
7525
7526#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
7527template <class FUNC, class RET, class ARGS_01,
7528 class ARGS_02,
7529 class ARGS_03,
7530 class ARGS_04,
7531 class ARGS_05,
7532 class ARGS_06>
7533RET
7534Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7535 RET(ARGS_01,
7536 ARGS_02,
7537 ARGS_03,
7538 ARGS_04,
7539 ARGS_05,
7540 ARGS_06), FUNC>::
7541invoke(const Function_Rep *rep,
7542 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7543 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7544 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7545 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7546 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7547 typename bslmf::ForwardingType<ARGS_06>::Type args_06)
7548{
7549 FUNC& f = *rep->targetRaw<FUNC, true>();
7550
7551 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7552 RET,
7553 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7554 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7555 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7556 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
7557 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
7558 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06)));
7559}
7560#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
7561
7562#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
7563template <class FUNC, class RET, class ARGS_01,
7564 class ARGS_02,
7565 class ARGS_03,
7566 class ARGS_04,
7567 class ARGS_05,
7568 class ARGS_06,
7569 class ARGS_07>
7570RET
7571Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7572 RET(ARGS_01,
7573 ARGS_02,
7574 ARGS_03,
7575 ARGS_04,
7576 ARGS_05,
7577 ARGS_06,
7578 ARGS_07), FUNC>::
7579invoke(const Function_Rep *rep,
7580 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7581 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7582 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7583 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7584 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7585 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7586 typename bslmf::ForwardingType<ARGS_07>::Type args_07)
7587{
7588 FUNC& f = *rep->targetRaw<FUNC, true>();
7589
7590 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7591 RET,
7592 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7593 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7594 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7595 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
7596 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
7597 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
7598 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07)));
7599}
7600#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
7601
7602#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
7603template <class FUNC, class RET, class ARGS_01,
7604 class ARGS_02,
7605 class ARGS_03,
7606 class ARGS_04,
7607 class ARGS_05,
7608 class ARGS_06,
7609 class ARGS_07,
7610 class ARGS_08>
7611RET
7612Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7613 RET(ARGS_01,
7614 ARGS_02,
7615 ARGS_03,
7616 ARGS_04,
7617 ARGS_05,
7618 ARGS_06,
7619 ARGS_07,
7620 ARGS_08), FUNC>::
7621invoke(const Function_Rep *rep,
7622 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7623 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7624 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7625 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7626 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7627 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7628 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7629 typename bslmf::ForwardingType<ARGS_08>::Type args_08)
7630{
7631 FUNC& f = *rep->targetRaw<FUNC, true>();
7632
7633 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7634 RET,
7635 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7636 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7637 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7638 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
7639 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
7640 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
7641 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
7642 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08)));
7643}
7644#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
7645
7646#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
7647template <class FUNC, class RET, class ARGS_01,
7648 class ARGS_02,
7649 class ARGS_03,
7650 class ARGS_04,
7651 class ARGS_05,
7652 class ARGS_06,
7653 class ARGS_07,
7654 class ARGS_08,
7655 class ARGS_09>
7656RET
7657Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7658 RET(ARGS_01,
7659 ARGS_02,
7660 ARGS_03,
7661 ARGS_04,
7662 ARGS_05,
7663 ARGS_06,
7664 ARGS_07,
7665 ARGS_08,
7666 ARGS_09), FUNC>::
7667invoke(const Function_Rep *rep,
7668 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7669 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7670 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7671 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7672 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7673 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7674 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7675 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7676 typename bslmf::ForwardingType<ARGS_09>::Type args_09)
7677{
7678 FUNC& f = *rep->targetRaw<FUNC, true>();
7679
7680 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7681 RET,
7682 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7683 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7684 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7685 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
7686 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
7687 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
7688 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
7689 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
7690 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09)));
7691}
7692#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
7693
7694#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
7695template <class FUNC, class RET, class ARGS_01,
7696 class ARGS_02,
7697 class ARGS_03,
7698 class ARGS_04,
7699 class ARGS_05,
7700 class ARGS_06,
7701 class ARGS_07,
7702 class ARGS_08,
7703 class ARGS_09,
7704 class ARGS_10>
7705RET
7706Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7707 RET(ARGS_01,
7708 ARGS_02,
7709 ARGS_03,
7710 ARGS_04,
7711 ARGS_05,
7712 ARGS_06,
7713 ARGS_07,
7714 ARGS_08,
7715 ARGS_09,
7716 ARGS_10), FUNC>::
7717invoke(const Function_Rep *rep,
7718 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7719 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7720 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7721 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7722 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7723 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7724 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7725 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7726 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
7727 typename bslmf::ForwardingType<ARGS_10>::Type args_10)
7728{
7729 FUNC& f = *rep->targetRaw<FUNC, true>();
7730
7731 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7732 RET,
7733 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7734 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7735 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7736 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
7737 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
7738 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
7739 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
7740 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
7741 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
7742 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10)));
7743}
7744#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
7745
7746#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
7747template <class FUNC, class RET, class ARGS_01,
7748 class ARGS_02,
7749 class ARGS_03,
7750 class ARGS_04,
7751 class ARGS_05,
7752 class ARGS_06,
7753 class ARGS_07,
7754 class ARGS_08,
7755 class ARGS_09,
7756 class ARGS_10,
7757 class ARGS_11>
7758RET
7759Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7760 RET(ARGS_01,
7761 ARGS_02,
7762 ARGS_03,
7763 ARGS_04,
7764 ARGS_05,
7765 ARGS_06,
7766 ARGS_07,
7767 ARGS_08,
7768 ARGS_09,
7769 ARGS_10,
7770 ARGS_11), FUNC>::
7771invoke(const Function_Rep *rep,
7772 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7773 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7774 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7775 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7776 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7777 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7778 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7779 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7780 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
7781 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
7782 typename bslmf::ForwardingType<ARGS_11>::Type args_11)
7783{
7784 FUNC& f = *rep->targetRaw<FUNC, true>();
7785
7786 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7787 RET,
7788 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7789 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7790 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7791 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
7792 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
7793 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
7794 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
7795 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
7796 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
7797 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
7798 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11)));
7799}
7800#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
7801
7802#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
7803template <class FUNC, class RET, class ARGS_01,
7804 class ARGS_02,
7805 class ARGS_03,
7806 class ARGS_04,
7807 class ARGS_05,
7808 class ARGS_06,
7809 class ARGS_07,
7810 class ARGS_08,
7811 class ARGS_09,
7812 class ARGS_10,
7813 class ARGS_11,
7814 class ARGS_12>
7815RET
7816Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7817 RET(ARGS_01,
7818 ARGS_02,
7819 ARGS_03,
7820 ARGS_04,
7821 ARGS_05,
7822 ARGS_06,
7823 ARGS_07,
7824 ARGS_08,
7825 ARGS_09,
7826 ARGS_10,
7827 ARGS_11,
7828 ARGS_12), FUNC>::
7829invoke(const Function_Rep *rep,
7830 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7831 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7832 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7833 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7834 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7835 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7836 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7837 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7838 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
7839 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
7840 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
7841 typename bslmf::ForwardingType<ARGS_12>::Type args_12)
7842{
7843 FUNC& f = *rep->targetRaw<FUNC, true>();
7844
7845 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7846 RET,
7847 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7848 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7849 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7850 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
7851 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
7852 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
7853 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
7854 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
7855 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
7856 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
7857 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
7858 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12)));
7859}
7860#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
7861
7862#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
7863template <class FUNC, class RET, class ARGS_01,
7864 class ARGS_02,
7865 class ARGS_03,
7866 class ARGS_04,
7867 class ARGS_05,
7868 class ARGS_06,
7869 class ARGS_07,
7870 class ARGS_08,
7871 class ARGS_09,
7872 class ARGS_10,
7873 class ARGS_11,
7874 class ARGS_12,
7875 class ARGS_13>
7876RET
7877Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
7878 RET(ARGS_01,
7879 ARGS_02,
7880 ARGS_03,
7881 ARGS_04,
7882 ARGS_05,
7883 ARGS_06,
7884 ARGS_07,
7885 ARGS_08,
7886 ARGS_09,
7887 ARGS_10,
7888 ARGS_11,
7889 ARGS_12,
7890 ARGS_13), FUNC>::
7891invoke(const Function_Rep *rep,
7892 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7893 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7894 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
7895 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
7896 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
7897 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
7898 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
7899 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
7900 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
7901 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
7902 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
7903 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
7904 typename bslmf::ForwardingType<ARGS_13>::Type args_13)
7905{
7906 FUNC& f = *rep->targetRaw<FUNC, true>();
7907
7908 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7909 RET,
7910 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7911 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7912 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
7913 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
7914 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
7915 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
7916 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
7917 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
7918 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
7919 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
7920 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
7921 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12),
7922 bslmf::ForwardingTypeUtil<ARGS_13>::forwardToTarget(args_13)));
7923}
7924#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
7925
7926
7927#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
7928template <class FUNC, class RET>
7929RET
7930Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
7931 RET(), FUNC>::
7932invoke(const Function_Rep *rep)
7933{
7934 FUNC& f = *rep->targetRaw<FUNC, false>();
7935
7936 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7937 RET,
7938 f());
7939}
7940#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 0
7941
7942#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
7943template <class FUNC, class RET, class ARGS_01>
7944RET
7945Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
7946 RET(ARGS_01), FUNC>::
7947invoke(const Function_Rep *rep,
7948 typename bslmf::ForwardingType<ARGS_01>::Type args_01)
7949{
7950 FUNC& f = *rep->targetRaw<FUNC, false>();
7951
7952 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7953 RET,
7954 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01)));
7955}
7956#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 1
7957
7958#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
7959template <class FUNC, class RET, class ARGS_01,
7960 class ARGS_02>
7961RET
7962Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
7963 RET(ARGS_01,
7964 ARGS_02), FUNC>::
7965invoke(const Function_Rep *rep,
7966 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7967 typename bslmf::ForwardingType<ARGS_02>::Type args_02)
7968{
7969 FUNC& f = *rep->targetRaw<FUNC, false>();
7970
7971 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7972 RET,
7973 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7974 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02)));
7975}
7976#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 2
7977
7978#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
7979template <class FUNC, class RET, class ARGS_01,
7980 class ARGS_02,
7981 class ARGS_03>
7982RET
7983Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
7984 RET(ARGS_01,
7985 ARGS_02,
7986 ARGS_03), FUNC>::
7987invoke(const Function_Rep *rep,
7988 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
7989 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
7990 typename bslmf::ForwardingType<ARGS_03>::Type args_03)
7991{
7992 FUNC& f = *rep->targetRaw<FUNC, false>();
7993
7994 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
7995 RET,
7996 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
7997 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
7998 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03)));
7999}
8000#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 3
8001
8002#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
8003template <class FUNC, class RET, class ARGS_01,
8004 class ARGS_02,
8005 class ARGS_03,
8006 class ARGS_04>
8007RET
8008Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8009 RET(ARGS_01,
8010 ARGS_02,
8011 ARGS_03,
8012 ARGS_04), FUNC>::
8013invoke(const Function_Rep *rep,
8014 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8015 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8016 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8017 typename bslmf::ForwardingType<ARGS_04>::Type args_04)
8018{
8019 FUNC& f = *rep->targetRaw<FUNC, false>();
8020
8021 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8022 RET,
8023 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8024 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8025 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8026 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04)));
8027}
8028#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 4
8029
8030#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
8031template <class FUNC, class RET, class ARGS_01,
8032 class ARGS_02,
8033 class ARGS_03,
8034 class ARGS_04,
8035 class ARGS_05>
8036RET
8037Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8038 RET(ARGS_01,
8039 ARGS_02,
8040 ARGS_03,
8041 ARGS_04,
8042 ARGS_05), FUNC>::
8043invoke(const Function_Rep *rep,
8044 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8045 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8046 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8047 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
8048 typename bslmf::ForwardingType<ARGS_05>::Type args_05)
8049{
8050 FUNC& f = *rep->targetRaw<FUNC, false>();
8051
8052 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8053 RET,
8054 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8055 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8056 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8057 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
8058 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05)));
8059}
8060#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 5
8061
8062#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
8063template <class FUNC, class RET, class ARGS_01,
8064 class ARGS_02,
8065 class ARGS_03,
8066 class ARGS_04,
8067 class ARGS_05,
8068 class ARGS_06>
8069RET
8070Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8071 RET(ARGS_01,
8072 ARGS_02,
8073 ARGS_03,
8074 ARGS_04,
8075 ARGS_05,
8076 ARGS_06), FUNC>::
8077invoke(const Function_Rep *rep,
8078 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8079 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8080 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8081 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
8082 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
8083 typename bslmf::ForwardingType<ARGS_06>::Type args_06)
8084{
8085 FUNC& f = *rep->targetRaw<FUNC, false>();
8086
8087 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8088 RET,
8089 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8090 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8091 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8092 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
8093 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
8094 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06)));
8095}
8096#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 6
8097
8098#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
8099template <class FUNC, class RET, class ARGS_01,
8100 class ARGS_02,
8101 class ARGS_03,
8102 class ARGS_04,
8103 class ARGS_05,
8104 class ARGS_06,
8105 class ARGS_07>
8106RET
8107Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8108 RET(ARGS_01,
8109 ARGS_02,
8110 ARGS_03,
8111 ARGS_04,
8112 ARGS_05,
8113 ARGS_06,
8114 ARGS_07), FUNC>::
8115invoke(const Function_Rep *rep,
8116 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8117 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8118 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8119 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
8120 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
8121 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
8122 typename bslmf::ForwardingType<ARGS_07>::Type args_07)
8123{
8124 FUNC& f = *rep->targetRaw<FUNC, false>();
8125
8126 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8127 RET,
8128 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8129 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8130 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8131 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
8132 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
8133 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
8134 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07)));
8135}
8136#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 7
8137
8138#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
8139template <class FUNC, class RET, class ARGS_01,
8140 class ARGS_02,
8141 class ARGS_03,
8142 class ARGS_04,
8143 class ARGS_05,
8144 class ARGS_06,
8145 class ARGS_07,
8146 class ARGS_08>
8147RET
8148Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8149 RET(ARGS_01,
8150 ARGS_02,
8151 ARGS_03,
8152 ARGS_04,
8153 ARGS_05,
8154 ARGS_06,
8155 ARGS_07,
8156 ARGS_08), FUNC>::
8157invoke(const Function_Rep *rep,
8158 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8159 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8160 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8161 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
8162 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
8163 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
8164 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
8165 typename bslmf::ForwardingType<ARGS_08>::Type args_08)
8166{
8167 FUNC& f = *rep->targetRaw<FUNC, false>();
8168
8169 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8170 RET,
8171 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8172 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8173 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8174 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
8175 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
8176 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
8177 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
8178 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08)));
8179}
8180#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 8
8181
8182#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
8183template <class FUNC, class RET, class ARGS_01,
8184 class ARGS_02,
8185 class ARGS_03,
8186 class ARGS_04,
8187 class ARGS_05,
8188 class ARGS_06,
8189 class ARGS_07,
8190 class ARGS_08,
8191 class ARGS_09>
8192RET
8193Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8194 RET(ARGS_01,
8195 ARGS_02,
8196 ARGS_03,
8197 ARGS_04,
8198 ARGS_05,
8199 ARGS_06,
8200 ARGS_07,
8201 ARGS_08,
8202 ARGS_09), FUNC>::
8203invoke(const Function_Rep *rep,
8204 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8205 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8206 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8207 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
8208 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
8209 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
8210 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
8211 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
8212 typename bslmf::ForwardingType<ARGS_09>::Type args_09)
8213{
8214 FUNC& f = *rep->targetRaw<FUNC, false>();
8215
8216 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8217 RET,
8218 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8219 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8220 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8221 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
8222 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
8223 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
8224 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
8225 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
8226 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09)));
8227}
8228#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 9
8229
8230#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
8231template <class FUNC, class RET, class ARGS_01,
8232 class ARGS_02,
8233 class ARGS_03,
8234 class ARGS_04,
8235 class ARGS_05,
8236 class ARGS_06,
8237 class ARGS_07,
8238 class ARGS_08,
8239 class ARGS_09,
8240 class ARGS_10>
8241RET
8242Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8243 RET(ARGS_01,
8244 ARGS_02,
8245 ARGS_03,
8246 ARGS_04,
8247 ARGS_05,
8248 ARGS_06,
8249 ARGS_07,
8250 ARGS_08,
8251 ARGS_09,
8252 ARGS_10), FUNC>::
8253invoke(const Function_Rep *rep,
8254 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8255 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8256 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8257 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
8258 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
8259 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
8260 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
8261 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
8262 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
8263 typename bslmf::ForwardingType<ARGS_10>::Type args_10)
8264{
8265 FUNC& f = *rep->targetRaw<FUNC, false>();
8266
8267 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8268 RET,
8269 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8270 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8271 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8272 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
8273 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
8274 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
8275 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
8276 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
8277 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
8278 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10)));
8279}
8280#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 10
8281
8282#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
8283template <class FUNC, class RET, class ARGS_01,
8284 class ARGS_02,
8285 class ARGS_03,
8286 class ARGS_04,
8287 class ARGS_05,
8288 class ARGS_06,
8289 class ARGS_07,
8290 class ARGS_08,
8291 class ARGS_09,
8292 class ARGS_10,
8293 class ARGS_11>
8294RET
8295Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8296 RET(ARGS_01,
8297 ARGS_02,
8298 ARGS_03,
8299 ARGS_04,
8300 ARGS_05,
8301 ARGS_06,
8302 ARGS_07,
8303 ARGS_08,
8304 ARGS_09,
8305 ARGS_10,
8306 ARGS_11), FUNC>::
8307invoke(const Function_Rep *rep,
8308 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8309 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8310 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8311 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
8312 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
8313 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
8314 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
8315 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
8316 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
8317 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
8318 typename bslmf::ForwardingType<ARGS_11>::Type args_11)
8319{
8320 FUNC& f = *rep->targetRaw<FUNC, false>();
8321
8322 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8323 RET,
8324 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8325 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8326 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8327 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
8328 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
8329 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
8330 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
8331 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
8332 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
8333 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
8334 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11)));
8335}
8336#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 11
8337
8338#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
8339template <class FUNC, class RET, class ARGS_01,
8340 class ARGS_02,
8341 class ARGS_03,
8342 class ARGS_04,
8343 class ARGS_05,
8344 class ARGS_06,
8345 class ARGS_07,
8346 class ARGS_08,
8347 class ARGS_09,
8348 class ARGS_10,
8349 class ARGS_11,
8350 class ARGS_12>
8351RET
8352Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8353 RET(ARGS_01,
8354 ARGS_02,
8355 ARGS_03,
8356 ARGS_04,
8357 ARGS_05,
8358 ARGS_06,
8359 ARGS_07,
8360 ARGS_08,
8361 ARGS_09,
8362 ARGS_10,
8363 ARGS_11,
8364 ARGS_12), FUNC>::
8365invoke(const Function_Rep *rep,
8366 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8367 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8368 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8369 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
8370 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
8371 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
8372 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
8373 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
8374 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
8375 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
8376 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
8377 typename bslmf::ForwardingType<ARGS_12>::Type args_12)
8378{
8379 FUNC& f = *rep->targetRaw<FUNC, false>();
8380
8381 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8382 RET,
8383 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8384 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8385 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8386 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
8387 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
8388 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
8389 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
8390 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
8391 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
8392 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
8393 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
8394 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12)));
8395}
8396#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 12
8397
8398#if BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
8399template <class FUNC, class RET, class ARGS_01,
8400 class ARGS_02,
8401 class ARGS_03,
8402 class ARGS_04,
8403 class ARGS_05,
8404 class ARGS_06,
8405 class ARGS_07,
8406 class ARGS_08,
8407 class ARGS_09,
8408 class ARGS_10,
8409 class ARGS_11,
8410 class ARGS_12,
8411 class ARGS_13>
8412RET
8413Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8414 RET(ARGS_01,
8415 ARGS_02,
8416 ARGS_03,
8417 ARGS_04,
8418 ARGS_05,
8419 ARGS_06,
8420 ARGS_07,
8421 ARGS_08,
8422 ARGS_09,
8423 ARGS_10,
8424 ARGS_11,
8425 ARGS_12,
8426 ARGS_13), FUNC>::
8427invoke(const Function_Rep *rep,
8428 typename bslmf::ForwardingType<ARGS_01>::Type args_01,
8429 typename bslmf::ForwardingType<ARGS_02>::Type args_02,
8430 typename bslmf::ForwardingType<ARGS_03>::Type args_03,
8431 typename bslmf::ForwardingType<ARGS_04>::Type args_04,
8432 typename bslmf::ForwardingType<ARGS_05>::Type args_05,
8433 typename bslmf::ForwardingType<ARGS_06>::Type args_06,
8434 typename bslmf::ForwardingType<ARGS_07>::Type args_07,
8435 typename bslmf::ForwardingType<ARGS_08>::Type args_08,
8436 typename bslmf::ForwardingType<ARGS_09>::Type args_09,
8437 typename bslmf::ForwardingType<ARGS_10>::Type args_10,
8438 typename bslmf::ForwardingType<ARGS_11>::Type args_11,
8439 typename bslmf::ForwardingType<ARGS_12>::Type args_12,
8440 typename bslmf::ForwardingType<ARGS_13>::Type args_13)
8441{
8442 FUNC& f = *rep->targetRaw<FUNC, false>();
8443
8444 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8445 RET,
8446 f(bslmf::ForwardingTypeUtil<ARGS_01>::forwardToTarget(args_01),
8447 bslmf::ForwardingTypeUtil<ARGS_02>::forwardToTarget(args_02),
8448 bslmf::ForwardingTypeUtil<ARGS_03>::forwardToTarget(args_03),
8449 bslmf::ForwardingTypeUtil<ARGS_04>::forwardToTarget(args_04),
8450 bslmf::ForwardingTypeUtil<ARGS_05>::forwardToTarget(args_05),
8451 bslmf::ForwardingTypeUtil<ARGS_06>::forwardToTarget(args_06),
8452 bslmf::ForwardingTypeUtil<ARGS_07>::forwardToTarget(args_07),
8453 bslmf::ForwardingTypeUtil<ARGS_08>::forwardToTarget(args_08),
8454 bslmf::ForwardingTypeUtil<ARGS_09>::forwardToTarget(args_09),
8455 bslmf::ForwardingTypeUtil<ARGS_10>::forwardToTarget(args_10),
8456 bslmf::ForwardingTypeUtil<ARGS_11>::forwardToTarget(args_11),
8457 bslmf::ForwardingTypeUtil<ARGS_12>::forwardToTarget(args_12),
8458 bslmf::ForwardingTypeUtil<ARGS_13>::forwardToTarget(args_13)));
8459}
8460#endif // BSLSTL_FUNCTION_INVOKERUTIL_VARIADIC_LIMIT_C >= 13
8461
8462#else
8463// The generated code below is a workaround for the absence of perfect
8464// forwarding in some compilers.
8465
8466template <class FUNC, class RET, class... ARGS>
8467RET
8468Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_FunctionPtr,
8469 RET(ARGS...), FUNC>::
8470invoke(const Function_Rep *rep,
8471 typename bslmf::ForwardingType<ARGS>::Type... args)
8472{
8473 FUNC f = *rep->targetRaw<FUNC, true>();
8474
8475
8476 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8477 RET,
8478 f(bslmf::ForwardingTypeUtil<ARGS>::forwardToTarget(args)...));
8479}
8480
8481template <class FUNC, class RET, class ARG0, class... ARGS>
8482inline
8483RET
8484Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
8485 RET(ARG0, ARGS...), FUNC>::
8486invokeImp(bsl::true_type ,
8487 FUNC f,
8488 typename bslmf::ForwardingType<ARG0>::Type obj,
8489 typename bslmf::ForwardingType<ARGS>::Type... args)
8490{
8491 typedef typename
8492 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
8493
8494 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8495 RET, (const_cast<Arg0Ref>(obj).*f)(
8496 bslmf::ForwardingTypeUtil<ARGS>::forwardToTarget(args)...));
8497}
8498
8499template <class FUNC, class RET, class ARG0, class... ARGS>
8500inline
8501RET
8502Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
8503 RET(ARG0, ARGS...), FUNC>::
8504invokeImp(bsl::false_type ,
8505 FUNC f,
8506 typename bslmf::ForwardingType<ARG0>::Type obj,
8507 typename bslmf::ForwardingType<ARGS>::Type... args)
8508{
8509 typedef typename
8510 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
8511
8512 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8513 RET, ((*const_cast<Arg0Ref>(obj)).*f)(
8514 bslmf::ForwardingTypeUtil<ARGS>::forwardToTarget(args)...));
8515}
8516
8517template <class FUNC, class RET, class ARG0, class... ARGS>
8518RET
8519Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemFunctionPtr,
8520 RET(ARG0, ARGS...), FUNC>::
8521invoke(const Function_Rep *rep,
8522 typename bslmf::ForwardingType<ARG0>::Type obj,
8523 typename bslmf::ForwardingType<ARGS>::Type... args)
8524{
8525 typedef typename
8526 bslmf::MemberFunctionPointerTraits<FUNC>::ClassType ClassType;
8527
8528 typedef typename bsl::is_convertible<
8529 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
8530 ClassType *
8531 >::type IsDirect;
8532
8533 FUNC f = *rep->targetRaw<FUNC, true>();
8534
8535 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET,
8536 invokeImp(IsDirect(), f, obj,
8537 args...));
8538}
8539
8540template <class MEMBER_TYPE, class CLASS_TYPE, class RET, class ARG0>
8541inline
8542RET
8543Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemDataPtr,
8544 RET(ARG0), MEMBER_TYPE CLASS_TYPE::*>::
8545invokeImp(bsl::true_type ,
8546 Func f,
8547 typename bslmf::ForwardingType<ARG0>::Type obj)
8548{
8549 typedef typename
8550 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
8551
8552 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8553 RET, (const_cast<Arg0Ref>(obj).*f));
8554}
8555
8556template <class MEMBER_TYPE, class CLASS_TYPE, class RET, class ARG0>
8557inline
8558RET
8559Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemDataPtr,
8560 RET(ARG0), MEMBER_TYPE CLASS_TYPE::*>::
8561invokeImp(bsl::false_type ,
8562 Func f,
8563 typename bslmf::ForwardingType<ARG0>::Type obj)
8564{
8565 typedef typename
8566 bslmf::MovableRefUtil::RemoveReference<ARG0>::type& Arg0Ref;
8567
8568 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8569 RET, ((*const_cast<Arg0Ref>(obj)).*f));
8570}
8571
8572template <class MEMBER_TYPE, class CLASS_TYPE, class RET, class ARG0>
8573RET
8574Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_MemDataPtr,
8575 RET(ARG0), MEMBER_TYPE CLASS_TYPE::*>::
8576invoke(const Function_Rep *rep,
8577 typename bslmf::ForwardingType<ARG0>::Type obj)
8578{
8579 typedef typename bsl::is_convertible<
8580 typename bslmf::MovableRefUtil::RemoveReference<ARG0>::type *,
8581 const volatile CLASS_TYPE *
8582 >::type IsDirect;
8583
8584 Func f = *rep->targetRaw<Func, true>();
8585
8586 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8587 RET, invokeImp(IsDirect(), f, obj));
8588}
8589
8590template <class FUNC, class RET, class... ARGS>
8591RET
8592Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_InplaceFunctor,
8593 RET(ARGS...), FUNC>::
8594invoke(const Function_Rep *rep,
8595 typename bslmf::ForwardingType<ARGS>::Type... args)
8596{
8597 FUNC& f = *rep->targetRaw<FUNC, true>();
8598
8599 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8600 RET,
8601 f(bslmf::ForwardingTypeUtil<ARGS>::forwardToTarget(args)...));
8602}
8603
8604template <class FUNC, class RET, class... ARGS>
8605RET
8606Function_InvokerUtil_Dispatch<Function_InvokerUtil::e_OutofplaceFunctor,
8607 RET(ARGS...), FUNC>::
8608invoke(const Function_Rep *rep,
8609 typename bslmf::ForwardingType<ARGS>::Type... args)
8610{
8611 FUNC& f = *rep->targetRaw<FUNC, false>();
8612
8613 return BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(
8614 RET,
8615 f(bslmf::ForwardingTypeUtil<ARGS>::forwardToTarget(args)...));
8616}
8617
8618// }}} END GENERATED CODE
8619#endif
8620
8621} // close package namespace
8622
8623
8624#else // if ! defined(DEFINED_BSLSTL_FUNCTION_INVOKERUTIL_H)
8625# error Not valid except when included from bslstl_function_invokerutil.h
8626#endif // ! defined(COMPILING_BSLSTL_FUNCTION_INVOKERUTIL_H)
8627
8628#endif // ! defined(INCLUDED_BSLSTL_FUNCTION_INVOKERUTIL_CPP03)
8629
8630// ----------------------------------------------------------------------------
8631// Copyright 2020 Bloomberg Finance L.P.
8632//
8633// Licensed under the Apache License, Version 2.0 (the "License");
8634// you may not use this file except in compliance with the License.
8635// You may obtain a copy of the License at
8636//
8637// http://www.apache.org/licenses/LICENSE-2.0
8638//
8639// Unless required by applicable law or agreed to in writing, software
8640// distributed under the License is distributed on an "AS IS" BASIS,
8641// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
8642// See the License for the specific language governing permissions and
8643// limitations under the License.
8644// ----------------------------- END-OF-FILE ----------------------------------
8645
8646/** @} */
8647/** @} */
8648/** @} */
bsl::invoke_result
Definition bslmf_invokeresult.h:358
bslmf::ForwardingTypeUtil
Provide a namespace for the forwardToTarget function.
Definition bslmf_forwardingtype.h:454
bslmf::ForwardingType::Type
Imp::Type Type
Definition bslmf_forwardingtype.h:439
bslstl::Function_Rep::GenericInvoker
void GenericInvoker()
Definition bslstl_function_rep.h:369
bslstl::Function_SmallObjectOptimization
Definition bslstl_function_smallobjectoptimization.h:78
BSLMF_ASSERT
#define BSLMF_ASSERT(expr)
Definition bslmf_assert.h:229
BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT
#define BSLSTL_FUNCTION_INVOKERUTIL_CAST_RESULT(RET, X)
Definition bslstl_function_invokerutil.h:186
bdlat_NullableValueFunctions::isNull
bool isNull(const TYPE &object)
bsl::nullptr_t
BloombergLP::bsls::Nullptr_Impl::Type nullptr_t
Definition bsls_nullptr.h:281
bslmf
Definition bdlbb_blob.h:576
bslstl
Definition bslstl_algorithm.h:82
bsl::add_lvalue_reference
Definition bslmf_addlvaluereference.h:126
bsl::conditional
Definition bslmf_conditional.h:120
bsl::integral_constant
Definition bslmf_integralconstant.h:244
bsl::is_convertible
Definition bslmf_isconvertible.h:867
bsl::is_member_pointer
Definition bslmf_ismemberpointer.h:143
bslalg::NothrowMovableUtil::UnwrappedType::type
NothrowMovableUtil_Traits< TYPE >::UnwrappedType type
Definition bslalg_nothrowmovableutil.h:370
bslalg::NothrowMovableUtil::unwrap
static UnwrappedType< TYPE >::type & unwrap(TYPE &f)
bslmf::IsFunctionPointer
Definition bslmf_functionpointertraits.h:153
bslmf::IsMemberFunctionPointer
Definition bslmf_memberfunctionpointertraits.h:164
bslmf::MemberFunctionPointerTraits
Definition bslmf_memberfunctionpointertraits.h:150
bslmf::MovableRefUtil_RemoveReference::type
t_TYPE type
Definition bslmf_movableref.h:1177
bslstl::Function_InvokerUtilNullCheck::isNull
static bool isNull(const FUNC &)
Return false.
Definition bslstl_function_invokerutil.h:803
bslstl::Function_InvokerUtil::e_Null
@ e_Null
Definition bslstl_function_invokerutil.h:222
bslstl::Function_InvokerUtil::e_MemDataPtr
@ e_MemDataPtr
Definition bslstl_function_invokerutil.h:225
bslstl::Function_InvokerUtil::e_FunctionPtr
@ e_FunctionPtr
Definition bslstl_function_invokerutil.h:223
bslstl::Function_InvokerUtil::e_InplaceFunctor
@ e_InplaceFunctor
Definition bslstl_function_invokerutil.h:226
bslstl::Function_InvokerUtil::e_OutofplaceFunctor
@ e_OutofplaceFunctor
Definition bslstl_function_invokerutil.h:227
bslstl::Function_InvokerUtil::e_MemFunctionPtr
@ e_MemFunctionPtr
Definition bslstl_function_invokerutil.h:224
bslstl::Function_InvokerUtil::invokerForFunc
static GenericInvoker * invokerForFunc(const bsl::nullptr_t &)
bslstl::Function_InvokerUtil::GenericInvoker
Function_Rep::GenericInvoker GenericInvoker
Definition bslstl_function_invokerutil.h:232