BDE 4.39.x Production Release
Loading...
Searching...
No Matches
bslmf_memberfunctionpointertraits.h
Go to the documentation of this file.
1/// @file bslmf_memberfunctionpointertraits.h
2///
3/// The content of this file has been pre-processed for Doxygen.
4///
5
6
7// bslmf_memberfunctionpointertraits.h -*-C++-*-
8#ifndef INCLUDED_BSLMF_MEMBERFUNCTIONPOINTERTRAITS
9#define INCLUDED_BSLMF_MEMBERFUNCTIONPOINTERTRAITS
10
11#include <bsls_ident.h>
12BSLS_IDENT("$Id: $")
13
14/// @defgroup bslmf_memberfunctionpointertraits bslmf_memberfunctionpointertraits
15/// @brief Provide meta-functions to detect member function pointer traits.
16/// @addtogroup bsl
17/// @{
18/// @addtogroup bslmf
19/// @{
20/// @addtogroup bslmf_memberfunctionpointertraits
21/// @{
22///
23/// <h1> Outline </h1>
24/// * <a href="#bslmf_memberfunctionpointertraits-purpose"> Purpose</a>
25/// * <a href="#bslmf_memberfunctionpointertraits-classes"> Classes </a>
26/// * <a href="#bslmf_memberfunctionpointertraits-description"> Description </a>
27/// * <a href="#bslmf_memberfunctionpointertraits-usage"> Usage </a>
28///
29/// # Purpose {#bslmf_memberfunctionpointertraits-purpose}
30/// Provide meta-functions to detect member function pointer traits.
31///
32/// # Classes {#bslmf_memberfunctionpointertraits-classes}
33///
34/// - bslmf::MemberFunctionPointerTraits: meta-function for detecting member
35/// - function pointer traits
36/// - bslmf::IsMemberFunctionPointer: meta-function to determine if a type is
37/// - a member function pointer
38///
39/// @see bslmf_functionpointertraits
40///
41/// # Description {#bslmf_memberfunctionpointertraits-description}
42/// This component provides meta-functions for determining the
43/// traits of a member function pointer. Two meta-functions are provided:
44/// `bslmf::IsMemberFunctionPointer`, and `bslmf::MemberFunctionPointerTraits`.
45/// `bslmf::IsMemberFunctionPointer` tests if a given type is a supported member
46/// function pointer. `bslmf::MemberFunctionPointerTraits` determines the
47/// traits of a member function type, including the type of the object that it
48/// is a member of, its result type, and the type of its list of arguments.
49///
50/// Note that, in order to support pre-C++11 compilers in a manageable way, only
51/// member functions with up to 14 arguments and no C-style (varargs) elipses
52/// are supported on all platforms by this component. When variadic templates
53/// are available, any number of arguments are supported. C-style elipses are
54/// not supported by this component at all. To identify all member function
55/// pointers see @ref bslmf_ismemberfunctionpointer .
56///
57/// ## Usage {#bslmf_memberfunctionpointertraits-usage}
58///
59///
60/// Define the following function types:
61/// @code
62/// typedef void (*VoidFunc0)();
63/// @endcode
64/// and the following `struct` with the following members:
65/// @code
66/// struct MyTestClass {
67/// static void voidFunc0() {}
68/// int func1(int) { return 0; }
69/// int func2(int, int) { return 1; }
70/// };
71/// @endcode
72/// In order to deduce the types of `voidFunc0` and `func1`, we will use the C++
73/// template system to get two auxiliary functions:
74/// @code
75/// template <class t_TYPE>
76/// void checkNotMemberFunctionPointer(t_TYPE object)
77/// {
78/// assert(0 == bslmf::IsMemberFunctionPointer<t_TYPE>::value);
79/// }
80///
81/// template <class t_BSLMF_RETURN, class t_ARGS, class t_TYPE>
82/// void checkMemberFunctionPointer(t_TYPE object)
83/// {
84/// assert(1 == bslmf::IsMemberFunctionPointer<t_TYPE>::value);
85/// typedef typename bslmf::MemberFunctionPointerTraits<t_TYPE>::ResultType
86/// ResultType;
87/// typedef typename
88/// bslmf::MemberFunctionPointerTraits<t_TYPE>::ArgumentList
89/// ArgumentList;
90/// assert(1 == (bsl::is_same<ResultType, t_BSLMF_RETURN>::value));
91/// assert(1 == (bsl::is_same<ArgumentList, t_ARGS>::value));
92/// }
93/// @endcode
94/// The following program should compile and run without errors:
95/// @code
96/// void usageExample()
97/// {
98/// assert(0 == bslmf::IsMemberFunctionPointer<int>::value);
99/// assert(0 == bslmf::IsMemberFunctionPointer<int>::value);
100///
101/// checkNotMemberFunctionPointer(&MyTestClass::voidFunc0);
102/// checkMemberFunctionPointer<int, bslmf::TypeList1<int> >(
103/// &MyTestClass::func1);
104/// checkMemberFunctionPointer<int, bslmf::TypeList2<int, int> >(
105/// &MyTestClass::func2);
106/// }
107/// @endcode
108/// @}
109/** @} */
110/** @} */
111
112/** @addtogroup bsl
113 * @{
114 */
115/** @addtogroup bslmf
116 * @{
117 */
118/** @addtogroup bslmf_memberfunctionpointertraits
119 * @{
120 */
121
122#include <bslscm_version.h>
123
124#include <bslmf_if.h>
125#include <bslmf_integralconstant.h>
126#include <bslmf_removecv.h>
127#include <bslmf_tag.h>
128#include <bslmf_typelist.h>
129
130#include <bsls_compilerfeatures.h>
131
132
133namespace bslmf {
134
135/// Forward declaration.
136template <class t_PROTOTYPE, class t_TEST_PROTOTYPE>
137struct MemberFunctionPointerTraits_Imp;
138
139 // =================================
140 // class MemberFunctionPointerTraits
141 // =================================
142
143/// This metafunction determines the traits of a member function type,
144/// including the type of the object that it is a member of, its result
145/// type, and the type of its list of arguments.
146template <class t_PROTOTYPE>
147struct MemberFunctionPointerTraits
148: public MemberFunctionPointerTraits_Imp<
149 typename bsl::remove_cv<t_PROTOTYPE>::type,
150 typename bsl::remove_cv<t_PROTOTYPE>::type> {
151};
152
153 // =============================
154 // class IsMemberFunctionPointer
155 // =============================
156
157/// This template determines if the specified `t_PROTOTYPE` is a member
158/// function pointer. `value` is defined as 1 if the specified
159/// `t_PROTOTYPE` is a member function, and a zero value otherwise.
160template <class t_PROTOTYPE>
161struct IsMemberFunctionPointer
162: bsl::integral_constant<
163 bool,
164 MemberFunctionPointerTraits<t_PROTOTYPE>::IS_MEMBER_FUNCTION_PTR> {
165};
166
167// ---- Anything below this line is implementation specific. Do not use. ----
168
169 // ==========================
170 // Unsupported Configurations
171 // ==========================
172
173#if defined(BSLS_COMPILERFEATURES_SUPPORT_REF_QUALIFIERS) && \
174 !defined(BSLS_COMPILERFEATURES_SUPPORT_VARIADIC_TEMPLATES)
175 // All of our compilers that support reference qualifiers also support
176 // variadic templates. It would be wasteful to do a variadic expansion
177 // that would never be used. Thus, we exclude this code from processing by
178 // 'sim_cpp11_features.pl' and verify that if reference qualifiers are
179 // supported then variadics are supported, too.
180# error Feature not supported for compilers without variadic templates
181#endif
182
183#if defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES) && \
184 !defined(BSLS_COMPILERFEATURES_SUPPORT_VARIADIC_TEMPLATES)
185 // All of our compilers which identify 'noexcept' as part of the type
186 // system (a C++17 piece of functionality) similarly also support variadic
187 // templates, so we refrain from having the dead code to support this case.
188# error Feature not supported for compilers without variadic templates
189#endif
190
191 // -------------------------------------------
192 // class MemberFunctionPointerTraits_ClassType
193 // -------------------------------------------
194
195#if !BSLS_COMPILERFEATURES_SIMULATE_CPP11_FEATURES // $var-args=14
196
197/// This `class` determines whether the specified `t_PROTOTYPE` is a
198/// `const`, `volatile` or `noexcept` member function of the specified
199/// `t_TYPE`. The `Type` member will be a correctly const and/or volatile
200/// qualified version of `t_TYPE`. This metafunction is necessary because
201/// some old compilers do not correctly dispatch to the correct partial
202/// specialization of `MemberFunctionPointerTraits_Imp` based on
203/// cv-qualification of the member-function pointer.
204///
205/// See @ref bslmf_memberfunctionpointertraits
206template <class t_PROTOTYPE,
207 class t_BSLMF_RETURN,
208 class t_TYPE,
209 class... t_ARGS>
210class MemberFunctionPointerTraits_ClassType {
211
212 typedef Tag<0> NonCVTag; // non-'const', non-'volatile'
213 typedef Tag<1> ConstTag; // 'const'
214 typedef Tag<2> VolTag; // 'volatile'
215 typedef Tag<3> ConstVolTag; // 'const volatile'
216#if !BSLS_COMPILERFEATURES_SIMULATE_CPP11_FEATURES && \
217 defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES)
218 typedef Tag<4> NonCVNoExceptTag; // non-'const', non-'volatile',
219 // 'noexcept'
220 typedef Tag<5> ConstNoExceptTag; // 'const', 'noexcept'
221 typedef Tag<6> VolNoExceptTag; // 'volatile', 'noexcept'
222 typedef Tag<7> ConstVolNoExceptTag; // 'const', 'volatile', 'noexcept'
223#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
224
225 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...));
226 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const);
227 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile);
228 static ConstVolTag test(
229 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const volatile);
230#if !BSLS_COMPILERFEATURES_SIMULATE_CPP11_FEATURES && \
231 defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES)
232 static NonCVNoExceptTag test(
233 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) noexcept);
234 static ConstNoExceptTag test(
235 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const noexcept);
236 static VolNoExceptTag test(
237 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile noexcept);
238 static ConstVolNoExceptTag test(t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...)
239 const volatile noexcept);
240#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
241
242 public:
243 // TYPES
244 enum {
245 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
246 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
247 };
248
249 /// Depending on `IS_CONST`, add or do not add a const qualifier to
250 /// `t_TYPE`.
251 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
252
253 /// Depending on `IS_VOLATILE`, add or do not add a volatile qualifier
254 /// to `t_TYPE`.
255 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
256};
257#elif BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
258// {{{ BEGIN GENERATED CODE
259// The following section is automatically generated. **DO NOT EDIT**
260// Generator command line:
261// sim_cpp11_features.pl bslmf_memberfunctionpointertraits.h
262#ifndef BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT
263#define BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT 14
264#endif
265#ifndef BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A
266#define BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A \
267 BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT
268#endif
269template <class t_PROTOTYPE,
270 class t_BSLMF_RETURN,
271 class t_TYPE
272#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 0
273 ,
274 class t_ARGS_0 = BSLS_COMPILERFEATURES_NILT
275#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 0
276
277#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 1
278 ,
279 class t_ARGS_1 = BSLS_COMPILERFEATURES_NILT
280#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 1
281
282#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 2
283 ,
284 class t_ARGS_2 = BSLS_COMPILERFEATURES_NILT
285#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 2
286
287#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 3
288 ,
289 class t_ARGS_3 = BSLS_COMPILERFEATURES_NILT
290#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 3
291
292#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 4
293 ,
294 class t_ARGS_4 = BSLS_COMPILERFEATURES_NILT
295#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 4
296
297#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 5
298 ,
299 class t_ARGS_5 = BSLS_COMPILERFEATURES_NILT
300#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 5
301
302#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 6
303 ,
304 class t_ARGS_6 = BSLS_COMPILERFEATURES_NILT
305#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 6
306
307#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 7
308 ,
309 class t_ARGS_7 = BSLS_COMPILERFEATURES_NILT
310#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 7
311
312#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 8
313 ,
314 class t_ARGS_8 = BSLS_COMPILERFEATURES_NILT
315#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 8
316
317#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 9
318 ,
319 class t_ARGS_9 = BSLS_COMPILERFEATURES_NILT
320#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 9
321
322#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 10
323 ,
324 class t_ARGS_10 = BSLS_COMPILERFEATURES_NILT
325#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 10
326
327#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 11
328 ,
329 class t_ARGS_11 = BSLS_COMPILERFEATURES_NILT
330#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 11
331
332#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 12
333 ,
334 class t_ARGS_12 = BSLS_COMPILERFEATURES_NILT
335#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 12
336
337#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 13
338 ,
339 class t_ARGS_13 = BSLS_COMPILERFEATURES_NILT
340#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 13
341 ,
342 class = BSLS_COMPILERFEATURES_NILT>
343class MemberFunctionPointerTraits_ClassType;
344
345#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 0
346template <class t_PROTOTYPE, class t_BSLMF_RETURN, class t_TYPE>
347class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
348 t_BSLMF_RETURN,
349 t_TYPE> {
350 typedef Tag<0> NonCVTag;
351 typedef Tag<1> ConstTag;
352 typedef Tag<2> VolTag;
353 typedef Tag<3> ConstVolTag;
354
355 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)());
356 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)() const);
357 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)() volatile);
358 static ConstVolTag test(t_BSLMF_RETURN(t_TYPE::*)() const volatile);
359
360 public:
361 enum {
362 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
363 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
364 };
365
366 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
367
368 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
369};
370#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 0
371
372#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 1
373template <class t_PROTOTYPE,
374 class t_BSLMF_RETURN,
375 class t_TYPE,
376 class t_ARGS_01>
377class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
378 t_BSLMF_RETURN,
379 t_TYPE,
380 t_ARGS_01> {
381 typedef Tag<0> NonCVTag;
382 typedef Tag<1> ConstTag;
383 typedef Tag<2> VolTag;
384 typedef Tag<3> ConstVolTag;
385
386 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01));
387 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01) const);
388 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01) volatile);
389 static ConstVolTag test(
390 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01) const volatile);
391
392 public:
393 enum {
394 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
395 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
396 };
397
398 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
399
400 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
401};
402#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 1
403
404#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 2
405template <class t_PROTOTYPE,
406 class t_BSLMF_RETURN,
407 class t_TYPE,
408 class t_ARGS_01,
409 class t_ARGS_02>
410class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
411 t_BSLMF_RETURN,
412 t_TYPE,
413 t_ARGS_01,
414 t_ARGS_02> {
415 typedef Tag<0> NonCVTag;
416 typedef Tag<1> ConstTag;
417 typedef Tag<2> VolTag;
418 typedef Tag<3> ConstVolTag;
419
420 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02));
421 static ConstTag test(
422 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02) const);
423 static VolTag test(
424 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02) volatile);
425 static ConstVolTag test(
426 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02) const volatile);
427
428 public:
429 enum {
430 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
431 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
432 };
433
434 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
435
436 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
437};
438#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 2
439
440#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 3
441template <class t_PROTOTYPE,
442 class t_BSLMF_RETURN,
443 class t_TYPE,
444 class t_ARGS_01,
445 class t_ARGS_02,
446 class t_ARGS_03>
447class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
448 t_BSLMF_RETURN,
449 t_TYPE,
450 t_ARGS_01,
451 t_ARGS_02,
452 t_ARGS_03> {
453 typedef Tag<0> NonCVTag;
454 typedef Tag<1> ConstTag;
455 typedef Tag<2> VolTag;
456 typedef Tag<3> ConstVolTag;
457
458 static NonCVTag test(
459 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03));
460 static ConstTag test(
461 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03) const);
462 static VolTag test(
463 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03) volatile);
464 static ConstVolTag
465 test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03)
466 const volatile);
467
468 public:
469 enum {
470 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
471 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
472 };
473
474 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
475
476 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
477};
478#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 3
479
480#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 4
481template <class t_PROTOTYPE,
482 class t_BSLMF_RETURN,
483 class t_TYPE,
484 class t_ARGS_01,
485 class t_ARGS_02,
486 class t_ARGS_03,
487 class t_ARGS_04>
488class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
489 t_BSLMF_RETURN,
490 t_TYPE,
491 t_ARGS_01,
492 t_ARGS_02,
493 t_ARGS_03,
494 t_ARGS_04> {
495 typedef Tag<0> NonCVTag;
496 typedef Tag<1> ConstTag;
497 typedef Tag<2> VolTag;
498 typedef Tag<3> ConstVolTag;
499
500 static NonCVTag test(
501 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04));
502 static ConstTag
503 test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04)
504 const);
505 static VolTag test(t_BSLMF_RETURN (
506 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04) volatile);
507 static ConstVolTag
508 test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04)
509 const volatile);
510
511 public:
512 enum {
513 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
514 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
515 };
516
517 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
518
519 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
520};
521#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 4
522
523#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 5
524template <class t_PROTOTYPE,
525 class t_BSLMF_RETURN,
526 class t_TYPE,
527 class t_ARGS_01,
528 class t_ARGS_02,
529 class t_ARGS_03,
530 class t_ARGS_04,
531 class t_ARGS_05>
532class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
533 t_BSLMF_RETURN,
534 t_TYPE,
535 t_ARGS_01,
536 t_ARGS_02,
537 t_ARGS_03,
538 t_ARGS_04,
539 t_ARGS_05> {
540 typedef Tag<0> NonCVTag;
541 typedef Tag<1> ConstTag;
542 typedef Tag<2> VolTag;
543 typedef Tag<3> ConstVolTag;
544
545 static NonCVTag test(t_BSLMF_RETURN (
546 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04, t_ARGS_05));
547 static ConstTag test(t_BSLMF_RETURN (
548 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04, t_ARGS_05)
549 const);
550 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
551 t_ARGS_02,
552 t_ARGS_03,
553 t_ARGS_04,
554 t_ARGS_05) volatile);
555 static ConstVolTag test(t_BSLMF_RETURN (
556 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04, t_ARGS_05)
557 const volatile);
558
559 public:
560 enum {
561 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
562 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
563 };
564
565 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
566
567 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
568};
569#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 5
570
571#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 6
572template <class t_PROTOTYPE,
573 class t_BSLMF_RETURN,
574 class t_TYPE,
575 class t_ARGS_01,
576 class t_ARGS_02,
577 class t_ARGS_03,
578 class t_ARGS_04,
579 class t_ARGS_05,
580 class t_ARGS_06>
581class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
582 t_BSLMF_RETURN,
583 t_TYPE,
584 t_ARGS_01,
585 t_ARGS_02,
586 t_ARGS_03,
587 t_ARGS_04,
588 t_ARGS_05,
589 t_ARGS_06> {
590 typedef Tag<0> NonCVTag;
591 typedef Tag<1> ConstTag;
592 typedef Tag<2> VolTag;
593 typedef Tag<3> ConstVolTag;
594
595 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
596 t_ARGS_02,
597 t_ARGS_03,
598 t_ARGS_04,
599 t_ARGS_05,
600 t_ARGS_06));
601 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
602 t_ARGS_02,
603 t_ARGS_03,
604 t_ARGS_04,
605 t_ARGS_05,
606 t_ARGS_06) const);
607 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
608 t_ARGS_02,
609 t_ARGS_03,
610 t_ARGS_04,
611 t_ARGS_05,
612 t_ARGS_06) volatile);
613 static ConstVolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
614 t_ARGS_02,
615 t_ARGS_03,
616 t_ARGS_04,
617 t_ARGS_05,
618 t_ARGS_06)
619 const volatile);
620
621 public:
622 enum {
623 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
624 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
625 };
626
627 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
628
629 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
630};
631#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 6
632
633#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 7
634template <class t_PROTOTYPE,
635 class t_BSLMF_RETURN,
636 class t_TYPE,
637 class t_ARGS_01,
638 class t_ARGS_02,
639 class t_ARGS_03,
640 class t_ARGS_04,
641 class t_ARGS_05,
642 class t_ARGS_06,
643 class t_ARGS_07>
644class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
645 t_BSLMF_RETURN,
646 t_TYPE,
647 t_ARGS_01,
648 t_ARGS_02,
649 t_ARGS_03,
650 t_ARGS_04,
651 t_ARGS_05,
652 t_ARGS_06,
653 t_ARGS_07> {
654 typedef Tag<0> NonCVTag;
655 typedef Tag<1> ConstTag;
656 typedef Tag<2> VolTag;
657 typedef Tag<3> ConstVolTag;
658
659 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
660 t_ARGS_02,
661 t_ARGS_03,
662 t_ARGS_04,
663 t_ARGS_05,
664 t_ARGS_06,
665 t_ARGS_07));
666 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
667 t_ARGS_02,
668 t_ARGS_03,
669 t_ARGS_04,
670 t_ARGS_05,
671 t_ARGS_06,
672 t_ARGS_07) const);
673 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
674 t_ARGS_02,
675 t_ARGS_03,
676 t_ARGS_04,
677 t_ARGS_05,
678 t_ARGS_06,
679 t_ARGS_07) volatile);
680 static ConstVolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
681 t_ARGS_02,
682 t_ARGS_03,
683 t_ARGS_04,
684 t_ARGS_05,
685 t_ARGS_06,
686 t_ARGS_07)
687 const volatile);
688
689 public:
690 enum {
691 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
692 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
693 };
694
695 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
696
697 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
698};
699#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 7
700
701#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 8
702template <class t_PROTOTYPE,
703 class t_BSLMF_RETURN,
704 class t_TYPE,
705 class t_ARGS_01,
706 class t_ARGS_02,
707 class t_ARGS_03,
708 class t_ARGS_04,
709 class t_ARGS_05,
710 class t_ARGS_06,
711 class t_ARGS_07,
712 class t_ARGS_08>
713class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
714 t_BSLMF_RETURN,
715 t_TYPE,
716 t_ARGS_01,
717 t_ARGS_02,
718 t_ARGS_03,
719 t_ARGS_04,
720 t_ARGS_05,
721 t_ARGS_06,
722 t_ARGS_07,
723 t_ARGS_08> {
724 typedef Tag<0> NonCVTag;
725 typedef Tag<1> ConstTag;
726 typedef Tag<2> VolTag;
727 typedef Tag<3> ConstVolTag;
728
729 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
730 t_ARGS_02,
731 t_ARGS_03,
732 t_ARGS_04,
733 t_ARGS_05,
734 t_ARGS_06,
735 t_ARGS_07,
736 t_ARGS_08));
737 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
738 t_ARGS_02,
739 t_ARGS_03,
740 t_ARGS_04,
741 t_ARGS_05,
742 t_ARGS_06,
743 t_ARGS_07,
744 t_ARGS_08) const);
745 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
746 t_ARGS_02,
747 t_ARGS_03,
748 t_ARGS_04,
749 t_ARGS_05,
750 t_ARGS_06,
751 t_ARGS_07,
752 t_ARGS_08) volatile);
753 static ConstVolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
754 t_ARGS_02,
755 t_ARGS_03,
756 t_ARGS_04,
757 t_ARGS_05,
758 t_ARGS_06,
759 t_ARGS_07,
760 t_ARGS_08)
761 const volatile);
762
763 public:
764 enum {
765 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
766 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
767 };
768
769 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
770
771 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
772};
773#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 8
774
775#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 9
776template <class t_PROTOTYPE,
777 class t_BSLMF_RETURN,
778 class t_TYPE,
779 class t_ARGS_01,
780 class t_ARGS_02,
781 class t_ARGS_03,
782 class t_ARGS_04,
783 class t_ARGS_05,
784 class t_ARGS_06,
785 class t_ARGS_07,
786 class t_ARGS_08,
787 class t_ARGS_09>
788class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
789 t_BSLMF_RETURN,
790 t_TYPE,
791 t_ARGS_01,
792 t_ARGS_02,
793 t_ARGS_03,
794 t_ARGS_04,
795 t_ARGS_05,
796 t_ARGS_06,
797 t_ARGS_07,
798 t_ARGS_08,
799 t_ARGS_09> {
800 typedef Tag<0> NonCVTag;
801 typedef Tag<1> ConstTag;
802 typedef Tag<2> VolTag;
803 typedef Tag<3> ConstVolTag;
804
805 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
806 t_ARGS_02,
807 t_ARGS_03,
808 t_ARGS_04,
809 t_ARGS_05,
810 t_ARGS_06,
811 t_ARGS_07,
812 t_ARGS_08,
813 t_ARGS_09));
814 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
815 t_ARGS_02,
816 t_ARGS_03,
817 t_ARGS_04,
818 t_ARGS_05,
819 t_ARGS_06,
820 t_ARGS_07,
821 t_ARGS_08,
822 t_ARGS_09) const);
823 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
824 t_ARGS_02,
825 t_ARGS_03,
826 t_ARGS_04,
827 t_ARGS_05,
828 t_ARGS_06,
829 t_ARGS_07,
830 t_ARGS_08,
831 t_ARGS_09) volatile);
832 static ConstVolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
833 t_ARGS_02,
834 t_ARGS_03,
835 t_ARGS_04,
836 t_ARGS_05,
837 t_ARGS_06,
838 t_ARGS_07,
839 t_ARGS_08,
840 t_ARGS_09)
841 const volatile);
842
843 public:
844 enum {
845 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
846 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
847 };
848
849 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
850
851 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
852};
853#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 9
854
855#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 10
856template <class t_PROTOTYPE,
857 class t_BSLMF_RETURN,
858 class t_TYPE,
859 class t_ARGS_01,
860 class t_ARGS_02,
861 class t_ARGS_03,
862 class t_ARGS_04,
863 class t_ARGS_05,
864 class t_ARGS_06,
865 class t_ARGS_07,
866 class t_ARGS_08,
867 class t_ARGS_09,
868 class t_ARGS_10>
869class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
870 t_BSLMF_RETURN,
871 t_TYPE,
872 t_ARGS_01,
873 t_ARGS_02,
874 t_ARGS_03,
875 t_ARGS_04,
876 t_ARGS_05,
877 t_ARGS_06,
878 t_ARGS_07,
879 t_ARGS_08,
880 t_ARGS_09,
881 t_ARGS_10> {
882 typedef Tag<0> NonCVTag;
883 typedef Tag<1> ConstTag;
884 typedef Tag<2> VolTag;
885 typedef Tag<3> ConstVolTag;
886
887 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
888 t_ARGS_02,
889 t_ARGS_03,
890 t_ARGS_04,
891 t_ARGS_05,
892 t_ARGS_06,
893 t_ARGS_07,
894 t_ARGS_08,
895 t_ARGS_09,
896 t_ARGS_10));
897 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
898 t_ARGS_02,
899 t_ARGS_03,
900 t_ARGS_04,
901 t_ARGS_05,
902 t_ARGS_06,
903 t_ARGS_07,
904 t_ARGS_08,
905 t_ARGS_09,
906 t_ARGS_10) const);
907 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
908 t_ARGS_02,
909 t_ARGS_03,
910 t_ARGS_04,
911 t_ARGS_05,
912 t_ARGS_06,
913 t_ARGS_07,
914 t_ARGS_08,
915 t_ARGS_09,
916 t_ARGS_10) volatile);
917 static ConstVolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
918 t_ARGS_02,
919 t_ARGS_03,
920 t_ARGS_04,
921 t_ARGS_05,
922 t_ARGS_06,
923 t_ARGS_07,
924 t_ARGS_08,
925 t_ARGS_09,
926 t_ARGS_10)
927 const volatile);
928
929 public:
930 enum {
931 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
932 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
933 };
934
935 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
936
937 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
938};
939#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 10
940
941#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 11
942template <class t_PROTOTYPE,
943 class t_BSLMF_RETURN,
944 class t_TYPE,
945 class t_ARGS_01,
946 class t_ARGS_02,
947 class t_ARGS_03,
948 class t_ARGS_04,
949 class t_ARGS_05,
950 class t_ARGS_06,
951 class t_ARGS_07,
952 class t_ARGS_08,
953 class t_ARGS_09,
954 class t_ARGS_10,
955 class t_ARGS_11>
956class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
957 t_BSLMF_RETURN,
958 t_TYPE,
959 t_ARGS_01,
960 t_ARGS_02,
961 t_ARGS_03,
962 t_ARGS_04,
963 t_ARGS_05,
964 t_ARGS_06,
965 t_ARGS_07,
966 t_ARGS_08,
967 t_ARGS_09,
968 t_ARGS_10,
969 t_ARGS_11> {
970 typedef Tag<0> NonCVTag;
971 typedef Tag<1> ConstTag;
972 typedef Tag<2> VolTag;
973 typedef Tag<3> ConstVolTag;
974
975 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
976 t_ARGS_02,
977 t_ARGS_03,
978 t_ARGS_04,
979 t_ARGS_05,
980 t_ARGS_06,
981 t_ARGS_07,
982 t_ARGS_08,
983 t_ARGS_09,
984 t_ARGS_10,
985 t_ARGS_11));
986 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
987 t_ARGS_02,
988 t_ARGS_03,
989 t_ARGS_04,
990 t_ARGS_05,
991 t_ARGS_06,
992 t_ARGS_07,
993 t_ARGS_08,
994 t_ARGS_09,
995 t_ARGS_10,
996 t_ARGS_11) const);
997 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
998 t_ARGS_02,
999 t_ARGS_03,
1000 t_ARGS_04,
1001 t_ARGS_05,
1002 t_ARGS_06,
1003 t_ARGS_07,
1004 t_ARGS_08,
1005 t_ARGS_09,
1006 t_ARGS_10,
1007 t_ARGS_11) volatile);
1008 static ConstVolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1009 t_ARGS_02,
1010 t_ARGS_03,
1011 t_ARGS_04,
1012 t_ARGS_05,
1013 t_ARGS_06,
1014 t_ARGS_07,
1015 t_ARGS_08,
1016 t_ARGS_09,
1017 t_ARGS_10,
1018 t_ARGS_11)
1019 const volatile);
1020
1021 public:
1022 enum {
1023 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
1024 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
1025 };
1026
1027 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
1028
1029 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
1030};
1031#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 11
1032
1033#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 12
1034template <class t_PROTOTYPE,
1035 class t_BSLMF_RETURN,
1036 class t_TYPE,
1037 class t_ARGS_01,
1038 class t_ARGS_02,
1039 class t_ARGS_03,
1040 class t_ARGS_04,
1041 class t_ARGS_05,
1042 class t_ARGS_06,
1043 class t_ARGS_07,
1044 class t_ARGS_08,
1045 class t_ARGS_09,
1046 class t_ARGS_10,
1047 class t_ARGS_11,
1048 class t_ARGS_12>
1049class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1050 t_BSLMF_RETURN,
1051 t_TYPE,
1052 t_ARGS_01,
1053 t_ARGS_02,
1054 t_ARGS_03,
1055 t_ARGS_04,
1056 t_ARGS_05,
1057 t_ARGS_06,
1058 t_ARGS_07,
1059 t_ARGS_08,
1060 t_ARGS_09,
1061 t_ARGS_10,
1062 t_ARGS_11,
1063 t_ARGS_12> {
1064 typedef Tag<0> NonCVTag;
1065 typedef Tag<1> ConstTag;
1066 typedef Tag<2> VolTag;
1067 typedef Tag<3> ConstVolTag;
1068
1069 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1070 t_ARGS_02,
1071 t_ARGS_03,
1072 t_ARGS_04,
1073 t_ARGS_05,
1074 t_ARGS_06,
1075 t_ARGS_07,
1076 t_ARGS_08,
1077 t_ARGS_09,
1078 t_ARGS_10,
1079 t_ARGS_11,
1080 t_ARGS_12));
1081 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1082 t_ARGS_02,
1083 t_ARGS_03,
1084 t_ARGS_04,
1085 t_ARGS_05,
1086 t_ARGS_06,
1087 t_ARGS_07,
1088 t_ARGS_08,
1089 t_ARGS_09,
1090 t_ARGS_10,
1091 t_ARGS_11,
1092 t_ARGS_12) const);
1093 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1094 t_ARGS_02,
1095 t_ARGS_03,
1096 t_ARGS_04,
1097 t_ARGS_05,
1098 t_ARGS_06,
1099 t_ARGS_07,
1100 t_ARGS_08,
1101 t_ARGS_09,
1102 t_ARGS_10,
1103 t_ARGS_11,
1104 t_ARGS_12) volatile);
1105 static ConstVolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1106 t_ARGS_02,
1107 t_ARGS_03,
1108 t_ARGS_04,
1109 t_ARGS_05,
1110 t_ARGS_06,
1111 t_ARGS_07,
1112 t_ARGS_08,
1113 t_ARGS_09,
1114 t_ARGS_10,
1115 t_ARGS_11,
1116 t_ARGS_12)
1117 const volatile);
1118
1119 public:
1120 enum {
1121 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
1122 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
1123 };
1124
1125 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
1126
1127 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
1128};
1129#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 12
1130
1131#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 13
1132template <class t_PROTOTYPE,
1133 class t_BSLMF_RETURN,
1134 class t_TYPE,
1135 class t_ARGS_01,
1136 class t_ARGS_02,
1137 class t_ARGS_03,
1138 class t_ARGS_04,
1139 class t_ARGS_05,
1140 class t_ARGS_06,
1141 class t_ARGS_07,
1142 class t_ARGS_08,
1143 class t_ARGS_09,
1144 class t_ARGS_10,
1145 class t_ARGS_11,
1146 class t_ARGS_12,
1147 class t_ARGS_13>
1148class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1149 t_BSLMF_RETURN,
1150 t_TYPE,
1151 t_ARGS_01,
1152 t_ARGS_02,
1153 t_ARGS_03,
1154 t_ARGS_04,
1155 t_ARGS_05,
1156 t_ARGS_06,
1157 t_ARGS_07,
1158 t_ARGS_08,
1159 t_ARGS_09,
1160 t_ARGS_10,
1161 t_ARGS_11,
1162 t_ARGS_12,
1163 t_ARGS_13> {
1164 typedef Tag<0> NonCVTag;
1165 typedef Tag<1> ConstTag;
1166 typedef Tag<2> VolTag;
1167 typedef Tag<3> ConstVolTag;
1168
1169 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1170 t_ARGS_02,
1171 t_ARGS_03,
1172 t_ARGS_04,
1173 t_ARGS_05,
1174 t_ARGS_06,
1175 t_ARGS_07,
1176 t_ARGS_08,
1177 t_ARGS_09,
1178 t_ARGS_10,
1179 t_ARGS_11,
1180 t_ARGS_12,
1181 t_ARGS_13));
1182 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1183 t_ARGS_02,
1184 t_ARGS_03,
1185 t_ARGS_04,
1186 t_ARGS_05,
1187 t_ARGS_06,
1188 t_ARGS_07,
1189 t_ARGS_08,
1190 t_ARGS_09,
1191 t_ARGS_10,
1192 t_ARGS_11,
1193 t_ARGS_12,
1194 t_ARGS_13) const);
1195 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1196 t_ARGS_02,
1197 t_ARGS_03,
1198 t_ARGS_04,
1199 t_ARGS_05,
1200 t_ARGS_06,
1201 t_ARGS_07,
1202 t_ARGS_08,
1203 t_ARGS_09,
1204 t_ARGS_10,
1205 t_ARGS_11,
1206 t_ARGS_12,
1207 t_ARGS_13) volatile);
1208 static ConstVolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1209 t_ARGS_02,
1210 t_ARGS_03,
1211 t_ARGS_04,
1212 t_ARGS_05,
1213 t_ARGS_06,
1214 t_ARGS_07,
1215 t_ARGS_08,
1216 t_ARGS_09,
1217 t_ARGS_10,
1218 t_ARGS_11,
1219 t_ARGS_12,
1220 t_ARGS_13)
1221 const volatile);
1222
1223 public:
1224 enum {
1225 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
1226 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
1227 };
1228
1229 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
1230
1231 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
1232};
1233#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 13
1234
1235#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 14
1236template <class t_PROTOTYPE,
1237 class t_BSLMF_RETURN,
1238 class t_TYPE,
1239 class t_ARGS_01,
1240 class t_ARGS_02,
1241 class t_ARGS_03,
1242 class t_ARGS_04,
1243 class t_ARGS_05,
1244 class t_ARGS_06,
1245 class t_ARGS_07,
1246 class t_ARGS_08,
1247 class t_ARGS_09,
1248 class t_ARGS_10,
1249 class t_ARGS_11,
1250 class t_ARGS_12,
1251 class t_ARGS_13,
1252 class t_ARGS_14>
1253class MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1254 t_BSLMF_RETURN,
1255 t_TYPE,
1256 t_ARGS_01,
1257 t_ARGS_02,
1258 t_ARGS_03,
1259 t_ARGS_04,
1260 t_ARGS_05,
1261 t_ARGS_06,
1262 t_ARGS_07,
1263 t_ARGS_08,
1264 t_ARGS_09,
1265 t_ARGS_10,
1266 t_ARGS_11,
1267 t_ARGS_12,
1268 t_ARGS_13,
1269 t_ARGS_14> {
1270 typedef Tag<0> NonCVTag;
1271 typedef Tag<1> ConstTag;
1272 typedef Tag<2> VolTag;
1273 typedef Tag<3> ConstVolTag;
1274
1275 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1276 t_ARGS_02,
1277 t_ARGS_03,
1278 t_ARGS_04,
1279 t_ARGS_05,
1280 t_ARGS_06,
1281 t_ARGS_07,
1282 t_ARGS_08,
1283 t_ARGS_09,
1284 t_ARGS_10,
1285 t_ARGS_11,
1286 t_ARGS_12,
1287 t_ARGS_13,
1288 t_ARGS_14));
1289 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1290 t_ARGS_02,
1291 t_ARGS_03,
1292 t_ARGS_04,
1293 t_ARGS_05,
1294 t_ARGS_06,
1295 t_ARGS_07,
1296 t_ARGS_08,
1297 t_ARGS_09,
1298 t_ARGS_10,
1299 t_ARGS_11,
1300 t_ARGS_12,
1301 t_ARGS_13,
1302 t_ARGS_14) const);
1303 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1304 t_ARGS_02,
1305 t_ARGS_03,
1306 t_ARGS_04,
1307 t_ARGS_05,
1308 t_ARGS_06,
1309 t_ARGS_07,
1310 t_ARGS_08,
1311 t_ARGS_09,
1312 t_ARGS_10,
1313 t_ARGS_11,
1314 t_ARGS_12,
1315 t_ARGS_13,
1316 t_ARGS_14) volatile);
1317 static ConstVolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1318 t_ARGS_02,
1319 t_ARGS_03,
1320 t_ARGS_04,
1321 t_ARGS_05,
1322 t_ARGS_06,
1323 t_ARGS_07,
1324 t_ARGS_08,
1325 t_ARGS_09,
1326 t_ARGS_10,
1327 t_ARGS_11,
1328 t_ARGS_12,
1329 t_ARGS_13,
1330 t_ARGS_14)
1331 const volatile);
1332
1333 public:
1334 enum {
1335 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
1336 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
1337 };
1338
1339 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
1340
1341 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
1342};
1343#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_A >= 14
1344
1345#else // BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
1346// The generated code below is a workaround for the absence of perfect
1347// forwarding in some compilers.
1348template <class t_PROTOTYPE,
1349 class t_BSLMF_RETURN,
1350 class t_TYPE,
1351 class... t_ARGS>
1352class MemberFunctionPointerTraits_ClassType {
1353 typedef Tag<0> NonCVTag;
1354 typedef Tag<1> ConstTag;
1355 typedef Tag<2> VolTag;
1356 typedef Tag<3> ConstVolTag;
1357
1358 static NonCVTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...));
1359 static ConstTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const);
1360 static VolTag test(t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile);
1361 static ConstVolTag test(
1362 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const volatile);
1363
1364 public:
1365 enum {
1366 IS_CONST = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 1) != 0,
1367 IS_VOLATILE = (BSLMF_TAG_TO_UINT((test)((t_PROTOTYPE)0)) & 2) != 0
1368 };
1369
1370 typedef typename If<IS_CONST, const t_TYPE, t_TYPE>::Type CType;
1371
1372 typedef typename If<IS_VOLATILE, volatile CType, CType>::Type Type;
1373};
1374// }}} END GENERATED CODE
1375#endif // BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
1376
1377
1378 // -------------------------------------
1379 // class MemberFunctionPointerTraits_Imp
1380 // -------------------------------------
1381
1382/// Implementation of `MemberFunctionPointerTraits`, containing the actual
1383/// traits types. This primary template is instantiated when `t_PROTOTYPE`
1384/// does not match a pointer-to-member-function type. In actual use,
1385/// `t_PROTOTYPE` and `t_TEST_PROTOTYPE` are the same, but specializations
1386/// treat `t_PROTOTYPE` as an opaque type and `t_TEST_PROTOTYPE` as a
1387/// pattern match. This redundancy is needed to work around some old
1388/// compiler bugs.
1389///
1390/// See @ref bslmf_memberfunctionpointertraits
1391template <class t_PROTOTYPE, class t_TEST_PROTOTYPE>
1392struct MemberFunctionPointerTraits_Imp {
1393
1394 enum {
1395 IS_MEMBER_FUNCTION_PTR = 0
1396 };
1397};
1398
1399// SPECIALIZATIONS
1400#if !BSLS_COMPILERFEATURES_SIMULATE_CPP11_FEATURES // $var-args=14
1401
1402/// Specialization to determine the traits of member functions. A modern
1403/// compiler will match only non-cv member functions, but some older
1404/// compilers might match this to any member function.
1405template <class t_PROTOTYPE,
1406 class t_BSLMF_RETURN,
1407 class t_TYPE,
1408 class... t_ARGS>
1409struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1410 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)> {
1411
1412 enum {
1413 IS_MEMBER_FUNCTION_PTR = 1,
1414 IS_LVALREF_QUALIFIED = 0,
1415 IS_RVALREF_QUALIFIED = 0,
1416 IS_NOEXCEPT = 0
1417 };
1418 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1419 t_BSLMF_RETURN,
1420 t_TYPE,
1421 t_ARGS...>::Type
1422 ClassType;
1423 typedef t_BSLMF_RETURN ResultType;
1424 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
1425};
1426
1427/// Specialization to determine the traits of member functions. A modern
1428/// compiler will match only const member functions, but some older
1429/// compilers might match this to any member function.
1430template <class t_PROTOTYPE,
1431 class t_BSLMF_RETURN,
1432 class t_TYPE,
1433 class... t_ARGS>
1434struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1435 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
1436 const> {
1437
1438 enum {
1439 IS_MEMBER_FUNCTION_PTR = 1,
1440 IS_LVALREF_QUALIFIED = 0,
1441 IS_RVALREF_QUALIFIED = 0,
1442 IS_NOEXCEPT = 0
1443 };
1444 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1445 t_BSLMF_RETURN,
1446 t_TYPE,
1447 t_ARGS...>::Type
1448 ClassType;
1449 typedef t_BSLMF_RETURN ResultType;
1450 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
1451};
1452
1453/// Specialization to determine the traits of member functions. A modern
1454/// compiler will match only volatile member functions, but some older
1455/// compilers might match this to any member function.
1456template <class t_PROTOTYPE,
1457 class t_BSLMF_RETURN,
1458 class t_TYPE,
1459 class... t_ARGS>
1460struct MemberFunctionPointerTraits_Imp<
1461 t_PROTOTYPE,
1462 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile> {
1463
1464 enum {
1465 IS_MEMBER_FUNCTION_PTR = 1,
1466 IS_LVALREF_QUALIFIED = 0,
1467 IS_RVALREF_QUALIFIED = 0,
1468 IS_NOEXCEPT = 0
1469 };
1470
1471 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1472 t_BSLMF_RETURN,
1473 t_TYPE,
1474 t_ARGS...>::Type
1475 ClassType;
1476 typedef t_BSLMF_RETURN ResultType;
1477 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
1478};
1479
1480/// Specialization to determine the traits of member functions. A modern
1481/// compiler will match only const volatile member functions, but some older
1482/// compilers might match this to any member function.
1483template <class t_PROTOTYPE,
1484 class t_BSLMF_RETURN,
1485 class t_TYPE,
1486 class... t_ARGS>
1487struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1488 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
1489 const volatile> {
1490
1491 enum {
1492 IS_MEMBER_FUNCTION_PTR = 1,
1493 IS_LVALREF_QUALIFIED = 0,
1494 IS_RVALREF_QUALIFIED = 0,
1495 IS_NOEXCEPT = 0
1496 };
1497 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1498 t_BSLMF_RETURN,
1499 t_TYPE,
1500 t_ARGS...>::Type
1501 ClassType;
1502 typedef t_BSLMF_RETURN ResultType;
1503 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
1504};
1505
1506#elif BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
1507// {{{ BEGIN GENERATED CODE
1508// The following section is automatically generated. **DO NOT EDIT**
1509// Generator command line:
1510// sim_cpp11_features.pl bslmf_memberfunctionpointertraits.h
1511#ifndef BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT
1512#define BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT 14
1513#endif
1514#ifndef BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B
1515#define BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B \
1516 BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT
1517#endif
1518#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
1519template <class t_PROTOTYPE, class t_BSLMF_RETURN, class t_TYPE>
1520struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1521 t_BSLMF_RETURN (t_TYPE::*)()> {
1522 enum {
1523 IS_MEMBER_FUNCTION_PTR = 1,
1524 IS_LVALREF_QUALIFIED = 0,
1525 IS_RVALREF_QUALIFIED = 0,
1526 IS_NOEXCEPT = 0
1527 };
1528 typedef
1529 typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1530 t_BSLMF_RETURN,
1531 t_TYPE>::Type ClassType;
1532 typedef t_BSLMF_RETURN ResultType;
1533 typedef typename TypeList<>::Type ArgumentList;
1534};
1535#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
1536
1537#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
1538template <class t_PROTOTYPE,
1539 class t_BSLMF_RETURN,
1540 class t_TYPE,
1541 class t_ARGS_01>
1542struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1543 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01)> {
1544 enum {
1545 IS_MEMBER_FUNCTION_PTR = 1,
1546 IS_LVALREF_QUALIFIED = 0,
1547 IS_RVALREF_QUALIFIED = 0,
1548 IS_NOEXCEPT = 0
1549 };
1550 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1551 t_BSLMF_RETURN,
1552 t_TYPE,
1553 t_ARGS_01>::Type
1554 ClassType;
1555 typedef t_BSLMF_RETURN ResultType;
1556 typedef typename TypeList<t_ARGS_01>::Type ArgumentList;
1557};
1558#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
1559
1560#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
1561template <class t_PROTOTYPE,
1562 class t_BSLMF_RETURN,
1563 class t_TYPE,
1564 class t_ARGS_01,
1565 class t_ARGS_02>
1566struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1567 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1568 t_ARGS_02)> {
1569 enum {
1570 IS_MEMBER_FUNCTION_PTR = 1,
1571 IS_LVALREF_QUALIFIED = 0,
1572 IS_RVALREF_QUALIFIED = 0,
1573 IS_NOEXCEPT = 0
1574 };
1575 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1576 t_BSLMF_RETURN,
1577 t_TYPE,
1578 t_ARGS_01,
1579 t_ARGS_02>::Type
1580 ClassType;
1581 typedef t_BSLMF_RETURN ResultType;
1582 typedef typename TypeList<t_ARGS_01,
1583 t_ARGS_02>::Type ArgumentList;
1584};
1585#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
1586
1587#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
1588template <class t_PROTOTYPE,
1589 class t_BSLMF_RETURN,
1590 class t_TYPE,
1591 class t_ARGS_01,
1592 class t_ARGS_02,
1593 class t_ARGS_03>
1594struct MemberFunctionPointerTraits_Imp<
1595 t_PROTOTYPE,
1596 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03)> {
1597 enum {
1598 IS_MEMBER_FUNCTION_PTR = 1,
1599 IS_LVALREF_QUALIFIED = 0,
1600 IS_RVALREF_QUALIFIED = 0,
1601 IS_NOEXCEPT = 0
1602 };
1603 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1604 t_BSLMF_RETURN,
1605 t_TYPE,
1606 t_ARGS_01,
1607 t_ARGS_02,
1608 t_ARGS_03>::Type
1609 ClassType;
1610 typedef t_BSLMF_RETURN ResultType;
1611 typedef typename TypeList<t_ARGS_01,
1612 t_ARGS_02,
1613 t_ARGS_03>::Type ArgumentList;
1614};
1615#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
1616
1617#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
1618template <class t_PROTOTYPE,
1619 class t_BSLMF_RETURN,
1620 class t_TYPE,
1621 class t_ARGS_01,
1622 class t_ARGS_02,
1623 class t_ARGS_03,
1624 class t_ARGS_04>
1625struct MemberFunctionPointerTraits_Imp<
1626 t_PROTOTYPE,
1627 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04)> {
1628 enum {
1629 IS_MEMBER_FUNCTION_PTR = 1,
1630 IS_LVALREF_QUALIFIED = 0,
1631 IS_RVALREF_QUALIFIED = 0,
1632 IS_NOEXCEPT = 0
1633 };
1634 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1635 t_BSLMF_RETURN,
1636 t_TYPE,
1637 t_ARGS_01,
1638 t_ARGS_02,
1639 t_ARGS_03,
1640 t_ARGS_04>::Type
1641 ClassType;
1642 typedef t_BSLMF_RETURN ResultType;
1643 typedef typename TypeList<t_ARGS_01,
1644 t_ARGS_02,
1645 t_ARGS_03,
1646 t_ARGS_04>::Type ArgumentList;
1647};
1648#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
1649
1650#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
1651template <class t_PROTOTYPE,
1652 class t_BSLMF_RETURN,
1653 class t_TYPE,
1654 class t_ARGS_01,
1655 class t_ARGS_02,
1656 class t_ARGS_03,
1657 class t_ARGS_04,
1658 class t_ARGS_05>
1659struct MemberFunctionPointerTraits_Imp<
1660 t_PROTOTYPE,
1661 t_BSLMF_RETURN (
1662 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04, t_ARGS_05)> {
1663 enum {
1664 IS_MEMBER_FUNCTION_PTR = 1,
1665 IS_LVALREF_QUALIFIED = 0,
1666 IS_RVALREF_QUALIFIED = 0,
1667 IS_NOEXCEPT = 0
1668 };
1669 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1670 t_BSLMF_RETURN,
1671 t_TYPE,
1672 t_ARGS_01,
1673 t_ARGS_02,
1674 t_ARGS_03,
1675 t_ARGS_04,
1676 t_ARGS_05>::Type
1677 ClassType;
1678 typedef t_BSLMF_RETURN ResultType;
1679 typedef typename TypeList<t_ARGS_01,
1680 t_ARGS_02,
1681 t_ARGS_03,
1682 t_ARGS_04,
1683 t_ARGS_05>::Type ArgumentList;
1684};
1685#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
1686
1687#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
1688template <class t_PROTOTYPE,
1689 class t_BSLMF_RETURN,
1690 class t_TYPE,
1691 class t_ARGS_01,
1692 class t_ARGS_02,
1693 class t_ARGS_03,
1694 class t_ARGS_04,
1695 class t_ARGS_05,
1696 class t_ARGS_06>
1697struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1698 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1699 t_ARGS_02,
1700 t_ARGS_03,
1701 t_ARGS_04,
1702 t_ARGS_05,
1703 t_ARGS_06)> {
1704 enum {
1705 IS_MEMBER_FUNCTION_PTR = 1,
1706 IS_LVALREF_QUALIFIED = 0,
1707 IS_RVALREF_QUALIFIED = 0,
1708 IS_NOEXCEPT = 0
1709 };
1710 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1711 t_BSLMF_RETURN,
1712 t_TYPE,
1713 t_ARGS_01,
1714 t_ARGS_02,
1715 t_ARGS_03,
1716 t_ARGS_04,
1717 t_ARGS_05,
1718 t_ARGS_06>::Type
1719 ClassType;
1720 typedef t_BSLMF_RETURN ResultType;
1721 typedef typename TypeList<t_ARGS_01,
1722 t_ARGS_02,
1723 t_ARGS_03,
1724 t_ARGS_04,
1725 t_ARGS_05,
1726 t_ARGS_06>::Type ArgumentList;
1727};
1728#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
1729
1730#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
1731template <class t_PROTOTYPE,
1732 class t_BSLMF_RETURN,
1733 class t_TYPE,
1734 class t_ARGS_01,
1735 class t_ARGS_02,
1736 class t_ARGS_03,
1737 class t_ARGS_04,
1738 class t_ARGS_05,
1739 class t_ARGS_06,
1740 class t_ARGS_07>
1741struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1742 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1743 t_ARGS_02,
1744 t_ARGS_03,
1745 t_ARGS_04,
1746 t_ARGS_05,
1747 t_ARGS_06,
1748 t_ARGS_07)> {
1749 enum {
1750 IS_MEMBER_FUNCTION_PTR = 1,
1751 IS_LVALREF_QUALIFIED = 0,
1752 IS_RVALREF_QUALIFIED = 0,
1753 IS_NOEXCEPT = 0
1754 };
1755 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1756 t_BSLMF_RETURN,
1757 t_TYPE,
1758 t_ARGS_01,
1759 t_ARGS_02,
1760 t_ARGS_03,
1761 t_ARGS_04,
1762 t_ARGS_05,
1763 t_ARGS_06,
1764 t_ARGS_07>::Type
1765 ClassType;
1766 typedef t_BSLMF_RETURN ResultType;
1767 typedef typename TypeList<t_ARGS_01,
1768 t_ARGS_02,
1769 t_ARGS_03,
1770 t_ARGS_04,
1771 t_ARGS_05,
1772 t_ARGS_06,
1773 t_ARGS_07>::Type ArgumentList;
1774};
1775#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
1776
1777#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
1778template <class t_PROTOTYPE,
1779 class t_BSLMF_RETURN,
1780 class t_TYPE,
1781 class t_ARGS_01,
1782 class t_ARGS_02,
1783 class t_ARGS_03,
1784 class t_ARGS_04,
1785 class t_ARGS_05,
1786 class t_ARGS_06,
1787 class t_ARGS_07,
1788 class t_ARGS_08>
1789struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1790 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1791 t_ARGS_02,
1792 t_ARGS_03,
1793 t_ARGS_04,
1794 t_ARGS_05,
1795 t_ARGS_06,
1796 t_ARGS_07,
1797 t_ARGS_08)> {
1798 enum {
1799 IS_MEMBER_FUNCTION_PTR = 1,
1800 IS_LVALREF_QUALIFIED = 0,
1801 IS_RVALREF_QUALIFIED = 0,
1802 IS_NOEXCEPT = 0
1803 };
1804 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1805 t_BSLMF_RETURN,
1806 t_TYPE,
1807 t_ARGS_01,
1808 t_ARGS_02,
1809 t_ARGS_03,
1810 t_ARGS_04,
1811 t_ARGS_05,
1812 t_ARGS_06,
1813 t_ARGS_07,
1814 t_ARGS_08>::Type
1815 ClassType;
1816 typedef t_BSLMF_RETURN ResultType;
1817 typedef typename TypeList<t_ARGS_01,
1818 t_ARGS_02,
1819 t_ARGS_03,
1820 t_ARGS_04,
1821 t_ARGS_05,
1822 t_ARGS_06,
1823 t_ARGS_07,
1824 t_ARGS_08>::Type ArgumentList;
1825};
1826#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
1827
1828#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
1829template <class t_PROTOTYPE,
1830 class t_BSLMF_RETURN,
1831 class t_TYPE,
1832 class t_ARGS_01,
1833 class t_ARGS_02,
1834 class t_ARGS_03,
1835 class t_ARGS_04,
1836 class t_ARGS_05,
1837 class t_ARGS_06,
1838 class t_ARGS_07,
1839 class t_ARGS_08,
1840 class t_ARGS_09>
1841struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1842 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1843 t_ARGS_02,
1844 t_ARGS_03,
1845 t_ARGS_04,
1846 t_ARGS_05,
1847 t_ARGS_06,
1848 t_ARGS_07,
1849 t_ARGS_08,
1850 t_ARGS_09)> {
1851 enum {
1852 IS_MEMBER_FUNCTION_PTR = 1,
1853 IS_LVALREF_QUALIFIED = 0,
1854 IS_RVALREF_QUALIFIED = 0,
1855 IS_NOEXCEPT = 0
1856 };
1857 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1858 t_BSLMF_RETURN,
1859 t_TYPE,
1860 t_ARGS_01,
1861 t_ARGS_02,
1862 t_ARGS_03,
1863 t_ARGS_04,
1864 t_ARGS_05,
1865 t_ARGS_06,
1866 t_ARGS_07,
1867 t_ARGS_08,
1868 t_ARGS_09>::Type
1869 ClassType;
1870 typedef t_BSLMF_RETURN ResultType;
1871 typedef typename TypeList<t_ARGS_01,
1872 t_ARGS_02,
1873 t_ARGS_03,
1874 t_ARGS_04,
1875 t_ARGS_05,
1876 t_ARGS_06,
1877 t_ARGS_07,
1878 t_ARGS_08,
1879 t_ARGS_09>::Type ArgumentList;
1880};
1881#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
1882
1883#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
1884template <class t_PROTOTYPE,
1885 class t_BSLMF_RETURN,
1886 class t_TYPE,
1887 class t_ARGS_01,
1888 class t_ARGS_02,
1889 class t_ARGS_03,
1890 class t_ARGS_04,
1891 class t_ARGS_05,
1892 class t_ARGS_06,
1893 class t_ARGS_07,
1894 class t_ARGS_08,
1895 class t_ARGS_09,
1896 class t_ARGS_10>
1897struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1898 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1899 t_ARGS_02,
1900 t_ARGS_03,
1901 t_ARGS_04,
1902 t_ARGS_05,
1903 t_ARGS_06,
1904 t_ARGS_07,
1905 t_ARGS_08,
1906 t_ARGS_09,
1907 t_ARGS_10)> {
1908 enum {
1909 IS_MEMBER_FUNCTION_PTR = 1,
1910 IS_LVALREF_QUALIFIED = 0,
1911 IS_RVALREF_QUALIFIED = 0,
1912 IS_NOEXCEPT = 0
1913 };
1914 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1915 t_BSLMF_RETURN,
1916 t_TYPE,
1917 t_ARGS_01,
1918 t_ARGS_02,
1919 t_ARGS_03,
1920 t_ARGS_04,
1921 t_ARGS_05,
1922 t_ARGS_06,
1923 t_ARGS_07,
1924 t_ARGS_08,
1925 t_ARGS_09,
1926 t_ARGS_10>::Type
1927 ClassType;
1928 typedef t_BSLMF_RETURN ResultType;
1929 typedef typename TypeList<t_ARGS_01,
1930 t_ARGS_02,
1931 t_ARGS_03,
1932 t_ARGS_04,
1933 t_ARGS_05,
1934 t_ARGS_06,
1935 t_ARGS_07,
1936 t_ARGS_08,
1937 t_ARGS_09,
1938 t_ARGS_10>::Type ArgumentList;
1939};
1940#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
1941
1942#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
1943template <class t_PROTOTYPE,
1944 class t_BSLMF_RETURN,
1945 class t_TYPE,
1946 class t_ARGS_01,
1947 class t_ARGS_02,
1948 class t_ARGS_03,
1949 class t_ARGS_04,
1950 class t_ARGS_05,
1951 class t_ARGS_06,
1952 class t_ARGS_07,
1953 class t_ARGS_08,
1954 class t_ARGS_09,
1955 class t_ARGS_10,
1956 class t_ARGS_11>
1957struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1958 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1959 t_ARGS_02,
1960 t_ARGS_03,
1961 t_ARGS_04,
1962 t_ARGS_05,
1963 t_ARGS_06,
1964 t_ARGS_07,
1965 t_ARGS_08,
1966 t_ARGS_09,
1967 t_ARGS_10,
1968 t_ARGS_11)> {
1969 enum {
1970 IS_MEMBER_FUNCTION_PTR = 1,
1971 IS_LVALREF_QUALIFIED = 0,
1972 IS_RVALREF_QUALIFIED = 0,
1973 IS_NOEXCEPT = 0
1974 };
1975 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1976 t_BSLMF_RETURN,
1977 t_TYPE,
1978 t_ARGS_01,
1979 t_ARGS_02,
1980 t_ARGS_03,
1981 t_ARGS_04,
1982 t_ARGS_05,
1983 t_ARGS_06,
1984 t_ARGS_07,
1985 t_ARGS_08,
1986 t_ARGS_09,
1987 t_ARGS_10,
1988 t_ARGS_11>::Type
1989 ClassType;
1990 typedef t_BSLMF_RETURN ResultType;
1991 typedef typename TypeList<t_ARGS_01,
1992 t_ARGS_02,
1993 t_ARGS_03,
1994 t_ARGS_04,
1995 t_ARGS_05,
1996 t_ARGS_06,
1997 t_ARGS_07,
1998 t_ARGS_08,
1999 t_ARGS_09,
2000 t_ARGS_10,
2001 t_ARGS_11>::Type ArgumentList;
2002};
2003#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
2004
2005#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
2006template <class t_PROTOTYPE,
2007 class t_BSLMF_RETURN,
2008 class t_TYPE,
2009 class t_ARGS_01,
2010 class t_ARGS_02,
2011 class t_ARGS_03,
2012 class t_ARGS_04,
2013 class t_ARGS_05,
2014 class t_ARGS_06,
2015 class t_ARGS_07,
2016 class t_ARGS_08,
2017 class t_ARGS_09,
2018 class t_ARGS_10,
2019 class t_ARGS_11,
2020 class t_ARGS_12>
2021struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2022 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2023 t_ARGS_02,
2024 t_ARGS_03,
2025 t_ARGS_04,
2026 t_ARGS_05,
2027 t_ARGS_06,
2028 t_ARGS_07,
2029 t_ARGS_08,
2030 t_ARGS_09,
2031 t_ARGS_10,
2032 t_ARGS_11,
2033 t_ARGS_12)> {
2034 enum {
2035 IS_MEMBER_FUNCTION_PTR = 1,
2036 IS_LVALREF_QUALIFIED = 0,
2037 IS_RVALREF_QUALIFIED = 0,
2038 IS_NOEXCEPT = 0
2039 };
2040 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2041 t_BSLMF_RETURN,
2042 t_TYPE,
2043 t_ARGS_01,
2044 t_ARGS_02,
2045 t_ARGS_03,
2046 t_ARGS_04,
2047 t_ARGS_05,
2048 t_ARGS_06,
2049 t_ARGS_07,
2050 t_ARGS_08,
2051 t_ARGS_09,
2052 t_ARGS_10,
2053 t_ARGS_11,
2054 t_ARGS_12>::Type
2055 ClassType;
2056 typedef t_BSLMF_RETURN ResultType;
2057 typedef typename TypeList<t_ARGS_01,
2058 t_ARGS_02,
2059 t_ARGS_03,
2060 t_ARGS_04,
2061 t_ARGS_05,
2062 t_ARGS_06,
2063 t_ARGS_07,
2064 t_ARGS_08,
2065 t_ARGS_09,
2066 t_ARGS_10,
2067 t_ARGS_11,
2068 t_ARGS_12>::Type ArgumentList;
2069};
2070#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
2071
2072#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
2073template <class t_PROTOTYPE,
2074 class t_BSLMF_RETURN,
2075 class t_TYPE,
2076 class t_ARGS_01,
2077 class t_ARGS_02,
2078 class t_ARGS_03,
2079 class t_ARGS_04,
2080 class t_ARGS_05,
2081 class t_ARGS_06,
2082 class t_ARGS_07,
2083 class t_ARGS_08,
2084 class t_ARGS_09,
2085 class t_ARGS_10,
2086 class t_ARGS_11,
2087 class t_ARGS_12,
2088 class t_ARGS_13>
2089struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2090 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2091 t_ARGS_02,
2092 t_ARGS_03,
2093 t_ARGS_04,
2094 t_ARGS_05,
2095 t_ARGS_06,
2096 t_ARGS_07,
2097 t_ARGS_08,
2098 t_ARGS_09,
2099 t_ARGS_10,
2100 t_ARGS_11,
2101 t_ARGS_12,
2102 t_ARGS_13)> {
2103 enum {
2104 IS_MEMBER_FUNCTION_PTR = 1,
2105 IS_LVALREF_QUALIFIED = 0,
2106 IS_RVALREF_QUALIFIED = 0,
2107 IS_NOEXCEPT = 0
2108 };
2109 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2110 t_BSLMF_RETURN,
2111 t_TYPE,
2112 t_ARGS_01,
2113 t_ARGS_02,
2114 t_ARGS_03,
2115 t_ARGS_04,
2116 t_ARGS_05,
2117 t_ARGS_06,
2118 t_ARGS_07,
2119 t_ARGS_08,
2120 t_ARGS_09,
2121 t_ARGS_10,
2122 t_ARGS_11,
2123 t_ARGS_12,
2124 t_ARGS_13>::Type
2125 ClassType;
2126 typedef t_BSLMF_RETURN ResultType;
2127 typedef typename TypeList<t_ARGS_01,
2128 t_ARGS_02,
2129 t_ARGS_03,
2130 t_ARGS_04,
2131 t_ARGS_05,
2132 t_ARGS_06,
2133 t_ARGS_07,
2134 t_ARGS_08,
2135 t_ARGS_09,
2136 t_ARGS_10,
2137 t_ARGS_11,
2138 t_ARGS_12,
2139 t_ARGS_13>::Type ArgumentList;
2140};
2141#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
2142
2143#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
2144template <class t_PROTOTYPE,
2145 class t_BSLMF_RETURN,
2146 class t_TYPE,
2147 class t_ARGS_01,
2148 class t_ARGS_02,
2149 class t_ARGS_03,
2150 class t_ARGS_04,
2151 class t_ARGS_05,
2152 class t_ARGS_06,
2153 class t_ARGS_07,
2154 class t_ARGS_08,
2155 class t_ARGS_09,
2156 class t_ARGS_10,
2157 class t_ARGS_11,
2158 class t_ARGS_12,
2159 class t_ARGS_13,
2160 class t_ARGS_14>
2161struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2162 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2163 t_ARGS_02,
2164 t_ARGS_03,
2165 t_ARGS_04,
2166 t_ARGS_05,
2167 t_ARGS_06,
2168 t_ARGS_07,
2169 t_ARGS_08,
2170 t_ARGS_09,
2171 t_ARGS_10,
2172 t_ARGS_11,
2173 t_ARGS_12,
2174 t_ARGS_13,
2175 t_ARGS_14)> {
2176 enum {
2177 IS_MEMBER_FUNCTION_PTR = 1,
2178 IS_LVALREF_QUALIFIED = 0,
2179 IS_RVALREF_QUALIFIED = 0,
2180 IS_NOEXCEPT = 0
2181 };
2182 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2183 t_BSLMF_RETURN,
2184 t_TYPE,
2185 t_ARGS_01,
2186 t_ARGS_02,
2187 t_ARGS_03,
2188 t_ARGS_04,
2189 t_ARGS_05,
2190 t_ARGS_06,
2191 t_ARGS_07,
2192 t_ARGS_08,
2193 t_ARGS_09,
2194 t_ARGS_10,
2195 t_ARGS_11,
2196 t_ARGS_12,
2197 t_ARGS_13,
2198 t_ARGS_14>::Type
2199 ClassType;
2200 typedef t_BSLMF_RETURN ResultType;
2201 typedef typename TypeList<t_ARGS_01,
2202 t_ARGS_02,
2203 t_ARGS_03,
2204 t_ARGS_04,
2205 t_ARGS_05,
2206 t_ARGS_06,
2207 t_ARGS_07,
2208 t_ARGS_08,
2209 t_ARGS_09,
2210 t_ARGS_10,
2211 t_ARGS_11,
2212 t_ARGS_12,
2213 t_ARGS_13,
2214 t_ARGS_14>::Type ArgumentList;
2215};
2216#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
2217
2218#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
2219template <class t_PROTOTYPE, class t_BSLMF_RETURN, class t_TYPE>
2220struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2221 t_BSLMF_RETURN (t_TYPE::*)() const> {
2222 enum {
2223 IS_MEMBER_FUNCTION_PTR = 1,
2224 IS_LVALREF_QUALIFIED = 0,
2225 IS_RVALREF_QUALIFIED = 0,
2226 IS_NOEXCEPT = 0
2227 };
2228 typedef
2229 typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2230 t_BSLMF_RETURN,
2231 t_TYPE>::Type ClassType;
2232 typedef t_BSLMF_RETURN ResultType;
2233 typedef typename TypeList<>::Type ArgumentList;
2234};
2235#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
2236
2237#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
2238template <class t_PROTOTYPE,
2239 class t_BSLMF_RETURN,
2240 class t_TYPE,
2241 class t_ARGS_01>
2242struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2243 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01)
2244 const> {
2245 enum {
2246 IS_MEMBER_FUNCTION_PTR = 1,
2247 IS_LVALREF_QUALIFIED = 0,
2248 IS_RVALREF_QUALIFIED = 0,
2249 IS_NOEXCEPT = 0
2250 };
2251 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2252 t_BSLMF_RETURN,
2253 t_TYPE,
2254 t_ARGS_01>::Type
2255 ClassType;
2256 typedef t_BSLMF_RETURN ResultType;
2257 typedef typename TypeList<t_ARGS_01>::Type ArgumentList;
2258};
2259#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
2260
2261#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
2262template <class t_PROTOTYPE,
2263 class t_BSLMF_RETURN,
2264 class t_TYPE,
2265 class t_ARGS_01,
2266 class t_ARGS_02>
2267struct MemberFunctionPointerTraits_Imp<
2268 t_PROTOTYPE,
2269 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02) const> {
2270 enum {
2271 IS_MEMBER_FUNCTION_PTR = 1,
2272 IS_LVALREF_QUALIFIED = 0,
2273 IS_RVALREF_QUALIFIED = 0,
2274 IS_NOEXCEPT = 0
2275 };
2276 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2277 t_BSLMF_RETURN,
2278 t_TYPE,
2279 t_ARGS_01,
2280 t_ARGS_02>::Type
2281 ClassType;
2282 typedef t_BSLMF_RETURN ResultType;
2283 typedef typename TypeList<t_ARGS_01,
2284 t_ARGS_02>::Type ArgumentList;
2285};
2286#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
2287
2288#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
2289template <class t_PROTOTYPE,
2290 class t_BSLMF_RETURN,
2291 class t_TYPE,
2292 class t_ARGS_01,
2293 class t_ARGS_02,
2294 class t_ARGS_03>
2295struct MemberFunctionPointerTraits_Imp<
2296 t_PROTOTYPE,
2297 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03) const> {
2298 enum {
2299 IS_MEMBER_FUNCTION_PTR = 1,
2300 IS_LVALREF_QUALIFIED = 0,
2301 IS_RVALREF_QUALIFIED = 0,
2302 IS_NOEXCEPT = 0
2303 };
2304 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2305 t_BSLMF_RETURN,
2306 t_TYPE,
2307 t_ARGS_01,
2308 t_ARGS_02,
2309 t_ARGS_03>::Type
2310 ClassType;
2311 typedef t_BSLMF_RETURN ResultType;
2312 typedef typename TypeList<t_ARGS_01,
2313 t_ARGS_02,
2314 t_ARGS_03>::Type ArgumentList;
2315};
2316#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
2317
2318#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
2319template <class t_PROTOTYPE,
2320 class t_BSLMF_RETURN,
2321 class t_TYPE,
2322 class t_ARGS_01,
2323 class t_ARGS_02,
2324 class t_ARGS_03,
2325 class t_ARGS_04>
2326struct MemberFunctionPointerTraits_Imp<
2327 t_PROTOTYPE,
2328 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04)
2329 const> {
2330 enum {
2331 IS_MEMBER_FUNCTION_PTR = 1,
2332 IS_LVALREF_QUALIFIED = 0,
2333 IS_RVALREF_QUALIFIED = 0,
2334 IS_NOEXCEPT = 0
2335 };
2336 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2337 t_BSLMF_RETURN,
2338 t_TYPE,
2339 t_ARGS_01,
2340 t_ARGS_02,
2341 t_ARGS_03,
2342 t_ARGS_04>::Type
2343 ClassType;
2344 typedef t_BSLMF_RETURN ResultType;
2345 typedef typename TypeList<t_ARGS_01,
2346 t_ARGS_02,
2347 t_ARGS_03,
2348 t_ARGS_04>::Type ArgumentList;
2349};
2350#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
2351
2352#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
2353template <class t_PROTOTYPE,
2354 class t_BSLMF_RETURN,
2355 class t_TYPE,
2356 class t_ARGS_01,
2357 class t_ARGS_02,
2358 class t_ARGS_03,
2359 class t_ARGS_04,
2360 class t_ARGS_05>
2361struct MemberFunctionPointerTraits_Imp<
2362 t_PROTOTYPE,
2363 t_BSLMF_RETURN (
2364 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04, t_ARGS_05)
2365 const> {
2366 enum {
2367 IS_MEMBER_FUNCTION_PTR = 1,
2368 IS_LVALREF_QUALIFIED = 0,
2369 IS_RVALREF_QUALIFIED = 0,
2370 IS_NOEXCEPT = 0
2371 };
2372 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2373 t_BSLMF_RETURN,
2374 t_TYPE,
2375 t_ARGS_01,
2376 t_ARGS_02,
2377 t_ARGS_03,
2378 t_ARGS_04,
2379 t_ARGS_05>::Type
2380 ClassType;
2381 typedef t_BSLMF_RETURN ResultType;
2382 typedef typename TypeList<t_ARGS_01,
2383 t_ARGS_02,
2384 t_ARGS_03,
2385 t_ARGS_04,
2386 t_ARGS_05>::Type ArgumentList;
2387};
2388#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
2389
2390#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
2391template <class t_PROTOTYPE,
2392 class t_BSLMF_RETURN,
2393 class t_TYPE,
2394 class t_ARGS_01,
2395 class t_ARGS_02,
2396 class t_ARGS_03,
2397 class t_ARGS_04,
2398 class t_ARGS_05,
2399 class t_ARGS_06>
2400struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2401 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2402 t_ARGS_02,
2403 t_ARGS_03,
2404 t_ARGS_04,
2405 t_ARGS_05,
2406 t_ARGS_06)
2407 const> {
2408 enum {
2409 IS_MEMBER_FUNCTION_PTR = 1,
2410 IS_LVALREF_QUALIFIED = 0,
2411 IS_RVALREF_QUALIFIED = 0,
2412 IS_NOEXCEPT = 0
2413 };
2414 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2415 t_BSLMF_RETURN,
2416 t_TYPE,
2417 t_ARGS_01,
2418 t_ARGS_02,
2419 t_ARGS_03,
2420 t_ARGS_04,
2421 t_ARGS_05,
2422 t_ARGS_06>::Type
2423 ClassType;
2424 typedef t_BSLMF_RETURN ResultType;
2425 typedef typename TypeList<t_ARGS_01,
2426 t_ARGS_02,
2427 t_ARGS_03,
2428 t_ARGS_04,
2429 t_ARGS_05,
2430 t_ARGS_06>::Type ArgumentList;
2431};
2432#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
2433
2434#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
2435template <class t_PROTOTYPE,
2436 class t_BSLMF_RETURN,
2437 class t_TYPE,
2438 class t_ARGS_01,
2439 class t_ARGS_02,
2440 class t_ARGS_03,
2441 class t_ARGS_04,
2442 class t_ARGS_05,
2443 class t_ARGS_06,
2444 class t_ARGS_07>
2445struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2446 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2447 t_ARGS_02,
2448 t_ARGS_03,
2449 t_ARGS_04,
2450 t_ARGS_05,
2451 t_ARGS_06,
2452 t_ARGS_07)
2453 const> {
2454 enum {
2455 IS_MEMBER_FUNCTION_PTR = 1,
2456 IS_LVALREF_QUALIFIED = 0,
2457 IS_RVALREF_QUALIFIED = 0,
2458 IS_NOEXCEPT = 0
2459 };
2460 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2461 t_BSLMF_RETURN,
2462 t_TYPE,
2463 t_ARGS_01,
2464 t_ARGS_02,
2465 t_ARGS_03,
2466 t_ARGS_04,
2467 t_ARGS_05,
2468 t_ARGS_06,
2469 t_ARGS_07>::Type
2470 ClassType;
2471 typedef t_BSLMF_RETURN ResultType;
2472 typedef typename TypeList<t_ARGS_01,
2473 t_ARGS_02,
2474 t_ARGS_03,
2475 t_ARGS_04,
2476 t_ARGS_05,
2477 t_ARGS_06,
2478 t_ARGS_07>::Type ArgumentList;
2479};
2480#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
2481
2482#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
2483template <class t_PROTOTYPE,
2484 class t_BSLMF_RETURN,
2485 class t_TYPE,
2486 class t_ARGS_01,
2487 class t_ARGS_02,
2488 class t_ARGS_03,
2489 class t_ARGS_04,
2490 class t_ARGS_05,
2491 class t_ARGS_06,
2492 class t_ARGS_07,
2493 class t_ARGS_08>
2494struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2495 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2496 t_ARGS_02,
2497 t_ARGS_03,
2498 t_ARGS_04,
2499 t_ARGS_05,
2500 t_ARGS_06,
2501 t_ARGS_07,
2502 t_ARGS_08)
2503 const> {
2504 enum {
2505 IS_MEMBER_FUNCTION_PTR = 1,
2506 IS_LVALREF_QUALIFIED = 0,
2507 IS_RVALREF_QUALIFIED = 0,
2508 IS_NOEXCEPT = 0
2509 };
2510 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2511 t_BSLMF_RETURN,
2512 t_TYPE,
2513 t_ARGS_01,
2514 t_ARGS_02,
2515 t_ARGS_03,
2516 t_ARGS_04,
2517 t_ARGS_05,
2518 t_ARGS_06,
2519 t_ARGS_07,
2520 t_ARGS_08>::Type
2521 ClassType;
2522 typedef t_BSLMF_RETURN ResultType;
2523 typedef typename TypeList<t_ARGS_01,
2524 t_ARGS_02,
2525 t_ARGS_03,
2526 t_ARGS_04,
2527 t_ARGS_05,
2528 t_ARGS_06,
2529 t_ARGS_07,
2530 t_ARGS_08>::Type ArgumentList;
2531};
2532#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
2533
2534#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
2535template <class t_PROTOTYPE,
2536 class t_BSLMF_RETURN,
2537 class t_TYPE,
2538 class t_ARGS_01,
2539 class t_ARGS_02,
2540 class t_ARGS_03,
2541 class t_ARGS_04,
2542 class t_ARGS_05,
2543 class t_ARGS_06,
2544 class t_ARGS_07,
2545 class t_ARGS_08,
2546 class t_ARGS_09>
2547struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2548 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2549 t_ARGS_02,
2550 t_ARGS_03,
2551 t_ARGS_04,
2552 t_ARGS_05,
2553 t_ARGS_06,
2554 t_ARGS_07,
2555 t_ARGS_08,
2556 t_ARGS_09)
2557 const> {
2558 enum {
2559 IS_MEMBER_FUNCTION_PTR = 1,
2560 IS_LVALREF_QUALIFIED = 0,
2561 IS_RVALREF_QUALIFIED = 0,
2562 IS_NOEXCEPT = 0
2563 };
2564 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2565 t_BSLMF_RETURN,
2566 t_TYPE,
2567 t_ARGS_01,
2568 t_ARGS_02,
2569 t_ARGS_03,
2570 t_ARGS_04,
2571 t_ARGS_05,
2572 t_ARGS_06,
2573 t_ARGS_07,
2574 t_ARGS_08,
2575 t_ARGS_09>::Type
2576 ClassType;
2577 typedef t_BSLMF_RETURN ResultType;
2578 typedef typename TypeList<t_ARGS_01,
2579 t_ARGS_02,
2580 t_ARGS_03,
2581 t_ARGS_04,
2582 t_ARGS_05,
2583 t_ARGS_06,
2584 t_ARGS_07,
2585 t_ARGS_08,
2586 t_ARGS_09>::Type ArgumentList;
2587};
2588#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
2589
2590#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
2591template <class t_PROTOTYPE,
2592 class t_BSLMF_RETURN,
2593 class t_TYPE,
2594 class t_ARGS_01,
2595 class t_ARGS_02,
2596 class t_ARGS_03,
2597 class t_ARGS_04,
2598 class t_ARGS_05,
2599 class t_ARGS_06,
2600 class t_ARGS_07,
2601 class t_ARGS_08,
2602 class t_ARGS_09,
2603 class t_ARGS_10>
2604struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2605 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2606 t_ARGS_02,
2607 t_ARGS_03,
2608 t_ARGS_04,
2609 t_ARGS_05,
2610 t_ARGS_06,
2611 t_ARGS_07,
2612 t_ARGS_08,
2613 t_ARGS_09,
2614 t_ARGS_10)
2615 const> {
2616 enum {
2617 IS_MEMBER_FUNCTION_PTR = 1,
2618 IS_LVALREF_QUALIFIED = 0,
2619 IS_RVALREF_QUALIFIED = 0,
2620 IS_NOEXCEPT = 0
2621 };
2622 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2623 t_BSLMF_RETURN,
2624 t_TYPE,
2625 t_ARGS_01,
2626 t_ARGS_02,
2627 t_ARGS_03,
2628 t_ARGS_04,
2629 t_ARGS_05,
2630 t_ARGS_06,
2631 t_ARGS_07,
2632 t_ARGS_08,
2633 t_ARGS_09,
2634 t_ARGS_10>::Type
2635 ClassType;
2636 typedef t_BSLMF_RETURN ResultType;
2637 typedef typename TypeList<t_ARGS_01,
2638 t_ARGS_02,
2639 t_ARGS_03,
2640 t_ARGS_04,
2641 t_ARGS_05,
2642 t_ARGS_06,
2643 t_ARGS_07,
2644 t_ARGS_08,
2645 t_ARGS_09,
2646 t_ARGS_10>::Type ArgumentList;
2647};
2648#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
2649
2650#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
2651template <class t_PROTOTYPE,
2652 class t_BSLMF_RETURN,
2653 class t_TYPE,
2654 class t_ARGS_01,
2655 class t_ARGS_02,
2656 class t_ARGS_03,
2657 class t_ARGS_04,
2658 class t_ARGS_05,
2659 class t_ARGS_06,
2660 class t_ARGS_07,
2661 class t_ARGS_08,
2662 class t_ARGS_09,
2663 class t_ARGS_10,
2664 class t_ARGS_11>
2665struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2666 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2667 t_ARGS_02,
2668 t_ARGS_03,
2669 t_ARGS_04,
2670 t_ARGS_05,
2671 t_ARGS_06,
2672 t_ARGS_07,
2673 t_ARGS_08,
2674 t_ARGS_09,
2675 t_ARGS_10,
2676 t_ARGS_11)
2677 const> {
2678 enum {
2679 IS_MEMBER_FUNCTION_PTR = 1,
2680 IS_LVALREF_QUALIFIED = 0,
2681 IS_RVALREF_QUALIFIED = 0,
2682 IS_NOEXCEPT = 0
2683 };
2684 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2685 t_BSLMF_RETURN,
2686 t_TYPE,
2687 t_ARGS_01,
2688 t_ARGS_02,
2689 t_ARGS_03,
2690 t_ARGS_04,
2691 t_ARGS_05,
2692 t_ARGS_06,
2693 t_ARGS_07,
2694 t_ARGS_08,
2695 t_ARGS_09,
2696 t_ARGS_10,
2697 t_ARGS_11>::Type
2698 ClassType;
2699 typedef t_BSLMF_RETURN ResultType;
2700 typedef typename TypeList<t_ARGS_01,
2701 t_ARGS_02,
2702 t_ARGS_03,
2703 t_ARGS_04,
2704 t_ARGS_05,
2705 t_ARGS_06,
2706 t_ARGS_07,
2707 t_ARGS_08,
2708 t_ARGS_09,
2709 t_ARGS_10,
2710 t_ARGS_11>::Type ArgumentList;
2711};
2712#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
2713
2714#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
2715template <class t_PROTOTYPE,
2716 class t_BSLMF_RETURN,
2717 class t_TYPE,
2718 class t_ARGS_01,
2719 class t_ARGS_02,
2720 class t_ARGS_03,
2721 class t_ARGS_04,
2722 class t_ARGS_05,
2723 class t_ARGS_06,
2724 class t_ARGS_07,
2725 class t_ARGS_08,
2726 class t_ARGS_09,
2727 class t_ARGS_10,
2728 class t_ARGS_11,
2729 class t_ARGS_12>
2730struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2731 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2732 t_ARGS_02,
2733 t_ARGS_03,
2734 t_ARGS_04,
2735 t_ARGS_05,
2736 t_ARGS_06,
2737 t_ARGS_07,
2738 t_ARGS_08,
2739 t_ARGS_09,
2740 t_ARGS_10,
2741 t_ARGS_11,
2742 t_ARGS_12)
2743 const> {
2744 enum {
2745 IS_MEMBER_FUNCTION_PTR = 1,
2746 IS_LVALREF_QUALIFIED = 0,
2747 IS_RVALREF_QUALIFIED = 0,
2748 IS_NOEXCEPT = 0
2749 };
2750 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2751 t_BSLMF_RETURN,
2752 t_TYPE,
2753 t_ARGS_01,
2754 t_ARGS_02,
2755 t_ARGS_03,
2756 t_ARGS_04,
2757 t_ARGS_05,
2758 t_ARGS_06,
2759 t_ARGS_07,
2760 t_ARGS_08,
2761 t_ARGS_09,
2762 t_ARGS_10,
2763 t_ARGS_11,
2764 t_ARGS_12>::Type
2765 ClassType;
2766 typedef t_BSLMF_RETURN ResultType;
2767 typedef typename TypeList<t_ARGS_01,
2768 t_ARGS_02,
2769 t_ARGS_03,
2770 t_ARGS_04,
2771 t_ARGS_05,
2772 t_ARGS_06,
2773 t_ARGS_07,
2774 t_ARGS_08,
2775 t_ARGS_09,
2776 t_ARGS_10,
2777 t_ARGS_11,
2778 t_ARGS_12>::Type ArgumentList;
2779};
2780#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
2781
2782#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
2783template <class t_PROTOTYPE,
2784 class t_BSLMF_RETURN,
2785 class t_TYPE,
2786 class t_ARGS_01,
2787 class t_ARGS_02,
2788 class t_ARGS_03,
2789 class t_ARGS_04,
2790 class t_ARGS_05,
2791 class t_ARGS_06,
2792 class t_ARGS_07,
2793 class t_ARGS_08,
2794 class t_ARGS_09,
2795 class t_ARGS_10,
2796 class t_ARGS_11,
2797 class t_ARGS_12,
2798 class t_ARGS_13>
2799struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2800 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2801 t_ARGS_02,
2802 t_ARGS_03,
2803 t_ARGS_04,
2804 t_ARGS_05,
2805 t_ARGS_06,
2806 t_ARGS_07,
2807 t_ARGS_08,
2808 t_ARGS_09,
2809 t_ARGS_10,
2810 t_ARGS_11,
2811 t_ARGS_12,
2812 t_ARGS_13)
2813 const> {
2814 enum {
2815 IS_MEMBER_FUNCTION_PTR = 1,
2816 IS_LVALREF_QUALIFIED = 0,
2817 IS_RVALREF_QUALIFIED = 0,
2818 IS_NOEXCEPT = 0
2819 };
2820 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2821 t_BSLMF_RETURN,
2822 t_TYPE,
2823 t_ARGS_01,
2824 t_ARGS_02,
2825 t_ARGS_03,
2826 t_ARGS_04,
2827 t_ARGS_05,
2828 t_ARGS_06,
2829 t_ARGS_07,
2830 t_ARGS_08,
2831 t_ARGS_09,
2832 t_ARGS_10,
2833 t_ARGS_11,
2834 t_ARGS_12,
2835 t_ARGS_13>::Type
2836 ClassType;
2837 typedef t_BSLMF_RETURN ResultType;
2838 typedef typename TypeList<t_ARGS_01,
2839 t_ARGS_02,
2840 t_ARGS_03,
2841 t_ARGS_04,
2842 t_ARGS_05,
2843 t_ARGS_06,
2844 t_ARGS_07,
2845 t_ARGS_08,
2846 t_ARGS_09,
2847 t_ARGS_10,
2848 t_ARGS_11,
2849 t_ARGS_12,
2850 t_ARGS_13>::Type ArgumentList;
2851};
2852#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
2853
2854#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
2855template <class t_PROTOTYPE,
2856 class t_BSLMF_RETURN,
2857 class t_TYPE,
2858 class t_ARGS_01,
2859 class t_ARGS_02,
2860 class t_ARGS_03,
2861 class t_ARGS_04,
2862 class t_ARGS_05,
2863 class t_ARGS_06,
2864 class t_ARGS_07,
2865 class t_ARGS_08,
2866 class t_ARGS_09,
2867 class t_ARGS_10,
2868 class t_ARGS_11,
2869 class t_ARGS_12,
2870 class t_ARGS_13,
2871 class t_ARGS_14>
2872struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2873 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2874 t_ARGS_02,
2875 t_ARGS_03,
2876 t_ARGS_04,
2877 t_ARGS_05,
2878 t_ARGS_06,
2879 t_ARGS_07,
2880 t_ARGS_08,
2881 t_ARGS_09,
2882 t_ARGS_10,
2883 t_ARGS_11,
2884 t_ARGS_12,
2885 t_ARGS_13,
2886 t_ARGS_14)
2887 const> {
2888 enum {
2889 IS_MEMBER_FUNCTION_PTR = 1,
2890 IS_LVALREF_QUALIFIED = 0,
2891 IS_RVALREF_QUALIFIED = 0,
2892 IS_NOEXCEPT = 0
2893 };
2894 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2895 t_BSLMF_RETURN,
2896 t_TYPE,
2897 t_ARGS_01,
2898 t_ARGS_02,
2899 t_ARGS_03,
2900 t_ARGS_04,
2901 t_ARGS_05,
2902 t_ARGS_06,
2903 t_ARGS_07,
2904 t_ARGS_08,
2905 t_ARGS_09,
2906 t_ARGS_10,
2907 t_ARGS_11,
2908 t_ARGS_12,
2909 t_ARGS_13,
2910 t_ARGS_14>::Type
2911 ClassType;
2912 typedef t_BSLMF_RETURN ResultType;
2913 typedef typename TypeList<t_ARGS_01,
2914 t_ARGS_02,
2915 t_ARGS_03,
2916 t_ARGS_04,
2917 t_ARGS_05,
2918 t_ARGS_06,
2919 t_ARGS_07,
2920 t_ARGS_08,
2921 t_ARGS_09,
2922 t_ARGS_10,
2923 t_ARGS_11,
2924 t_ARGS_12,
2925 t_ARGS_13,
2926 t_ARGS_14>::Type ArgumentList;
2927};
2928#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
2929
2930#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
2931template <class t_PROTOTYPE, class t_BSLMF_RETURN, class t_TYPE>
2932struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2933 t_BSLMF_RETURN (t_TYPE::*)() volatile> {
2934 enum {
2935 IS_MEMBER_FUNCTION_PTR = 1,
2936 IS_LVALREF_QUALIFIED = 0,
2937 IS_RVALREF_QUALIFIED = 0,
2938 IS_NOEXCEPT = 0
2939 };
2940
2941 typedef
2942 typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2943 t_BSLMF_RETURN,
2944 t_TYPE>::Type ClassType;
2945 typedef t_BSLMF_RETURN ResultType;
2946 typedef typename TypeList<>::Type ArgumentList;
2947};
2948#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
2949
2950#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
2951template <class t_PROTOTYPE,
2952 class t_BSLMF_RETURN,
2953 class t_TYPE,
2954 class t_ARGS_01>
2955struct MemberFunctionPointerTraits_Imp<
2956 t_PROTOTYPE,
2957 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01) volatile> {
2958 enum {
2959 IS_MEMBER_FUNCTION_PTR = 1,
2960 IS_LVALREF_QUALIFIED = 0,
2961 IS_RVALREF_QUALIFIED = 0,
2962 IS_NOEXCEPT = 0
2963 };
2964
2965 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2966 t_BSLMF_RETURN,
2967 t_TYPE,
2968 t_ARGS_01>::Type
2969 ClassType;
2970 typedef t_BSLMF_RETURN ResultType;
2971 typedef typename TypeList<t_ARGS_01>::Type ArgumentList;
2972};
2973#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
2974
2975#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
2976template <class t_PROTOTYPE,
2977 class t_BSLMF_RETURN,
2978 class t_TYPE,
2979 class t_ARGS_01,
2980 class t_ARGS_02>
2981struct MemberFunctionPointerTraits_Imp<
2982 t_PROTOTYPE,
2983 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02) volatile> {
2984 enum {
2985 IS_MEMBER_FUNCTION_PTR = 1,
2986 IS_LVALREF_QUALIFIED = 0,
2987 IS_RVALREF_QUALIFIED = 0,
2988 IS_NOEXCEPT = 0
2989 };
2990
2991 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2992 t_BSLMF_RETURN,
2993 t_TYPE,
2994 t_ARGS_01,
2995 t_ARGS_02>::Type
2996 ClassType;
2997 typedef t_BSLMF_RETURN ResultType;
2998 typedef typename TypeList<t_ARGS_01,
2999 t_ARGS_02>::Type ArgumentList;
3000};
3001#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
3002
3003#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
3004template <class t_PROTOTYPE,
3005 class t_BSLMF_RETURN,
3006 class t_TYPE,
3007 class t_ARGS_01,
3008 class t_ARGS_02,
3009 class t_ARGS_03>
3010struct MemberFunctionPointerTraits_Imp<
3011 t_PROTOTYPE,
3012 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03) volatile> {
3013 enum {
3014 IS_MEMBER_FUNCTION_PTR = 1,
3015 IS_LVALREF_QUALIFIED = 0,
3016 IS_RVALREF_QUALIFIED = 0,
3017 IS_NOEXCEPT = 0
3018 };
3019
3020 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3021 t_BSLMF_RETURN,
3022 t_TYPE,
3023 t_ARGS_01,
3024 t_ARGS_02,
3025 t_ARGS_03>::Type
3026 ClassType;
3027 typedef t_BSLMF_RETURN ResultType;
3028 typedef typename TypeList<t_ARGS_01,
3029 t_ARGS_02,
3030 t_ARGS_03>::Type ArgumentList;
3031};
3032#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
3033
3034#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
3035template <class t_PROTOTYPE,
3036 class t_BSLMF_RETURN,
3037 class t_TYPE,
3038 class t_ARGS_01,
3039 class t_ARGS_02,
3040 class t_ARGS_03,
3041 class t_ARGS_04>
3042struct MemberFunctionPointerTraits_Imp<
3043 t_PROTOTYPE,
3044 t_BSLMF_RETURN (
3045 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04) volatile> {
3046 enum {
3047 IS_MEMBER_FUNCTION_PTR = 1,
3048 IS_LVALREF_QUALIFIED = 0,
3049 IS_RVALREF_QUALIFIED = 0,
3050 IS_NOEXCEPT = 0
3051 };
3052
3053 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3054 t_BSLMF_RETURN,
3055 t_TYPE,
3056 t_ARGS_01,
3057 t_ARGS_02,
3058 t_ARGS_03,
3059 t_ARGS_04>::Type
3060 ClassType;
3061 typedef t_BSLMF_RETURN ResultType;
3062 typedef typename TypeList<t_ARGS_01,
3063 t_ARGS_02,
3064 t_ARGS_03,
3065 t_ARGS_04>::Type ArgumentList;
3066};
3067#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
3068
3069#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
3070template <class t_PROTOTYPE,
3071 class t_BSLMF_RETURN,
3072 class t_TYPE,
3073 class t_ARGS_01,
3074 class t_ARGS_02,
3075 class t_ARGS_03,
3076 class t_ARGS_04,
3077 class t_ARGS_05>
3078struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3079 t_BSLMF_RETURN (t_TYPE::*)(
3080 t_ARGS_01,
3081 t_ARGS_02,
3082 t_ARGS_03,
3083 t_ARGS_04,
3084 t_ARGS_05) volatile> {
3085 enum {
3086 IS_MEMBER_FUNCTION_PTR = 1,
3087 IS_LVALREF_QUALIFIED = 0,
3088 IS_RVALREF_QUALIFIED = 0,
3089 IS_NOEXCEPT = 0
3090 };
3091
3092 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3093 t_BSLMF_RETURN,
3094 t_TYPE,
3095 t_ARGS_01,
3096 t_ARGS_02,
3097 t_ARGS_03,
3098 t_ARGS_04,
3099 t_ARGS_05>::Type
3100 ClassType;
3101 typedef t_BSLMF_RETURN ResultType;
3102 typedef typename TypeList<t_ARGS_01,
3103 t_ARGS_02,
3104 t_ARGS_03,
3105 t_ARGS_04,
3106 t_ARGS_05>::Type ArgumentList;
3107};
3108#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
3109
3110#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
3111template <class t_PROTOTYPE,
3112 class t_BSLMF_RETURN,
3113 class t_TYPE,
3114 class t_ARGS_01,
3115 class t_ARGS_02,
3116 class t_ARGS_03,
3117 class t_ARGS_04,
3118 class t_ARGS_05,
3119 class t_ARGS_06>
3120struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3121 t_BSLMF_RETURN (t_TYPE::*)(
3122 t_ARGS_01,
3123 t_ARGS_02,
3124 t_ARGS_03,
3125 t_ARGS_04,
3126 t_ARGS_05,
3127 t_ARGS_06) volatile> {
3128 enum {
3129 IS_MEMBER_FUNCTION_PTR = 1,
3130 IS_LVALREF_QUALIFIED = 0,
3131 IS_RVALREF_QUALIFIED = 0,
3132 IS_NOEXCEPT = 0
3133 };
3134
3135 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3136 t_BSLMF_RETURN,
3137 t_TYPE,
3138 t_ARGS_01,
3139 t_ARGS_02,
3140 t_ARGS_03,
3141 t_ARGS_04,
3142 t_ARGS_05,
3143 t_ARGS_06>::Type
3144 ClassType;
3145 typedef t_BSLMF_RETURN ResultType;
3146 typedef typename TypeList<t_ARGS_01,
3147 t_ARGS_02,
3148 t_ARGS_03,
3149 t_ARGS_04,
3150 t_ARGS_05,
3151 t_ARGS_06>::Type ArgumentList;
3152};
3153#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
3154
3155#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
3156template <class t_PROTOTYPE,
3157 class t_BSLMF_RETURN,
3158 class t_TYPE,
3159 class t_ARGS_01,
3160 class t_ARGS_02,
3161 class t_ARGS_03,
3162 class t_ARGS_04,
3163 class t_ARGS_05,
3164 class t_ARGS_06,
3165 class t_ARGS_07>
3166struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3167 t_BSLMF_RETURN (t_TYPE::*)(
3168 t_ARGS_01,
3169 t_ARGS_02,
3170 t_ARGS_03,
3171 t_ARGS_04,
3172 t_ARGS_05,
3173 t_ARGS_06,
3174 t_ARGS_07) volatile> {
3175 enum {
3176 IS_MEMBER_FUNCTION_PTR = 1,
3177 IS_LVALREF_QUALIFIED = 0,
3178 IS_RVALREF_QUALIFIED = 0,
3179 IS_NOEXCEPT = 0
3180 };
3181
3182 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3183 t_BSLMF_RETURN,
3184 t_TYPE,
3185 t_ARGS_01,
3186 t_ARGS_02,
3187 t_ARGS_03,
3188 t_ARGS_04,
3189 t_ARGS_05,
3190 t_ARGS_06,
3191 t_ARGS_07>::Type
3192 ClassType;
3193 typedef t_BSLMF_RETURN ResultType;
3194 typedef typename TypeList<t_ARGS_01,
3195 t_ARGS_02,
3196 t_ARGS_03,
3197 t_ARGS_04,
3198 t_ARGS_05,
3199 t_ARGS_06,
3200 t_ARGS_07>::Type ArgumentList;
3201};
3202#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
3203
3204#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
3205template <class t_PROTOTYPE,
3206 class t_BSLMF_RETURN,
3207 class t_TYPE,
3208 class t_ARGS_01,
3209 class t_ARGS_02,
3210 class t_ARGS_03,
3211 class t_ARGS_04,
3212 class t_ARGS_05,
3213 class t_ARGS_06,
3214 class t_ARGS_07,
3215 class t_ARGS_08>
3216struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3217 t_BSLMF_RETURN (t_TYPE::*)(
3218 t_ARGS_01,
3219 t_ARGS_02,
3220 t_ARGS_03,
3221 t_ARGS_04,
3222 t_ARGS_05,
3223 t_ARGS_06,
3224 t_ARGS_07,
3225 t_ARGS_08) volatile> {
3226 enum {
3227 IS_MEMBER_FUNCTION_PTR = 1,
3228 IS_LVALREF_QUALIFIED = 0,
3229 IS_RVALREF_QUALIFIED = 0,
3230 IS_NOEXCEPT = 0
3231 };
3232
3233 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3234 t_BSLMF_RETURN,
3235 t_TYPE,
3236 t_ARGS_01,
3237 t_ARGS_02,
3238 t_ARGS_03,
3239 t_ARGS_04,
3240 t_ARGS_05,
3241 t_ARGS_06,
3242 t_ARGS_07,
3243 t_ARGS_08>::Type
3244 ClassType;
3245 typedef t_BSLMF_RETURN ResultType;
3246 typedef typename TypeList<t_ARGS_01,
3247 t_ARGS_02,
3248 t_ARGS_03,
3249 t_ARGS_04,
3250 t_ARGS_05,
3251 t_ARGS_06,
3252 t_ARGS_07,
3253 t_ARGS_08>::Type ArgumentList;
3254};
3255#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
3256
3257#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
3258template <class t_PROTOTYPE,
3259 class t_BSLMF_RETURN,
3260 class t_TYPE,
3261 class t_ARGS_01,
3262 class t_ARGS_02,
3263 class t_ARGS_03,
3264 class t_ARGS_04,
3265 class t_ARGS_05,
3266 class t_ARGS_06,
3267 class t_ARGS_07,
3268 class t_ARGS_08,
3269 class t_ARGS_09>
3270struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3271 t_BSLMF_RETURN (t_TYPE::*)(
3272 t_ARGS_01,
3273 t_ARGS_02,
3274 t_ARGS_03,
3275 t_ARGS_04,
3276 t_ARGS_05,
3277 t_ARGS_06,
3278 t_ARGS_07,
3279 t_ARGS_08,
3280 t_ARGS_09) volatile> {
3281 enum {
3282 IS_MEMBER_FUNCTION_PTR = 1,
3283 IS_LVALREF_QUALIFIED = 0,
3284 IS_RVALREF_QUALIFIED = 0,
3285 IS_NOEXCEPT = 0
3286 };
3287
3288 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3289 t_BSLMF_RETURN,
3290 t_TYPE,
3291 t_ARGS_01,
3292 t_ARGS_02,
3293 t_ARGS_03,
3294 t_ARGS_04,
3295 t_ARGS_05,
3296 t_ARGS_06,
3297 t_ARGS_07,
3298 t_ARGS_08,
3299 t_ARGS_09>::Type
3300 ClassType;
3301 typedef t_BSLMF_RETURN ResultType;
3302 typedef typename TypeList<t_ARGS_01,
3303 t_ARGS_02,
3304 t_ARGS_03,
3305 t_ARGS_04,
3306 t_ARGS_05,
3307 t_ARGS_06,
3308 t_ARGS_07,
3309 t_ARGS_08,
3310 t_ARGS_09>::Type ArgumentList;
3311};
3312#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
3313
3314#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
3315template <class t_PROTOTYPE,
3316 class t_BSLMF_RETURN,
3317 class t_TYPE,
3318 class t_ARGS_01,
3319 class t_ARGS_02,
3320 class t_ARGS_03,
3321 class t_ARGS_04,
3322 class t_ARGS_05,
3323 class t_ARGS_06,
3324 class t_ARGS_07,
3325 class t_ARGS_08,
3326 class t_ARGS_09,
3327 class t_ARGS_10>
3328struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3329 t_BSLMF_RETURN (t_TYPE::*)(
3330 t_ARGS_01,
3331 t_ARGS_02,
3332 t_ARGS_03,
3333 t_ARGS_04,
3334 t_ARGS_05,
3335 t_ARGS_06,
3336 t_ARGS_07,
3337 t_ARGS_08,
3338 t_ARGS_09,
3339 t_ARGS_10) volatile> {
3340 enum {
3341 IS_MEMBER_FUNCTION_PTR = 1,
3342 IS_LVALREF_QUALIFIED = 0,
3343 IS_RVALREF_QUALIFIED = 0,
3344 IS_NOEXCEPT = 0
3345 };
3346
3347 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3348 t_BSLMF_RETURN,
3349 t_TYPE,
3350 t_ARGS_01,
3351 t_ARGS_02,
3352 t_ARGS_03,
3353 t_ARGS_04,
3354 t_ARGS_05,
3355 t_ARGS_06,
3356 t_ARGS_07,
3357 t_ARGS_08,
3358 t_ARGS_09,
3359 t_ARGS_10>::Type
3360 ClassType;
3361 typedef t_BSLMF_RETURN ResultType;
3362 typedef typename TypeList<t_ARGS_01,
3363 t_ARGS_02,
3364 t_ARGS_03,
3365 t_ARGS_04,
3366 t_ARGS_05,
3367 t_ARGS_06,
3368 t_ARGS_07,
3369 t_ARGS_08,
3370 t_ARGS_09,
3371 t_ARGS_10>::Type ArgumentList;
3372};
3373#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
3374
3375#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
3376template <class t_PROTOTYPE,
3377 class t_BSLMF_RETURN,
3378 class t_TYPE,
3379 class t_ARGS_01,
3380 class t_ARGS_02,
3381 class t_ARGS_03,
3382 class t_ARGS_04,
3383 class t_ARGS_05,
3384 class t_ARGS_06,
3385 class t_ARGS_07,
3386 class t_ARGS_08,
3387 class t_ARGS_09,
3388 class t_ARGS_10,
3389 class t_ARGS_11>
3390struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3391 t_BSLMF_RETURN (t_TYPE::*)(
3392 t_ARGS_01,
3393 t_ARGS_02,
3394 t_ARGS_03,
3395 t_ARGS_04,
3396 t_ARGS_05,
3397 t_ARGS_06,
3398 t_ARGS_07,
3399 t_ARGS_08,
3400 t_ARGS_09,
3401 t_ARGS_10,
3402 t_ARGS_11) volatile> {
3403 enum {
3404 IS_MEMBER_FUNCTION_PTR = 1,
3405 IS_LVALREF_QUALIFIED = 0,
3406 IS_RVALREF_QUALIFIED = 0,
3407 IS_NOEXCEPT = 0
3408 };
3409
3410 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3411 t_BSLMF_RETURN,
3412 t_TYPE,
3413 t_ARGS_01,
3414 t_ARGS_02,
3415 t_ARGS_03,
3416 t_ARGS_04,
3417 t_ARGS_05,
3418 t_ARGS_06,
3419 t_ARGS_07,
3420 t_ARGS_08,
3421 t_ARGS_09,
3422 t_ARGS_10,
3423 t_ARGS_11>::Type
3424 ClassType;
3425 typedef t_BSLMF_RETURN ResultType;
3426 typedef typename TypeList<t_ARGS_01,
3427 t_ARGS_02,
3428 t_ARGS_03,
3429 t_ARGS_04,
3430 t_ARGS_05,
3431 t_ARGS_06,
3432 t_ARGS_07,
3433 t_ARGS_08,
3434 t_ARGS_09,
3435 t_ARGS_10,
3436 t_ARGS_11>::Type ArgumentList;
3437};
3438#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
3439
3440#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
3441template <class t_PROTOTYPE,
3442 class t_BSLMF_RETURN,
3443 class t_TYPE,
3444 class t_ARGS_01,
3445 class t_ARGS_02,
3446 class t_ARGS_03,
3447 class t_ARGS_04,
3448 class t_ARGS_05,
3449 class t_ARGS_06,
3450 class t_ARGS_07,
3451 class t_ARGS_08,
3452 class t_ARGS_09,
3453 class t_ARGS_10,
3454 class t_ARGS_11,
3455 class t_ARGS_12>
3456struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3457 t_BSLMF_RETURN (t_TYPE::*)(
3458 t_ARGS_01,
3459 t_ARGS_02,
3460 t_ARGS_03,
3461 t_ARGS_04,
3462 t_ARGS_05,
3463 t_ARGS_06,
3464 t_ARGS_07,
3465 t_ARGS_08,
3466 t_ARGS_09,
3467 t_ARGS_10,
3468 t_ARGS_11,
3469 t_ARGS_12) volatile> {
3470 enum {
3471 IS_MEMBER_FUNCTION_PTR = 1,
3472 IS_LVALREF_QUALIFIED = 0,
3473 IS_RVALREF_QUALIFIED = 0,
3474 IS_NOEXCEPT = 0
3475 };
3476
3477 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3478 t_BSLMF_RETURN,
3479 t_TYPE,
3480 t_ARGS_01,
3481 t_ARGS_02,
3482 t_ARGS_03,
3483 t_ARGS_04,
3484 t_ARGS_05,
3485 t_ARGS_06,
3486 t_ARGS_07,
3487 t_ARGS_08,
3488 t_ARGS_09,
3489 t_ARGS_10,
3490 t_ARGS_11,
3491 t_ARGS_12>::Type
3492 ClassType;
3493 typedef t_BSLMF_RETURN ResultType;
3494 typedef typename TypeList<t_ARGS_01,
3495 t_ARGS_02,
3496 t_ARGS_03,
3497 t_ARGS_04,
3498 t_ARGS_05,
3499 t_ARGS_06,
3500 t_ARGS_07,
3501 t_ARGS_08,
3502 t_ARGS_09,
3503 t_ARGS_10,
3504 t_ARGS_11,
3505 t_ARGS_12>::Type ArgumentList;
3506};
3507#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
3508
3509#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
3510template <class t_PROTOTYPE,
3511 class t_BSLMF_RETURN,
3512 class t_TYPE,
3513 class t_ARGS_01,
3514 class t_ARGS_02,
3515 class t_ARGS_03,
3516 class t_ARGS_04,
3517 class t_ARGS_05,
3518 class t_ARGS_06,
3519 class t_ARGS_07,
3520 class t_ARGS_08,
3521 class t_ARGS_09,
3522 class t_ARGS_10,
3523 class t_ARGS_11,
3524 class t_ARGS_12,
3525 class t_ARGS_13>
3526struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3527 t_BSLMF_RETURN (t_TYPE::*)(
3528 t_ARGS_01,
3529 t_ARGS_02,
3530 t_ARGS_03,
3531 t_ARGS_04,
3532 t_ARGS_05,
3533 t_ARGS_06,
3534 t_ARGS_07,
3535 t_ARGS_08,
3536 t_ARGS_09,
3537 t_ARGS_10,
3538 t_ARGS_11,
3539 t_ARGS_12,
3540 t_ARGS_13) volatile> {
3541 enum {
3542 IS_MEMBER_FUNCTION_PTR = 1,
3543 IS_LVALREF_QUALIFIED = 0,
3544 IS_RVALREF_QUALIFIED = 0,
3545 IS_NOEXCEPT = 0
3546 };
3547
3548 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3549 t_BSLMF_RETURN,
3550 t_TYPE,
3551 t_ARGS_01,
3552 t_ARGS_02,
3553 t_ARGS_03,
3554 t_ARGS_04,
3555 t_ARGS_05,
3556 t_ARGS_06,
3557 t_ARGS_07,
3558 t_ARGS_08,
3559 t_ARGS_09,
3560 t_ARGS_10,
3561 t_ARGS_11,
3562 t_ARGS_12,
3563 t_ARGS_13>::Type
3564 ClassType;
3565 typedef t_BSLMF_RETURN ResultType;
3566 typedef typename TypeList<t_ARGS_01,
3567 t_ARGS_02,
3568 t_ARGS_03,
3569 t_ARGS_04,
3570 t_ARGS_05,
3571 t_ARGS_06,
3572 t_ARGS_07,
3573 t_ARGS_08,
3574 t_ARGS_09,
3575 t_ARGS_10,
3576 t_ARGS_11,
3577 t_ARGS_12,
3578 t_ARGS_13>::Type ArgumentList;
3579};
3580#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
3581
3582#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
3583template <class t_PROTOTYPE,
3584 class t_BSLMF_RETURN,
3585 class t_TYPE,
3586 class t_ARGS_01,
3587 class t_ARGS_02,
3588 class t_ARGS_03,
3589 class t_ARGS_04,
3590 class t_ARGS_05,
3591 class t_ARGS_06,
3592 class t_ARGS_07,
3593 class t_ARGS_08,
3594 class t_ARGS_09,
3595 class t_ARGS_10,
3596 class t_ARGS_11,
3597 class t_ARGS_12,
3598 class t_ARGS_13,
3599 class t_ARGS_14>
3600struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3601 t_BSLMF_RETURN (t_TYPE::*)(
3602 t_ARGS_01,
3603 t_ARGS_02,
3604 t_ARGS_03,
3605 t_ARGS_04,
3606 t_ARGS_05,
3607 t_ARGS_06,
3608 t_ARGS_07,
3609 t_ARGS_08,
3610 t_ARGS_09,
3611 t_ARGS_10,
3612 t_ARGS_11,
3613 t_ARGS_12,
3614 t_ARGS_13,
3615 t_ARGS_14) volatile> {
3616 enum {
3617 IS_MEMBER_FUNCTION_PTR = 1,
3618 IS_LVALREF_QUALIFIED = 0,
3619 IS_RVALREF_QUALIFIED = 0,
3620 IS_NOEXCEPT = 0
3621 };
3622
3623 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3624 t_BSLMF_RETURN,
3625 t_TYPE,
3626 t_ARGS_01,
3627 t_ARGS_02,
3628 t_ARGS_03,
3629 t_ARGS_04,
3630 t_ARGS_05,
3631 t_ARGS_06,
3632 t_ARGS_07,
3633 t_ARGS_08,
3634 t_ARGS_09,
3635 t_ARGS_10,
3636 t_ARGS_11,
3637 t_ARGS_12,
3638 t_ARGS_13,
3639 t_ARGS_14>::Type
3640 ClassType;
3641 typedef t_BSLMF_RETURN ResultType;
3642 typedef typename TypeList<t_ARGS_01,
3643 t_ARGS_02,
3644 t_ARGS_03,
3645 t_ARGS_04,
3646 t_ARGS_05,
3647 t_ARGS_06,
3648 t_ARGS_07,
3649 t_ARGS_08,
3650 t_ARGS_09,
3651 t_ARGS_10,
3652 t_ARGS_11,
3653 t_ARGS_12,
3654 t_ARGS_13,
3655 t_ARGS_14>::Type ArgumentList;
3656};
3657#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
3658
3659#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
3660template <class t_PROTOTYPE, class t_BSLMF_RETURN, class t_TYPE>
3661struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3662 t_BSLMF_RETURN (t_TYPE::*)()
3663 const volatile> {
3664 enum {
3665 IS_MEMBER_FUNCTION_PTR = 1,
3666 IS_LVALREF_QUALIFIED = 0,
3667 IS_RVALREF_QUALIFIED = 0,
3668 IS_NOEXCEPT = 0
3669 };
3670 typedef
3671 typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3672 t_BSLMF_RETURN,
3673 t_TYPE>::Type ClassType;
3674 typedef t_BSLMF_RETURN ResultType;
3675 typedef typename TypeList<>::Type ArgumentList;
3676};
3677#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
3678
3679#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
3680template <class t_PROTOTYPE,
3681 class t_BSLMF_RETURN,
3682 class t_TYPE,
3683 class t_ARGS_01>
3684struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3685 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01)
3686 const volatile> {
3687 enum {
3688 IS_MEMBER_FUNCTION_PTR = 1,
3689 IS_LVALREF_QUALIFIED = 0,
3690 IS_RVALREF_QUALIFIED = 0,
3691 IS_NOEXCEPT = 0
3692 };
3693 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3694 t_BSLMF_RETURN,
3695 t_TYPE,
3696 t_ARGS_01>::Type
3697 ClassType;
3698 typedef t_BSLMF_RETURN ResultType;
3699 typedef typename TypeList<t_ARGS_01>::Type ArgumentList;
3700};
3701#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
3702
3703#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
3704template <class t_PROTOTYPE,
3705 class t_BSLMF_RETURN,
3706 class t_TYPE,
3707 class t_ARGS_01,
3708 class t_ARGS_02>
3709struct MemberFunctionPointerTraits_Imp<
3710 t_PROTOTYPE,
3711 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02) const volatile> {
3712 enum {
3713 IS_MEMBER_FUNCTION_PTR = 1,
3714 IS_LVALREF_QUALIFIED = 0,
3715 IS_RVALREF_QUALIFIED = 0,
3716 IS_NOEXCEPT = 0
3717 };
3718 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3719 t_BSLMF_RETURN,
3720 t_TYPE,
3721 t_ARGS_01,
3722 t_ARGS_02>::Type
3723 ClassType;
3724 typedef t_BSLMF_RETURN ResultType;
3725 typedef typename TypeList<t_ARGS_01,
3726 t_ARGS_02>::Type ArgumentList;
3727};
3728#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
3729
3730#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
3731template <class t_PROTOTYPE,
3732 class t_BSLMF_RETURN,
3733 class t_TYPE,
3734 class t_ARGS_01,
3735 class t_ARGS_02,
3736 class t_ARGS_03>
3737struct MemberFunctionPointerTraits_Imp<
3738 t_PROTOTYPE,
3739 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03)
3740 const volatile> {
3741 enum {
3742 IS_MEMBER_FUNCTION_PTR = 1,
3743 IS_LVALREF_QUALIFIED = 0,
3744 IS_RVALREF_QUALIFIED = 0,
3745 IS_NOEXCEPT = 0
3746 };
3747 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3748 t_BSLMF_RETURN,
3749 t_TYPE,
3750 t_ARGS_01,
3751 t_ARGS_02,
3752 t_ARGS_03>::Type
3753 ClassType;
3754 typedef t_BSLMF_RETURN ResultType;
3755 typedef typename TypeList<t_ARGS_01,
3756 t_ARGS_02,
3757 t_ARGS_03>::Type ArgumentList;
3758};
3759#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
3760
3761#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
3762template <class t_PROTOTYPE,
3763 class t_BSLMF_RETURN,
3764 class t_TYPE,
3765 class t_ARGS_01,
3766 class t_ARGS_02,
3767 class t_ARGS_03,
3768 class t_ARGS_04>
3769struct MemberFunctionPointerTraits_Imp<
3770 t_PROTOTYPE,
3771 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04)
3772 const volatile> {
3773 enum {
3774 IS_MEMBER_FUNCTION_PTR = 1,
3775 IS_LVALREF_QUALIFIED = 0,
3776 IS_RVALREF_QUALIFIED = 0,
3777 IS_NOEXCEPT = 0
3778 };
3779 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3780 t_BSLMF_RETURN,
3781 t_TYPE,
3782 t_ARGS_01,
3783 t_ARGS_02,
3784 t_ARGS_03,
3785 t_ARGS_04>::Type
3786 ClassType;
3787 typedef t_BSLMF_RETURN ResultType;
3788 typedef typename TypeList<t_ARGS_01,
3789 t_ARGS_02,
3790 t_ARGS_03,
3791 t_ARGS_04>::Type ArgumentList;
3792};
3793#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
3794
3795#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
3796template <class t_PROTOTYPE,
3797 class t_BSLMF_RETURN,
3798 class t_TYPE,
3799 class t_ARGS_01,
3800 class t_ARGS_02,
3801 class t_ARGS_03,
3802 class t_ARGS_04,
3803 class t_ARGS_05>
3804struct MemberFunctionPointerTraits_Imp<
3805 t_PROTOTYPE,
3806 t_BSLMF_RETURN (
3807 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04, t_ARGS_05)
3808 const volatile> {
3809 enum {
3810 IS_MEMBER_FUNCTION_PTR = 1,
3811 IS_LVALREF_QUALIFIED = 0,
3812 IS_RVALREF_QUALIFIED = 0,
3813 IS_NOEXCEPT = 0
3814 };
3815 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3816 t_BSLMF_RETURN,
3817 t_TYPE,
3818 t_ARGS_01,
3819 t_ARGS_02,
3820 t_ARGS_03,
3821 t_ARGS_04,
3822 t_ARGS_05>::Type
3823 ClassType;
3824 typedef t_BSLMF_RETURN ResultType;
3825 typedef typename TypeList<t_ARGS_01,
3826 t_ARGS_02,
3827 t_ARGS_03,
3828 t_ARGS_04,
3829 t_ARGS_05>::Type ArgumentList;
3830};
3831#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
3832
3833#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
3834template <class t_PROTOTYPE,
3835 class t_BSLMF_RETURN,
3836 class t_TYPE,
3837 class t_ARGS_01,
3838 class t_ARGS_02,
3839 class t_ARGS_03,
3840 class t_ARGS_04,
3841 class t_ARGS_05,
3842 class t_ARGS_06>
3843struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3844 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
3845 t_ARGS_02,
3846 t_ARGS_03,
3847 t_ARGS_04,
3848 t_ARGS_05,
3849 t_ARGS_06)
3850 const volatile> {
3851 enum {
3852 IS_MEMBER_FUNCTION_PTR = 1,
3853 IS_LVALREF_QUALIFIED = 0,
3854 IS_RVALREF_QUALIFIED = 0,
3855 IS_NOEXCEPT = 0
3856 };
3857 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3858 t_BSLMF_RETURN,
3859 t_TYPE,
3860 t_ARGS_01,
3861 t_ARGS_02,
3862 t_ARGS_03,
3863 t_ARGS_04,
3864 t_ARGS_05,
3865 t_ARGS_06>::Type
3866 ClassType;
3867 typedef t_BSLMF_RETURN ResultType;
3868 typedef typename TypeList<t_ARGS_01,
3869 t_ARGS_02,
3870 t_ARGS_03,
3871 t_ARGS_04,
3872 t_ARGS_05,
3873 t_ARGS_06>::Type ArgumentList;
3874};
3875#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
3876
3877#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
3878template <class t_PROTOTYPE,
3879 class t_BSLMF_RETURN,
3880 class t_TYPE,
3881 class t_ARGS_01,
3882 class t_ARGS_02,
3883 class t_ARGS_03,
3884 class t_ARGS_04,
3885 class t_ARGS_05,
3886 class t_ARGS_06,
3887 class t_ARGS_07>
3888struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3889 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
3890 t_ARGS_02,
3891 t_ARGS_03,
3892 t_ARGS_04,
3893 t_ARGS_05,
3894 t_ARGS_06,
3895 t_ARGS_07)
3896 const volatile> {
3897 enum {
3898 IS_MEMBER_FUNCTION_PTR = 1,
3899 IS_LVALREF_QUALIFIED = 0,
3900 IS_RVALREF_QUALIFIED = 0,
3901 IS_NOEXCEPT = 0
3902 };
3903 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3904 t_BSLMF_RETURN,
3905 t_TYPE,
3906 t_ARGS_01,
3907 t_ARGS_02,
3908 t_ARGS_03,
3909 t_ARGS_04,
3910 t_ARGS_05,
3911 t_ARGS_06,
3912 t_ARGS_07>::Type
3913 ClassType;
3914 typedef t_BSLMF_RETURN ResultType;
3915 typedef typename TypeList<t_ARGS_01,
3916 t_ARGS_02,
3917 t_ARGS_03,
3918 t_ARGS_04,
3919 t_ARGS_05,
3920 t_ARGS_06,
3921 t_ARGS_07>::Type ArgumentList;
3922};
3923#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
3924
3925#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
3926template <class t_PROTOTYPE,
3927 class t_BSLMF_RETURN,
3928 class t_TYPE,
3929 class t_ARGS_01,
3930 class t_ARGS_02,
3931 class t_ARGS_03,
3932 class t_ARGS_04,
3933 class t_ARGS_05,
3934 class t_ARGS_06,
3935 class t_ARGS_07,
3936 class t_ARGS_08>
3937struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3938 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
3939 t_ARGS_02,
3940 t_ARGS_03,
3941 t_ARGS_04,
3942 t_ARGS_05,
3943 t_ARGS_06,
3944 t_ARGS_07,
3945 t_ARGS_08)
3946 const volatile> {
3947 enum {
3948 IS_MEMBER_FUNCTION_PTR = 1,
3949 IS_LVALREF_QUALIFIED = 0,
3950 IS_RVALREF_QUALIFIED = 0,
3951 IS_NOEXCEPT = 0
3952 };
3953 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3954 t_BSLMF_RETURN,
3955 t_TYPE,
3956 t_ARGS_01,
3957 t_ARGS_02,
3958 t_ARGS_03,
3959 t_ARGS_04,
3960 t_ARGS_05,
3961 t_ARGS_06,
3962 t_ARGS_07,
3963 t_ARGS_08>::Type
3964 ClassType;
3965 typedef t_BSLMF_RETURN ResultType;
3966 typedef typename TypeList<t_ARGS_01,
3967 t_ARGS_02,
3968 t_ARGS_03,
3969 t_ARGS_04,
3970 t_ARGS_05,
3971 t_ARGS_06,
3972 t_ARGS_07,
3973 t_ARGS_08>::Type ArgumentList;
3974};
3975#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
3976
3977#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
3978template <class t_PROTOTYPE,
3979 class t_BSLMF_RETURN,
3980 class t_TYPE,
3981 class t_ARGS_01,
3982 class t_ARGS_02,
3983 class t_ARGS_03,
3984 class t_ARGS_04,
3985 class t_ARGS_05,
3986 class t_ARGS_06,
3987 class t_ARGS_07,
3988 class t_ARGS_08,
3989 class t_ARGS_09>
3990struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3991 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
3992 t_ARGS_02,
3993 t_ARGS_03,
3994 t_ARGS_04,
3995 t_ARGS_05,
3996 t_ARGS_06,
3997 t_ARGS_07,
3998 t_ARGS_08,
3999 t_ARGS_09)
4000 const volatile> {
4001 enum {
4002 IS_MEMBER_FUNCTION_PTR = 1,
4003 IS_LVALREF_QUALIFIED = 0,
4004 IS_RVALREF_QUALIFIED = 0,
4005 IS_NOEXCEPT = 0
4006 };
4007 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4008 t_BSLMF_RETURN,
4009 t_TYPE,
4010 t_ARGS_01,
4011 t_ARGS_02,
4012 t_ARGS_03,
4013 t_ARGS_04,
4014 t_ARGS_05,
4015 t_ARGS_06,
4016 t_ARGS_07,
4017 t_ARGS_08,
4018 t_ARGS_09>::Type
4019 ClassType;
4020 typedef t_BSLMF_RETURN ResultType;
4021 typedef typename TypeList<t_ARGS_01,
4022 t_ARGS_02,
4023 t_ARGS_03,
4024 t_ARGS_04,
4025 t_ARGS_05,
4026 t_ARGS_06,
4027 t_ARGS_07,
4028 t_ARGS_08,
4029 t_ARGS_09>::Type ArgumentList;
4030};
4031#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
4032
4033#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
4034template <class t_PROTOTYPE,
4035 class t_BSLMF_RETURN,
4036 class t_TYPE,
4037 class t_ARGS_01,
4038 class t_ARGS_02,
4039 class t_ARGS_03,
4040 class t_ARGS_04,
4041 class t_ARGS_05,
4042 class t_ARGS_06,
4043 class t_ARGS_07,
4044 class t_ARGS_08,
4045 class t_ARGS_09,
4046 class t_ARGS_10>
4047struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4048 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4049 t_ARGS_02,
4050 t_ARGS_03,
4051 t_ARGS_04,
4052 t_ARGS_05,
4053 t_ARGS_06,
4054 t_ARGS_07,
4055 t_ARGS_08,
4056 t_ARGS_09,
4057 t_ARGS_10)
4058 const volatile> {
4059 enum {
4060 IS_MEMBER_FUNCTION_PTR = 1,
4061 IS_LVALREF_QUALIFIED = 0,
4062 IS_RVALREF_QUALIFIED = 0,
4063 IS_NOEXCEPT = 0
4064 };
4065 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4066 t_BSLMF_RETURN,
4067 t_TYPE,
4068 t_ARGS_01,
4069 t_ARGS_02,
4070 t_ARGS_03,
4071 t_ARGS_04,
4072 t_ARGS_05,
4073 t_ARGS_06,
4074 t_ARGS_07,
4075 t_ARGS_08,
4076 t_ARGS_09,
4077 t_ARGS_10>::Type
4078 ClassType;
4079 typedef t_BSLMF_RETURN ResultType;
4080 typedef typename TypeList<t_ARGS_01,
4081 t_ARGS_02,
4082 t_ARGS_03,
4083 t_ARGS_04,
4084 t_ARGS_05,
4085 t_ARGS_06,
4086 t_ARGS_07,
4087 t_ARGS_08,
4088 t_ARGS_09,
4089 t_ARGS_10>::Type ArgumentList;
4090};
4091#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
4092
4093#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
4094template <class t_PROTOTYPE,
4095 class t_BSLMF_RETURN,
4096 class t_TYPE,
4097 class t_ARGS_01,
4098 class t_ARGS_02,
4099 class t_ARGS_03,
4100 class t_ARGS_04,
4101 class t_ARGS_05,
4102 class t_ARGS_06,
4103 class t_ARGS_07,
4104 class t_ARGS_08,
4105 class t_ARGS_09,
4106 class t_ARGS_10,
4107 class t_ARGS_11>
4108struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4109 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4110 t_ARGS_02,
4111 t_ARGS_03,
4112 t_ARGS_04,
4113 t_ARGS_05,
4114 t_ARGS_06,
4115 t_ARGS_07,
4116 t_ARGS_08,
4117 t_ARGS_09,
4118 t_ARGS_10,
4119 t_ARGS_11)
4120 const volatile> {
4121 enum {
4122 IS_MEMBER_FUNCTION_PTR = 1,
4123 IS_LVALREF_QUALIFIED = 0,
4124 IS_RVALREF_QUALIFIED = 0,
4125 IS_NOEXCEPT = 0
4126 };
4127 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4128 t_BSLMF_RETURN,
4129 t_TYPE,
4130 t_ARGS_01,
4131 t_ARGS_02,
4132 t_ARGS_03,
4133 t_ARGS_04,
4134 t_ARGS_05,
4135 t_ARGS_06,
4136 t_ARGS_07,
4137 t_ARGS_08,
4138 t_ARGS_09,
4139 t_ARGS_10,
4140 t_ARGS_11>::Type
4141 ClassType;
4142 typedef t_BSLMF_RETURN ResultType;
4143 typedef typename TypeList<t_ARGS_01,
4144 t_ARGS_02,
4145 t_ARGS_03,
4146 t_ARGS_04,
4147 t_ARGS_05,
4148 t_ARGS_06,
4149 t_ARGS_07,
4150 t_ARGS_08,
4151 t_ARGS_09,
4152 t_ARGS_10,
4153 t_ARGS_11>::Type ArgumentList;
4154};
4155#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
4156
4157#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
4158template <class t_PROTOTYPE,
4159 class t_BSLMF_RETURN,
4160 class t_TYPE,
4161 class t_ARGS_01,
4162 class t_ARGS_02,
4163 class t_ARGS_03,
4164 class t_ARGS_04,
4165 class t_ARGS_05,
4166 class t_ARGS_06,
4167 class t_ARGS_07,
4168 class t_ARGS_08,
4169 class t_ARGS_09,
4170 class t_ARGS_10,
4171 class t_ARGS_11,
4172 class t_ARGS_12>
4173struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4174 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4175 t_ARGS_02,
4176 t_ARGS_03,
4177 t_ARGS_04,
4178 t_ARGS_05,
4179 t_ARGS_06,
4180 t_ARGS_07,
4181 t_ARGS_08,
4182 t_ARGS_09,
4183 t_ARGS_10,
4184 t_ARGS_11,
4185 t_ARGS_12)
4186 const volatile> {
4187 enum {
4188 IS_MEMBER_FUNCTION_PTR = 1,
4189 IS_LVALREF_QUALIFIED = 0,
4190 IS_RVALREF_QUALIFIED = 0,
4191 IS_NOEXCEPT = 0
4192 };
4193 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4194 t_BSLMF_RETURN,
4195 t_TYPE,
4196 t_ARGS_01,
4197 t_ARGS_02,
4198 t_ARGS_03,
4199 t_ARGS_04,
4200 t_ARGS_05,
4201 t_ARGS_06,
4202 t_ARGS_07,
4203 t_ARGS_08,
4204 t_ARGS_09,
4205 t_ARGS_10,
4206 t_ARGS_11,
4207 t_ARGS_12>::Type
4208 ClassType;
4209 typedef t_BSLMF_RETURN ResultType;
4210 typedef typename TypeList<t_ARGS_01,
4211 t_ARGS_02,
4212 t_ARGS_03,
4213 t_ARGS_04,
4214 t_ARGS_05,
4215 t_ARGS_06,
4216 t_ARGS_07,
4217 t_ARGS_08,
4218 t_ARGS_09,
4219 t_ARGS_10,
4220 t_ARGS_11,
4221 t_ARGS_12>::Type ArgumentList;
4222};
4223#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
4224
4225#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
4226template <class t_PROTOTYPE,
4227 class t_BSLMF_RETURN,
4228 class t_TYPE,
4229 class t_ARGS_01,
4230 class t_ARGS_02,
4231 class t_ARGS_03,
4232 class t_ARGS_04,
4233 class t_ARGS_05,
4234 class t_ARGS_06,
4235 class t_ARGS_07,
4236 class t_ARGS_08,
4237 class t_ARGS_09,
4238 class t_ARGS_10,
4239 class t_ARGS_11,
4240 class t_ARGS_12,
4241 class t_ARGS_13>
4242struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4243 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4244 t_ARGS_02,
4245 t_ARGS_03,
4246 t_ARGS_04,
4247 t_ARGS_05,
4248 t_ARGS_06,
4249 t_ARGS_07,
4250 t_ARGS_08,
4251 t_ARGS_09,
4252 t_ARGS_10,
4253 t_ARGS_11,
4254 t_ARGS_12,
4255 t_ARGS_13)
4256 const volatile> {
4257 enum {
4258 IS_MEMBER_FUNCTION_PTR = 1,
4259 IS_LVALREF_QUALIFIED = 0,
4260 IS_RVALREF_QUALIFIED = 0,
4261 IS_NOEXCEPT = 0
4262 };
4263 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4264 t_BSLMF_RETURN,
4265 t_TYPE,
4266 t_ARGS_01,
4267 t_ARGS_02,
4268 t_ARGS_03,
4269 t_ARGS_04,
4270 t_ARGS_05,
4271 t_ARGS_06,
4272 t_ARGS_07,
4273 t_ARGS_08,
4274 t_ARGS_09,
4275 t_ARGS_10,
4276 t_ARGS_11,
4277 t_ARGS_12,
4278 t_ARGS_13>::Type
4279 ClassType;
4280 typedef t_BSLMF_RETURN ResultType;
4281 typedef typename TypeList<t_ARGS_01,
4282 t_ARGS_02,
4283 t_ARGS_03,
4284 t_ARGS_04,
4285 t_ARGS_05,
4286 t_ARGS_06,
4287 t_ARGS_07,
4288 t_ARGS_08,
4289 t_ARGS_09,
4290 t_ARGS_10,
4291 t_ARGS_11,
4292 t_ARGS_12,
4293 t_ARGS_13>::Type ArgumentList;
4294};
4295#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
4296
4297#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
4298template <class t_PROTOTYPE,
4299 class t_BSLMF_RETURN,
4300 class t_TYPE,
4301 class t_ARGS_01,
4302 class t_ARGS_02,
4303 class t_ARGS_03,
4304 class t_ARGS_04,
4305 class t_ARGS_05,
4306 class t_ARGS_06,
4307 class t_ARGS_07,
4308 class t_ARGS_08,
4309 class t_ARGS_09,
4310 class t_ARGS_10,
4311 class t_ARGS_11,
4312 class t_ARGS_12,
4313 class t_ARGS_13,
4314 class t_ARGS_14>
4315struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4316 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4317 t_ARGS_02,
4318 t_ARGS_03,
4319 t_ARGS_04,
4320 t_ARGS_05,
4321 t_ARGS_06,
4322 t_ARGS_07,
4323 t_ARGS_08,
4324 t_ARGS_09,
4325 t_ARGS_10,
4326 t_ARGS_11,
4327 t_ARGS_12,
4328 t_ARGS_13,
4329 t_ARGS_14)
4330 const volatile> {
4331 enum {
4332 IS_MEMBER_FUNCTION_PTR = 1,
4333 IS_LVALREF_QUALIFIED = 0,
4334 IS_RVALREF_QUALIFIED = 0,
4335 IS_NOEXCEPT = 0
4336 };
4337 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4338 t_BSLMF_RETURN,
4339 t_TYPE,
4340 t_ARGS_01,
4341 t_ARGS_02,
4342 t_ARGS_03,
4343 t_ARGS_04,
4344 t_ARGS_05,
4345 t_ARGS_06,
4346 t_ARGS_07,
4347 t_ARGS_08,
4348 t_ARGS_09,
4349 t_ARGS_10,
4350 t_ARGS_11,
4351 t_ARGS_12,
4352 t_ARGS_13,
4353 t_ARGS_14>::Type
4354 ClassType;
4355 typedef t_BSLMF_RETURN ResultType;
4356 typedef typename TypeList<t_ARGS_01,
4357 t_ARGS_02,
4358 t_ARGS_03,
4359 t_ARGS_04,
4360 t_ARGS_05,
4361 t_ARGS_06,
4362 t_ARGS_07,
4363 t_ARGS_08,
4364 t_ARGS_09,
4365 t_ARGS_10,
4366 t_ARGS_11,
4367 t_ARGS_12,
4368 t_ARGS_13,
4369 t_ARGS_14>::Type ArgumentList;
4370};
4371#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
4372
4373#else // BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
4374// The generated code below is a workaround for the absence of perfect
4375// forwarding in some compilers.
4376template <class t_PROTOTYPE,
4377 class t_BSLMF_RETURN,
4378 class t_TYPE,
4379 class... t_ARGS>
4380struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4381 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)> {
4382 enum {
4383 IS_MEMBER_FUNCTION_PTR = 1,
4384 IS_LVALREF_QUALIFIED = 0,
4385 IS_RVALREF_QUALIFIED = 0,
4386 IS_NOEXCEPT = 0
4387 };
4388 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4389 t_BSLMF_RETURN,
4390 t_TYPE,
4391 t_ARGS...>::Type
4392 ClassType;
4393 typedef t_BSLMF_RETURN ResultType;
4394 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4395};
4396
4397template <class t_PROTOTYPE,
4398 class t_BSLMF_RETURN,
4399 class t_TYPE,
4400 class... t_ARGS>
4401struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4402 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4403 const> {
4404 enum {
4405 IS_MEMBER_FUNCTION_PTR = 1,
4406 IS_LVALREF_QUALIFIED = 0,
4407 IS_RVALREF_QUALIFIED = 0,
4408 IS_NOEXCEPT = 0
4409 };
4410 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4411 t_BSLMF_RETURN,
4412 t_TYPE,
4413 t_ARGS...>::Type
4414 ClassType;
4415 typedef t_BSLMF_RETURN ResultType;
4416 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4417};
4418
4419template <class t_PROTOTYPE,
4420 class t_BSLMF_RETURN,
4421 class t_TYPE,
4422 class... t_ARGS>
4423struct MemberFunctionPointerTraits_Imp<
4424 t_PROTOTYPE,
4425 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile> {
4426 enum {
4427 IS_MEMBER_FUNCTION_PTR = 1,
4428 IS_LVALREF_QUALIFIED = 0,
4429 IS_RVALREF_QUALIFIED = 0,
4430 IS_NOEXCEPT = 0
4431 };
4432
4433 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4434 t_BSLMF_RETURN,
4435 t_TYPE,
4436 t_ARGS...>::Type
4437 ClassType;
4438 typedef t_BSLMF_RETURN ResultType;
4439 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4440};
4441
4442template <class t_PROTOTYPE,
4443 class t_BSLMF_RETURN,
4444 class t_TYPE,
4445 class... t_ARGS>
4446struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4447 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4448 const volatile> {
4449 enum {
4450 IS_MEMBER_FUNCTION_PTR = 1,
4451 IS_LVALREF_QUALIFIED = 0,
4452 IS_RVALREF_QUALIFIED = 0,
4453 IS_NOEXCEPT = 0
4454 };
4455 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4456 t_BSLMF_RETURN,
4457 t_TYPE,
4458 t_ARGS...>::Type
4459 ClassType;
4460 typedef t_BSLMF_RETURN ResultType;
4461 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4462};
4463
4464// }}} END GENERATED CODE
4465#endif // BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
4466
4467#ifdef BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4468
4469/// Specialization to determine the traits of member functions. A modern
4470/// compiler will match only non-cv member functions, but some older
4471/// compilers might match this to any member function.
4472template <class t_PROTOTYPE,
4473 class t_BSLMF_RETURN,
4474 class t_TYPE,
4475 class... t_ARGS>
4476struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4477 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4478 noexcept> {
4479
4480 enum {
4481 IS_MEMBER_FUNCTION_PTR = 1,
4482 IS_LVALREF_QUALIFIED = 0,
4483 IS_RVALREF_QUALIFIED = 0,
4484 IS_NOEXCEPT = 1
4485 };
4486 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4487 t_BSLMF_RETURN,
4488 t_TYPE,
4489 t_ARGS...>::Type
4490 ClassType;
4491 typedef t_BSLMF_RETURN ResultType;
4492 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4493};
4494
4495/// Specialization to determine the traits of member functions. A modern
4496/// compiler will match only const member functions, but some older
4497/// compilers might match this to any member function.
4498template <class t_PROTOTYPE,
4499 class t_BSLMF_RETURN,
4500 class t_TYPE,
4501 class... t_ARGS>
4502struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4503 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4504 const noexcept> {
4505
4506 enum {
4507 IS_MEMBER_FUNCTION_PTR = 1,
4508 IS_LVALREF_QUALIFIED = 0,
4509 IS_RVALREF_QUALIFIED = 0,
4510 IS_NOEXCEPT = 1
4511 };
4512 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4513 t_BSLMF_RETURN,
4514 t_TYPE,
4515 t_ARGS...>::Type
4516 ClassType;
4517 typedef t_BSLMF_RETURN ResultType;
4518 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4519};
4520
4521/// Specialization to determine the traits of member functions. A modern
4522/// compiler will match only volatile member functions, but some older
4523/// compilers might match this to any member function.
4524template <class t_PROTOTYPE,
4525 class t_BSLMF_RETURN,
4526 class t_TYPE,
4527 class... t_ARGS>
4528struct MemberFunctionPointerTraits_Imp<
4529 t_PROTOTYPE,
4530 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile noexcept> {
4531
4532 enum {
4533 IS_MEMBER_FUNCTION_PTR = 1,
4534 IS_LVALREF_QUALIFIED = 0,
4535 IS_RVALREF_QUALIFIED = 0,
4536 IS_NOEXCEPT = 1
4537 };
4538
4539 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4540 t_BSLMF_RETURN,
4541 t_TYPE,
4542 t_ARGS...>::Type
4543 ClassType;
4544 typedef t_BSLMF_RETURN ResultType;
4545 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4546};
4547
4548/// Specialization to determine the traits of member functions. A modern
4549/// compiler will match only const volatile member functions, but some older
4550/// compilers might match this to any member function.
4551template <class t_PROTOTYPE,
4552 class t_BSLMF_RETURN,
4553 class t_TYPE,
4554 class... t_ARGS>
4555struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4556 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4557 const volatile noexcept> {
4558
4559 enum {
4560 IS_MEMBER_FUNCTION_PTR = 1,
4561 IS_LVALREF_QUALIFIED = 0,
4562 IS_RVALREF_QUALIFIED = 0,
4563 IS_NOEXCEPT = 1
4564 };
4565 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4566 t_BSLMF_RETURN,
4567 t_TYPE,
4568 t_ARGS...>::Type
4569 ClassType;
4570 typedef t_BSLMF_RETURN ResultType;
4571 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4572};
4573#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4574
4575#ifdef BSLS_COMPILERFEATURES_SUPPORT_REF_QUALIFIERS
4576
4577/// Specialization to determine the traits of a pointer to lvalref-qualified
4578/// member function. The workarounds for older compilers are not needed
4579/// because only more modern compilers support ref-qualified member
4580/// functions.
4581template <class t_PROTOTYPE,
4582 class t_BSLMF_RETURN,
4583 class t_TYPE,
4584 class... t_ARGS>
4585struct MemberFunctionPointerTraits_Imp<
4586 t_PROTOTYPE,
4587 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)&> {
4588
4589 enum {
4590 IS_MEMBER_FUNCTION_PTR = 1,
4591 IS_LVALREF_QUALIFIED = 1,
4592 IS_RVALREF_QUALIFIED = 0,
4593 IS_NOEXCEPT = 0
4594 };
4595 typedef t_TYPE ClassType;
4596 typedef t_BSLMF_RETURN ResultType;
4597 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4598};
4599
4600/// Specialization to determine the traits of a pointer to const
4601/// lvalref-qualified member function. The workarounds for older compilers
4602/// are not needed because only more modern compilers support ref-qualified
4603/// member functions.
4604template <class t_PROTOTYPE,
4605 class t_BSLMF_RETURN,
4606 class t_TYPE,
4607 class... t_ARGS>
4608struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4609 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4610 const&> {
4611
4612 enum {
4613 IS_MEMBER_FUNCTION_PTR = 1,
4614 IS_LVALREF_QUALIFIED = 1,
4615 IS_RVALREF_QUALIFIED = 0,
4616 IS_NOEXCEPT = 0
4617 };
4618 typedef const t_TYPE ClassType;
4619 typedef t_BSLMF_RETURN ResultType;
4620 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4621};
4622
4623/// Specialization to determine the traits of a pointer to volatile
4624/// lvalref-qualified member function. The workarounds for older compilers
4625/// are not needed because only more modern compilers support ref-qualified
4626/// member functions.
4627template <class t_PROTOTYPE,
4628 class t_BSLMF_RETURN,
4629 class t_TYPE,
4630 class... t_ARGS>
4631struct MemberFunctionPointerTraits_Imp<
4632 t_PROTOTYPE,
4633 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile&> {
4634
4635 enum {
4636 IS_MEMBER_FUNCTION_PTR = 1,
4637 IS_LVALREF_QUALIFIED = 1,
4638 IS_RVALREF_QUALIFIED = 0,
4639 IS_NOEXCEPT = 0
4640 };
4641 typedef volatile t_TYPE ClassType;
4642 typedef t_BSLMF_RETURN ResultType;
4643 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4644};
4645
4646/// Specialization to determine the traits of a pointer to const volatile
4647/// lvalref-qualified member function. The workarounds for older compilers
4648/// are not needed because only more modern compilers support ref-qualified
4649/// member functions.
4650template <class t_PROTOTYPE,
4651 class t_BSLMF_RETURN,
4652 class t_TYPE,
4653 class... t_ARGS>
4654struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4655 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4656 const volatile&> {
4657
4658 enum {
4659 IS_MEMBER_FUNCTION_PTR = 1,
4660 IS_LVALREF_QUALIFIED = 1,
4661 IS_RVALREF_QUALIFIED = 0,
4662 IS_NOEXCEPT = 0
4663 };
4664 typedef const volatile t_TYPE ClassType;
4665 typedef t_BSLMF_RETURN ResultType;
4666 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4667};
4668
4669#ifdef BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4670
4671/// Specialization to determine the traits of a pointer to lvalref-qualified
4672/// member function. The workarounds for older compilers are not needed
4673/// because only more modern compilers support ref-qualified member
4674/// functions.
4675template <class t_PROTOTYPE,
4676 class t_BSLMF_RETURN,
4677 class t_TYPE,
4678 class... t_ARGS>
4679struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4680 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) &
4681 noexcept> {
4682
4683 enum {
4684 IS_MEMBER_FUNCTION_PTR = 1,
4685 IS_LVALREF_QUALIFIED = 1,
4686 IS_RVALREF_QUALIFIED = 0,
4687 IS_NOEXCEPT = 1
4688 };
4689 typedef t_TYPE ClassType;
4690 typedef t_BSLMF_RETURN ResultType;
4691 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4692};
4693
4694/// Specialization to determine the traits of a pointer to const
4695/// lvalref-qualified member function. The workarounds for older compilers
4696/// are not needed because only more modern compilers support ref-qualified
4697/// member functions.
4698template <class t_PROTOTYPE,
4699 class t_BSLMF_RETURN,
4700 class t_TYPE,
4701 class... t_ARGS>
4702struct MemberFunctionPointerTraits_Imp<
4703 t_PROTOTYPE,
4704 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const & noexcept> {
4705
4706 enum {
4707 IS_MEMBER_FUNCTION_PTR = 1,
4708 IS_LVALREF_QUALIFIED = 1,
4709 IS_RVALREF_QUALIFIED = 0,
4710 IS_NOEXCEPT = 1
4711 };
4712 typedef const t_TYPE ClassType;
4713 typedef t_BSLMF_RETURN ResultType;
4714 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4715};
4716
4717/// Specialization to determine the traits of a pointer to volatile
4718/// lvalref-qualified member function. The workarounds for older compilers
4719/// are not needed because only more modern compilers support ref-qualified
4720/// member functions.
4721template <class t_PROTOTYPE,
4722 class t_BSLMF_RETURN,
4723 class t_TYPE,
4724 class... t_ARGS>
4725struct MemberFunctionPointerTraits_Imp<
4726 t_PROTOTYPE,
4727 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile & noexcept> {
4728
4729 enum {
4730 IS_MEMBER_FUNCTION_PTR = 1,
4731 IS_LVALREF_QUALIFIED = 1,
4732 IS_RVALREF_QUALIFIED = 0,
4733 IS_NOEXCEPT = 1
4734 };
4735 typedef volatile t_TYPE ClassType;
4736 typedef t_BSLMF_RETURN ResultType;
4737 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4738};
4739
4740/// Specialization to determine the traits of a pointer to const volatile
4741/// lvalref-qualified member function. The workarounds for older compilers
4742/// are not needed because only more modern compilers support ref-qualified
4743/// member functions.
4744template <class t_PROTOTYPE,
4745 class t_BSLMF_RETURN,
4746 class t_TYPE,
4747 class... t_ARGS>
4748struct MemberFunctionPointerTraits_Imp<
4749 t_PROTOTYPE,
4750 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const volatile & noexcept> {
4751
4752 enum {
4753 IS_MEMBER_FUNCTION_PTR = 1,
4754 IS_LVALREF_QUALIFIED = 1,
4755 IS_RVALREF_QUALIFIED = 0,
4756 IS_NOEXCEPT = 1
4757 };
4758 typedef const volatile t_TYPE ClassType;
4759 typedef t_BSLMF_RETURN ResultType;
4760 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4761};
4762
4763#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4764
4765/// Specialization to determine the traits of a pointer to rvalref-qualified
4766/// member function. The workarounds for older compilers are not needed
4767/// because only more modern compilers support ref-qualified member
4768/// functions.
4769template <class t_PROTOTYPE,
4770 class t_BSLMF_RETURN,
4771 class t_TYPE,
4772 class... t_ARGS>
4773struct MemberFunctionPointerTraits_Imp<
4774 t_PROTOTYPE,
4775 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) &&> {
4776
4777 enum {
4778 IS_MEMBER_FUNCTION_PTR = 1,
4779 IS_LVALREF_QUALIFIED = 0,
4780 IS_RVALREF_QUALIFIED = 1,
4781 IS_NOEXCEPT = 0
4782 };
4783 typedef t_TYPE ClassType;
4784 typedef t_BSLMF_RETURN ResultType;
4785 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4786};
4787
4788/// Specialization to determine the traits of a pointer to const
4789/// rvalref-qualified member function. The workarounds for older compilers
4790/// are not needed because only more modern compilers support ref-qualified
4791/// member functions.
4792template <class t_PROTOTYPE,
4793 class t_BSLMF_RETURN,
4794 class t_TYPE,
4795 class... t_ARGS>
4796struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4797 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4798 const&&> {
4799
4800 enum {
4801 IS_MEMBER_FUNCTION_PTR = 1,
4802 IS_LVALREF_QUALIFIED = 0,
4803 IS_RVALREF_QUALIFIED = 1,
4804 IS_NOEXCEPT = 0
4805 };
4806 typedef const t_TYPE ClassType;
4807 typedef t_BSLMF_RETURN ResultType;
4808 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4809};
4810
4811/// Specialization to determine the traits of a pointer to volatile
4812/// rvalref-qualified member function. The workarounds for older compilers
4813/// are not needed because only more modern compilers support ref-qualified
4814/// member functions.
4815template <class t_PROTOTYPE,
4816 class t_BSLMF_RETURN,
4817 class t_TYPE,
4818 class... t_ARGS>
4819struct MemberFunctionPointerTraits_Imp<
4820 t_PROTOTYPE,
4821 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile&&> {
4822
4823 enum {
4824 IS_MEMBER_FUNCTION_PTR = 1,
4825 IS_LVALREF_QUALIFIED = 0,
4826 IS_RVALREF_QUALIFIED = 1,
4827 IS_NOEXCEPT = 0
4828 };
4829 typedef volatile t_TYPE ClassType;
4830 typedef t_BSLMF_RETURN ResultType;
4831 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4832};
4833
4834/// Specialization to determine the traits of a pointer to const volatile
4835/// rvalref-qualified member function. The workarounds for older compilers
4836/// are not needed because only more modern compilers support ref-qualified
4837/// member functions.
4838template <class t_PROTOTYPE,
4839 class t_BSLMF_RETURN,
4840 class t_TYPE,
4841 class... t_ARGS>
4842struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4843 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4844 const volatile&&> {
4845
4846 enum {
4847 IS_MEMBER_FUNCTION_PTR = 1,
4848 IS_LVALREF_QUALIFIED = 0,
4849 IS_RVALREF_QUALIFIED = 1,
4850 IS_NOEXCEPT = 0
4851 };
4852 typedef const volatile t_TYPE ClassType;
4853 typedef t_BSLMF_RETURN ResultType;
4854 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4855};
4856
4857#ifdef BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4858
4859/// Specialization to determine the traits of a pointer to rvalref-qualified
4860/// member function. The workarounds for older compilers are not needed
4861/// because only more modern compilers support ref-qualified member
4862/// functions.
4863template <class t_PROTOTYPE,
4864 class t_BSLMF_RETURN,
4865 class t_TYPE,
4866 class... t_ARGS>
4867struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4868 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) &&
4869 noexcept> {
4870
4871 enum {
4872 IS_MEMBER_FUNCTION_PTR = 1,
4873 IS_LVALREF_QUALIFIED = 0,
4874 IS_RVALREF_QUALIFIED = 1,
4875 IS_NOEXCEPT = 1
4876 };
4877 typedef t_TYPE ClassType;
4878 typedef t_BSLMF_RETURN ResultType;
4879 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4880};
4881
4882/// Specialization to determine the traits of a pointer to const
4883/// rvalref-qualified member function. The workarounds for older compilers
4884/// are not needed because only more modern compilers support ref-qualified
4885/// member functions.
4886template <class t_PROTOTYPE,
4887 class t_BSLMF_RETURN,
4888 class t_TYPE,
4889 class... t_ARGS>
4890struct MemberFunctionPointerTraits_Imp<
4891 t_PROTOTYPE,
4892 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const && noexcept> {
4893
4894 enum {
4895 IS_MEMBER_FUNCTION_PTR = 1,
4896 IS_LVALREF_QUALIFIED = 0,
4897 IS_RVALREF_QUALIFIED = 1,
4898 IS_NOEXCEPT = 1
4899 };
4900 typedef const t_TYPE ClassType;
4901 typedef t_BSLMF_RETURN ResultType;
4902 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4903};
4904
4905/// Specialization to determine the traits of a pointer to volatile
4906/// rvalref-qualified member function. The workarounds for older compilers
4907/// are not needed because only more modern compilers support ref-qualified
4908/// member functions.
4909template <class t_PROTOTYPE,
4910 class t_BSLMF_RETURN,
4911 class t_TYPE,
4912 class... t_ARGS>
4913struct MemberFunctionPointerTraits_Imp<
4914 t_PROTOTYPE,
4915 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile && noexcept> {
4916
4917 enum {
4918 IS_MEMBER_FUNCTION_PTR = 1,
4919 IS_LVALREF_QUALIFIED = 0,
4920 IS_RVALREF_QUALIFIED = 1,
4921 IS_NOEXCEPT = 1
4922 };
4923 typedef volatile t_TYPE ClassType;
4924 typedef t_BSLMF_RETURN ResultType;
4925 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4926};
4927
4928/// Specialization to determine the traits of a pointer to const volatile
4929/// rvalref-qualified member function. The workarounds for older compilers
4930/// are not needed because only more modern compilers support ref-qualified
4931/// member functions.
4932template <class t_PROTOTYPE,
4933 class t_BSLMF_RETURN,
4934 class t_TYPE,
4935 class... t_ARGS>
4936struct MemberFunctionPointerTraits_Imp<
4937 t_PROTOTYPE,
4938 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const volatile && noexcept> {
4939
4940 enum {
4941 IS_MEMBER_FUNCTION_PTR = 1,
4942 IS_LVALREF_QUALIFIED = 0,
4943 IS_RVALREF_QUALIFIED = 1,
4944 IS_NOEXCEPT = 1
4945 };
4946 typedef const volatile t_TYPE ClassType;
4947 typedef t_BSLMF_RETURN ResultType;
4948 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4949};
4950#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4951
4952#endif // BSLS_COMPILERFEATURES_SUPPORT_REF_QUALIFIERS
4953
4954} // close package namespace
4955
4956#ifndef BDE_OPENSOURCE_PUBLICATION // BACKWARD_COMPATIBILITY
4957// ============================================================================
4958// BACKWARD COMPATIBILITY
4959// ============================================================================
4960
4961#ifdef bslmf_MemberFunctionPointerTraits
4962#undef bslmf_MemberFunctionPointerTraits
4963#endif
4964/// This alias is defined for backward compatibility.
4965#define bslmf_MemberFunctionPointerTraits bslmf::MemberFunctionPointerTraits
4966
4967#ifdef bslmf_IsMemberFunctionPointer
4968#undef bslmf_IsMemberFunctionPointer
4969#endif
4970/// This alias is defined for backward compatibility.
4971#define bslmf_IsMemberFunctionPointer bslmf::IsMemberFunctionPointer
4972
4973#ifdef bslmf_MemberFunctionPointerTraitsImp
4974#undef bslmf_MemberFunctionPointerTraitsImp
4975#endif
4976/// This alias is defined for backward compatibility.
4977#define bslmf_MemberFunctionPointerTraitsImp \
4978 bslmf::MemberFunctionPointerTraits_Imp
4979#endif // BDE_OPENSOURCE_PUBLICATION -- BACKWARD_COMPATIBILITY
4980
4981
4982
4983#endif
4984
4985// ----------------------------------------------------------------------------
4986// Copyright 2013-2019 Bloomberg Finance L.P.
4987//
4988// Licensed under the Apache License, Version 2.0 (the "License");
4989// you may not use this file except in compliance with the License.
4990// You may obtain a copy of the License at
4991//
4992// http://www.apache.org/licenses/LICENSE-2.0
4993//
4994// Unless required by applicable law or agreed to in writing, software
4995// distributed under the License is distributed on an "AS IS" BASIS,
4996// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4997// See the License for the specific language governing permissions and
4998// limitations under the License.
4999// ----------------------------- END-OF-FILE ----------------------------------
5000
5001/** @} */
5002/** @} */
5003/** @} */
bslmf_if.h
bslmf_integralconstant.h
bslmf_removecv.h
bslmf_tag.h
bslmf_typelist.h
bsls_compilerfeatures.h
bsls_ident.h
bslmf::MemberFunctionPointerTraits_ClassType
Definition bslmf_memberfunctionpointertraits.h:210
bslmf::MemberFunctionPointerTraits_ClassType::IS_VOLATILE
@ IS_VOLATILE
Definition bslmf_memberfunctionpointertraits.h:246
bslmf::MemberFunctionPointerTraits_ClassType::IS_CONST
@ IS_CONST
Definition bslmf_memberfunctionpointertraits.h:245
bslmf::MemberFunctionPointerTraits_ClassType::CType
If< IS_CONST, constt_TYPE, t_TYPE >::Type CType
Definition bslmf_memberfunctionpointertraits.h:251
bslmf::MemberFunctionPointerTraits_ClassType::Type
If< IS_VOLATILE, volatileCType, CType >::Type Type
Definition bslmf_memberfunctionpointertraits.h:255
BSLMF_TAG_TO_UINT
#define BSLMF_TAG_TO_UINT(BSLMF_EXPR)
Definition bslmf_tag.h:175
BSLS_IDENT
#define BSLS_IDENT(str)
BSLS_IDENT() - insert string into .comment binary segment (if supported)
Definition bsls_ident.h:238
bslmf
Definition bdlbb_blob.h:579
bsl::integral_constant
Definition bslmf_integralconstant.h:261
bslmf::If::Type
bsl::conditional< t_CONDITION, t_IF_TRUE_TYPE, t_IF_FALSE_TYPE >::type Type
Definition bslmf_if.h:163
bslmf::IsMemberFunctionPointer
Definition bslmf_memberfunctionpointertraits.h:164
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) const >::ResultType
t_BSLMF_RETURN ResultType
Definition bslmf_memberfunctionpointertraits.h:1449
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) const >::ArgumentList
TypeList< t_ARGS... >::Type ArgumentList
Definition bslmf_memberfunctionpointertraits.h:1450
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) const >::ClassType
MemberFunctionPointerTraits_ClassType< t_PROTOTYPE, t_BSLMF_RETURN, t_TYPE, t_ARGS... >::Type ClassType
Definition bslmf_memberfunctionpointertraits.h:1448
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) volatile >::ClassType
MemberFunctionPointerTraits_ClassType< t_PROTOTYPE, t_BSLMF_RETURN, t_TYPE, t_ARGS... >::Type ClassType
Definition bslmf_memberfunctionpointertraits.h:1475
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) volatile >::ResultType
t_BSLMF_RETURN ResultType
Definition bslmf_memberfunctionpointertraits.h:1476
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) volatile >::ArgumentList
TypeList< t_ARGS... >::Type ArgumentList
Definition bslmf_memberfunctionpointertraits.h:1477
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...)>::ResultType
t_BSLMF_RETURN ResultType
Definition bslmf_memberfunctionpointertraits.h:1423
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...)>::ClassType
MemberFunctionPointerTraits_ClassType< t_PROTOTYPE, t_BSLMF_RETURN, t_TYPE, t_ARGS... >::Type ClassType
Definition bslmf_memberfunctionpointertraits.h:1422
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...)>::ArgumentList
TypeList< t_ARGS... >::Type ArgumentList
Definition bslmf_memberfunctionpointertraits.h:1424
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) const volatile >::ResultType
t_BSLMF_RETURN ResultType
Definition bslmf_memberfunctionpointertraits.h:1502
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) const volatile >::ClassType
MemberFunctionPointerTraits_ClassType< t_PROTOTYPE, t_BSLMF_RETURN, t_TYPE, t_ARGS... >::Type ClassType
Definition bslmf_memberfunctionpointertraits.h:1501
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) const volatile >::ArgumentList
TypeList< t_ARGS... >::Type ArgumentList
Definition bslmf_memberfunctionpointertraits.h:1503
bslmf::MemberFunctionPointerTraits_Imp
Forward declaration.
Definition bslmf_memberfunctionpointertraits.h:1392
bslmf::MemberFunctionPointerTraits_Imp::IS_MEMBER_FUNCTION_PTR
@ IS_MEMBER_FUNCTION_PTR
Definition bslmf_memberfunctionpointertraits.h:1395
bslmf::MemberFunctionPointerTraits
Definition bslmf_memberfunctionpointertraits.h:150
bslmf::Tag
Definition bslmf_tag.h:166
bslmf::TypeList20::Type
ListType Type
Definition bslmf_typelist.h:2486
bslmf::TypeList
Definition bslmf_typelist.h:1612