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