BDE 4.14.0 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.
1389template <class t_PROTOTYPE, class t_TEST_PROTOTYPE>
1390struct MemberFunctionPointerTraits_Imp {
1391
1392 enum {
1393 IS_MEMBER_FUNCTION_PTR = 0
1394 };
1395};
1396
1397// SPECIALIZATIONS
1398#if !BSLS_COMPILERFEATURES_SIMULATE_CPP11_FEATURES // $var-args=14
1399
1400/// Specialization to determine the traits of member functions. A modern
1401/// compiler will match only non-cv member functions, but some older
1402/// compilers might match this to any member function.
1403template <class t_PROTOTYPE,
1404 class t_BSLMF_RETURN,
1405 class t_TYPE,
1406 class... t_ARGS>
1407struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1408 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)> {
1409
1410 enum {
1411 IS_MEMBER_FUNCTION_PTR = 1,
1412 IS_LVALREF_QUALIFIED = 0,
1413 IS_RVALREF_QUALIFIED = 0,
1414 IS_NOEXCEPT = 0
1415 };
1416 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1417 t_BSLMF_RETURN,
1418 t_TYPE,
1419 t_ARGS...>::Type
1420 ClassType;
1421 typedef t_BSLMF_RETURN ResultType;
1422 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
1423};
1424
1425/// Specialization to determine the traits of member functions. A modern
1426/// compiler will match only const member functions, but some older
1427/// compilers might match this to any member function.
1428template <class t_PROTOTYPE,
1429 class t_BSLMF_RETURN,
1430 class t_TYPE,
1431 class... t_ARGS>
1432struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1433 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
1434 const> {
1435
1436 enum {
1437 IS_MEMBER_FUNCTION_PTR = 1,
1438 IS_LVALREF_QUALIFIED = 0,
1439 IS_RVALREF_QUALIFIED = 0,
1440 IS_NOEXCEPT = 0
1441 };
1442 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1443 t_BSLMF_RETURN,
1444 t_TYPE,
1445 t_ARGS...>::Type
1446 ClassType;
1447 typedef t_BSLMF_RETURN ResultType;
1448 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
1449};
1450
1451/// Specialization to determine the traits of member functions. A modern
1452/// compiler will match only volatile member functions, but some older
1453/// compilers might match this to any member function.
1454template <class t_PROTOTYPE,
1455 class t_BSLMF_RETURN,
1456 class t_TYPE,
1457 class... t_ARGS>
1458struct MemberFunctionPointerTraits_Imp<
1459 t_PROTOTYPE,
1460 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile> {
1461
1462 enum {
1463 IS_MEMBER_FUNCTION_PTR = 1,
1464 IS_LVALREF_QUALIFIED = 0,
1465 IS_RVALREF_QUALIFIED = 0,
1466 IS_NOEXCEPT = 0
1467 };
1468
1469 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1470 t_BSLMF_RETURN,
1471 t_TYPE,
1472 t_ARGS...>::Type
1473 ClassType;
1474 typedef t_BSLMF_RETURN ResultType;
1475 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
1476};
1477
1478/// Specialization to determine the traits of member functions. A modern
1479/// compiler will match only const volatile member functions, but some older
1480/// compilers might match this to any member function.
1481template <class t_PROTOTYPE,
1482 class t_BSLMF_RETURN,
1483 class t_TYPE,
1484 class... t_ARGS>
1485struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1486 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
1487 const volatile> {
1488
1489 enum {
1490 IS_MEMBER_FUNCTION_PTR = 1,
1491 IS_LVALREF_QUALIFIED = 0,
1492 IS_RVALREF_QUALIFIED = 0,
1493 IS_NOEXCEPT = 0
1494 };
1495 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1496 t_BSLMF_RETURN,
1497 t_TYPE,
1498 t_ARGS...>::Type
1499 ClassType;
1500 typedef t_BSLMF_RETURN ResultType;
1501 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
1502};
1503
1504#elif BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
1505// {{{ BEGIN GENERATED CODE
1506// The following section is automatically generated. **DO NOT EDIT**
1507// Generator command line:
1508// sim_cpp11_features.pl bslmf_memberfunctionpointertraits.h
1509#ifndef BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT
1510#define BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT 14
1511#endif
1512#ifndef BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B
1513#define BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B \
1514 BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT
1515#endif
1516#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
1517template <class t_PROTOTYPE, class t_BSLMF_RETURN, class t_TYPE>
1518struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1519 t_BSLMF_RETURN (t_TYPE::*)()> {
1520 enum {
1521 IS_MEMBER_FUNCTION_PTR = 1,
1522 IS_LVALREF_QUALIFIED = 0,
1523 IS_RVALREF_QUALIFIED = 0,
1524 IS_NOEXCEPT = 0
1525 };
1526 typedef
1527 typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1528 t_BSLMF_RETURN,
1529 t_TYPE>::Type ClassType;
1530 typedef t_BSLMF_RETURN ResultType;
1531 typedef typename TypeList<>::Type ArgumentList;
1532};
1533#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
1534
1535#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
1536template <class t_PROTOTYPE,
1537 class t_BSLMF_RETURN,
1538 class t_TYPE,
1539 class t_ARGS_01>
1540struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1541 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01)> {
1542 enum {
1543 IS_MEMBER_FUNCTION_PTR = 1,
1544 IS_LVALREF_QUALIFIED = 0,
1545 IS_RVALREF_QUALIFIED = 0,
1546 IS_NOEXCEPT = 0
1547 };
1548 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1549 t_BSLMF_RETURN,
1550 t_TYPE,
1551 t_ARGS_01>::Type
1552 ClassType;
1553 typedef t_BSLMF_RETURN ResultType;
1554 typedef typename TypeList<t_ARGS_01>::Type ArgumentList;
1555};
1556#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
1557
1558#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
1559template <class t_PROTOTYPE,
1560 class t_BSLMF_RETURN,
1561 class t_TYPE,
1562 class t_ARGS_01,
1563 class t_ARGS_02>
1564struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1565 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1566 t_ARGS_02)> {
1567 enum {
1568 IS_MEMBER_FUNCTION_PTR = 1,
1569 IS_LVALREF_QUALIFIED = 0,
1570 IS_RVALREF_QUALIFIED = 0,
1571 IS_NOEXCEPT = 0
1572 };
1573 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1574 t_BSLMF_RETURN,
1575 t_TYPE,
1576 t_ARGS_01,
1577 t_ARGS_02>::Type
1578 ClassType;
1579 typedef t_BSLMF_RETURN ResultType;
1580 typedef typename TypeList<t_ARGS_01,
1581 t_ARGS_02>::Type ArgumentList;
1582};
1583#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
1584
1585#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
1586template <class t_PROTOTYPE,
1587 class t_BSLMF_RETURN,
1588 class t_TYPE,
1589 class t_ARGS_01,
1590 class t_ARGS_02,
1591 class t_ARGS_03>
1592struct MemberFunctionPointerTraits_Imp<
1593 t_PROTOTYPE,
1594 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03)> {
1595 enum {
1596 IS_MEMBER_FUNCTION_PTR = 1,
1597 IS_LVALREF_QUALIFIED = 0,
1598 IS_RVALREF_QUALIFIED = 0,
1599 IS_NOEXCEPT = 0
1600 };
1601 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1602 t_BSLMF_RETURN,
1603 t_TYPE,
1604 t_ARGS_01,
1605 t_ARGS_02,
1606 t_ARGS_03>::Type
1607 ClassType;
1608 typedef t_BSLMF_RETURN ResultType;
1609 typedef typename TypeList<t_ARGS_01,
1610 t_ARGS_02,
1611 t_ARGS_03>::Type ArgumentList;
1612};
1613#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
1614
1615#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
1616template <class t_PROTOTYPE,
1617 class t_BSLMF_RETURN,
1618 class t_TYPE,
1619 class t_ARGS_01,
1620 class t_ARGS_02,
1621 class t_ARGS_03,
1622 class t_ARGS_04>
1623struct MemberFunctionPointerTraits_Imp<
1624 t_PROTOTYPE,
1625 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04)> {
1626 enum {
1627 IS_MEMBER_FUNCTION_PTR = 1,
1628 IS_LVALREF_QUALIFIED = 0,
1629 IS_RVALREF_QUALIFIED = 0,
1630 IS_NOEXCEPT = 0
1631 };
1632 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1633 t_BSLMF_RETURN,
1634 t_TYPE,
1635 t_ARGS_01,
1636 t_ARGS_02,
1637 t_ARGS_03,
1638 t_ARGS_04>::Type
1639 ClassType;
1640 typedef t_BSLMF_RETURN ResultType;
1641 typedef typename TypeList<t_ARGS_01,
1642 t_ARGS_02,
1643 t_ARGS_03,
1644 t_ARGS_04>::Type ArgumentList;
1645};
1646#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
1647
1648#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
1649template <class t_PROTOTYPE,
1650 class t_BSLMF_RETURN,
1651 class t_TYPE,
1652 class t_ARGS_01,
1653 class t_ARGS_02,
1654 class t_ARGS_03,
1655 class t_ARGS_04,
1656 class t_ARGS_05>
1657struct MemberFunctionPointerTraits_Imp<
1658 t_PROTOTYPE,
1659 t_BSLMF_RETURN (
1660 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04, t_ARGS_05)> {
1661 enum {
1662 IS_MEMBER_FUNCTION_PTR = 1,
1663 IS_LVALREF_QUALIFIED = 0,
1664 IS_RVALREF_QUALIFIED = 0,
1665 IS_NOEXCEPT = 0
1666 };
1667 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1668 t_BSLMF_RETURN,
1669 t_TYPE,
1670 t_ARGS_01,
1671 t_ARGS_02,
1672 t_ARGS_03,
1673 t_ARGS_04,
1674 t_ARGS_05>::Type
1675 ClassType;
1676 typedef t_BSLMF_RETURN ResultType;
1677 typedef typename TypeList<t_ARGS_01,
1678 t_ARGS_02,
1679 t_ARGS_03,
1680 t_ARGS_04,
1681 t_ARGS_05>::Type ArgumentList;
1682};
1683#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
1684
1685#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
1686template <class t_PROTOTYPE,
1687 class t_BSLMF_RETURN,
1688 class t_TYPE,
1689 class t_ARGS_01,
1690 class t_ARGS_02,
1691 class t_ARGS_03,
1692 class t_ARGS_04,
1693 class t_ARGS_05,
1694 class t_ARGS_06>
1695struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1696 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1697 t_ARGS_02,
1698 t_ARGS_03,
1699 t_ARGS_04,
1700 t_ARGS_05,
1701 t_ARGS_06)> {
1702 enum {
1703 IS_MEMBER_FUNCTION_PTR = 1,
1704 IS_LVALREF_QUALIFIED = 0,
1705 IS_RVALREF_QUALIFIED = 0,
1706 IS_NOEXCEPT = 0
1707 };
1708 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1709 t_BSLMF_RETURN,
1710 t_TYPE,
1711 t_ARGS_01,
1712 t_ARGS_02,
1713 t_ARGS_03,
1714 t_ARGS_04,
1715 t_ARGS_05,
1716 t_ARGS_06>::Type
1717 ClassType;
1718 typedef t_BSLMF_RETURN ResultType;
1719 typedef typename TypeList<t_ARGS_01,
1720 t_ARGS_02,
1721 t_ARGS_03,
1722 t_ARGS_04,
1723 t_ARGS_05,
1724 t_ARGS_06>::Type ArgumentList;
1725};
1726#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
1727
1728#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
1729template <class t_PROTOTYPE,
1730 class t_BSLMF_RETURN,
1731 class t_TYPE,
1732 class t_ARGS_01,
1733 class t_ARGS_02,
1734 class t_ARGS_03,
1735 class t_ARGS_04,
1736 class t_ARGS_05,
1737 class t_ARGS_06,
1738 class t_ARGS_07>
1739struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1740 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1741 t_ARGS_02,
1742 t_ARGS_03,
1743 t_ARGS_04,
1744 t_ARGS_05,
1745 t_ARGS_06,
1746 t_ARGS_07)> {
1747 enum {
1748 IS_MEMBER_FUNCTION_PTR = 1,
1749 IS_LVALREF_QUALIFIED = 0,
1750 IS_RVALREF_QUALIFIED = 0,
1751 IS_NOEXCEPT = 0
1752 };
1753 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1754 t_BSLMF_RETURN,
1755 t_TYPE,
1756 t_ARGS_01,
1757 t_ARGS_02,
1758 t_ARGS_03,
1759 t_ARGS_04,
1760 t_ARGS_05,
1761 t_ARGS_06,
1762 t_ARGS_07>::Type
1763 ClassType;
1764 typedef t_BSLMF_RETURN ResultType;
1765 typedef typename TypeList<t_ARGS_01,
1766 t_ARGS_02,
1767 t_ARGS_03,
1768 t_ARGS_04,
1769 t_ARGS_05,
1770 t_ARGS_06,
1771 t_ARGS_07>::Type ArgumentList;
1772};
1773#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
1774
1775#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
1776template <class t_PROTOTYPE,
1777 class t_BSLMF_RETURN,
1778 class t_TYPE,
1779 class t_ARGS_01,
1780 class t_ARGS_02,
1781 class t_ARGS_03,
1782 class t_ARGS_04,
1783 class t_ARGS_05,
1784 class t_ARGS_06,
1785 class t_ARGS_07,
1786 class t_ARGS_08>
1787struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1788 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1789 t_ARGS_02,
1790 t_ARGS_03,
1791 t_ARGS_04,
1792 t_ARGS_05,
1793 t_ARGS_06,
1794 t_ARGS_07,
1795 t_ARGS_08)> {
1796 enum {
1797 IS_MEMBER_FUNCTION_PTR = 1,
1798 IS_LVALREF_QUALIFIED = 0,
1799 IS_RVALREF_QUALIFIED = 0,
1800 IS_NOEXCEPT = 0
1801 };
1802 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1803 t_BSLMF_RETURN,
1804 t_TYPE,
1805 t_ARGS_01,
1806 t_ARGS_02,
1807 t_ARGS_03,
1808 t_ARGS_04,
1809 t_ARGS_05,
1810 t_ARGS_06,
1811 t_ARGS_07,
1812 t_ARGS_08>::Type
1813 ClassType;
1814 typedef t_BSLMF_RETURN ResultType;
1815 typedef typename TypeList<t_ARGS_01,
1816 t_ARGS_02,
1817 t_ARGS_03,
1818 t_ARGS_04,
1819 t_ARGS_05,
1820 t_ARGS_06,
1821 t_ARGS_07,
1822 t_ARGS_08>::Type ArgumentList;
1823};
1824#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
1825
1826#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
1827template <class t_PROTOTYPE,
1828 class t_BSLMF_RETURN,
1829 class t_TYPE,
1830 class t_ARGS_01,
1831 class t_ARGS_02,
1832 class t_ARGS_03,
1833 class t_ARGS_04,
1834 class t_ARGS_05,
1835 class t_ARGS_06,
1836 class t_ARGS_07,
1837 class t_ARGS_08,
1838 class t_ARGS_09>
1839struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1840 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1841 t_ARGS_02,
1842 t_ARGS_03,
1843 t_ARGS_04,
1844 t_ARGS_05,
1845 t_ARGS_06,
1846 t_ARGS_07,
1847 t_ARGS_08,
1848 t_ARGS_09)> {
1849 enum {
1850 IS_MEMBER_FUNCTION_PTR = 1,
1851 IS_LVALREF_QUALIFIED = 0,
1852 IS_RVALREF_QUALIFIED = 0,
1853 IS_NOEXCEPT = 0
1854 };
1855 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1856 t_BSLMF_RETURN,
1857 t_TYPE,
1858 t_ARGS_01,
1859 t_ARGS_02,
1860 t_ARGS_03,
1861 t_ARGS_04,
1862 t_ARGS_05,
1863 t_ARGS_06,
1864 t_ARGS_07,
1865 t_ARGS_08,
1866 t_ARGS_09>::Type
1867 ClassType;
1868 typedef t_BSLMF_RETURN ResultType;
1869 typedef typename TypeList<t_ARGS_01,
1870 t_ARGS_02,
1871 t_ARGS_03,
1872 t_ARGS_04,
1873 t_ARGS_05,
1874 t_ARGS_06,
1875 t_ARGS_07,
1876 t_ARGS_08,
1877 t_ARGS_09>::Type ArgumentList;
1878};
1879#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
1880
1881#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
1882template <class t_PROTOTYPE,
1883 class t_BSLMF_RETURN,
1884 class t_TYPE,
1885 class t_ARGS_01,
1886 class t_ARGS_02,
1887 class t_ARGS_03,
1888 class t_ARGS_04,
1889 class t_ARGS_05,
1890 class t_ARGS_06,
1891 class t_ARGS_07,
1892 class t_ARGS_08,
1893 class t_ARGS_09,
1894 class t_ARGS_10>
1895struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1896 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1897 t_ARGS_02,
1898 t_ARGS_03,
1899 t_ARGS_04,
1900 t_ARGS_05,
1901 t_ARGS_06,
1902 t_ARGS_07,
1903 t_ARGS_08,
1904 t_ARGS_09,
1905 t_ARGS_10)> {
1906 enum {
1907 IS_MEMBER_FUNCTION_PTR = 1,
1908 IS_LVALREF_QUALIFIED = 0,
1909 IS_RVALREF_QUALIFIED = 0,
1910 IS_NOEXCEPT = 0
1911 };
1912 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1913 t_BSLMF_RETURN,
1914 t_TYPE,
1915 t_ARGS_01,
1916 t_ARGS_02,
1917 t_ARGS_03,
1918 t_ARGS_04,
1919 t_ARGS_05,
1920 t_ARGS_06,
1921 t_ARGS_07,
1922 t_ARGS_08,
1923 t_ARGS_09,
1924 t_ARGS_10>::Type
1925 ClassType;
1926 typedef t_BSLMF_RETURN ResultType;
1927 typedef typename TypeList<t_ARGS_01,
1928 t_ARGS_02,
1929 t_ARGS_03,
1930 t_ARGS_04,
1931 t_ARGS_05,
1932 t_ARGS_06,
1933 t_ARGS_07,
1934 t_ARGS_08,
1935 t_ARGS_09,
1936 t_ARGS_10>::Type ArgumentList;
1937};
1938#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
1939
1940#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
1941template <class t_PROTOTYPE,
1942 class t_BSLMF_RETURN,
1943 class t_TYPE,
1944 class t_ARGS_01,
1945 class t_ARGS_02,
1946 class t_ARGS_03,
1947 class t_ARGS_04,
1948 class t_ARGS_05,
1949 class t_ARGS_06,
1950 class t_ARGS_07,
1951 class t_ARGS_08,
1952 class t_ARGS_09,
1953 class t_ARGS_10,
1954 class t_ARGS_11>
1955struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
1956 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
1957 t_ARGS_02,
1958 t_ARGS_03,
1959 t_ARGS_04,
1960 t_ARGS_05,
1961 t_ARGS_06,
1962 t_ARGS_07,
1963 t_ARGS_08,
1964 t_ARGS_09,
1965 t_ARGS_10,
1966 t_ARGS_11)> {
1967 enum {
1968 IS_MEMBER_FUNCTION_PTR = 1,
1969 IS_LVALREF_QUALIFIED = 0,
1970 IS_RVALREF_QUALIFIED = 0,
1971 IS_NOEXCEPT = 0
1972 };
1973 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
1974 t_BSLMF_RETURN,
1975 t_TYPE,
1976 t_ARGS_01,
1977 t_ARGS_02,
1978 t_ARGS_03,
1979 t_ARGS_04,
1980 t_ARGS_05,
1981 t_ARGS_06,
1982 t_ARGS_07,
1983 t_ARGS_08,
1984 t_ARGS_09,
1985 t_ARGS_10,
1986 t_ARGS_11>::Type
1987 ClassType;
1988 typedef t_BSLMF_RETURN ResultType;
1989 typedef typename TypeList<t_ARGS_01,
1990 t_ARGS_02,
1991 t_ARGS_03,
1992 t_ARGS_04,
1993 t_ARGS_05,
1994 t_ARGS_06,
1995 t_ARGS_07,
1996 t_ARGS_08,
1997 t_ARGS_09,
1998 t_ARGS_10,
1999 t_ARGS_11>::Type ArgumentList;
2000};
2001#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
2002
2003#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
2004template <class t_PROTOTYPE,
2005 class t_BSLMF_RETURN,
2006 class t_TYPE,
2007 class t_ARGS_01,
2008 class t_ARGS_02,
2009 class t_ARGS_03,
2010 class t_ARGS_04,
2011 class t_ARGS_05,
2012 class t_ARGS_06,
2013 class t_ARGS_07,
2014 class t_ARGS_08,
2015 class t_ARGS_09,
2016 class t_ARGS_10,
2017 class t_ARGS_11,
2018 class t_ARGS_12>
2019struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2020 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2021 t_ARGS_02,
2022 t_ARGS_03,
2023 t_ARGS_04,
2024 t_ARGS_05,
2025 t_ARGS_06,
2026 t_ARGS_07,
2027 t_ARGS_08,
2028 t_ARGS_09,
2029 t_ARGS_10,
2030 t_ARGS_11,
2031 t_ARGS_12)> {
2032 enum {
2033 IS_MEMBER_FUNCTION_PTR = 1,
2034 IS_LVALREF_QUALIFIED = 0,
2035 IS_RVALREF_QUALIFIED = 0,
2036 IS_NOEXCEPT = 0
2037 };
2038 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2039 t_BSLMF_RETURN,
2040 t_TYPE,
2041 t_ARGS_01,
2042 t_ARGS_02,
2043 t_ARGS_03,
2044 t_ARGS_04,
2045 t_ARGS_05,
2046 t_ARGS_06,
2047 t_ARGS_07,
2048 t_ARGS_08,
2049 t_ARGS_09,
2050 t_ARGS_10,
2051 t_ARGS_11,
2052 t_ARGS_12>::Type
2053 ClassType;
2054 typedef t_BSLMF_RETURN ResultType;
2055 typedef typename TypeList<t_ARGS_01,
2056 t_ARGS_02,
2057 t_ARGS_03,
2058 t_ARGS_04,
2059 t_ARGS_05,
2060 t_ARGS_06,
2061 t_ARGS_07,
2062 t_ARGS_08,
2063 t_ARGS_09,
2064 t_ARGS_10,
2065 t_ARGS_11,
2066 t_ARGS_12>::Type ArgumentList;
2067};
2068#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
2069
2070#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
2071template <class t_PROTOTYPE,
2072 class t_BSLMF_RETURN,
2073 class t_TYPE,
2074 class t_ARGS_01,
2075 class t_ARGS_02,
2076 class t_ARGS_03,
2077 class t_ARGS_04,
2078 class t_ARGS_05,
2079 class t_ARGS_06,
2080 class t_ARGS_07,
2081 class t_ARGS_08,
2082 class t_ARGS_09,
2083 class t_ARGS_10,
2084 class t_ARGS_11,
2085 class t_ARGS_12,
2086 class t_ARGS_13>
2087struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2088 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2089 t_ARGS_02,
2090 t_ARGS_03,
2091 t_ARGS_04,
2092 t_ARGS_05,
2093 t_ARGS_06,
2094 t_ARGS_07,
2095 t_ARGS_08,
2096 t_ARGS_09,
2097 t_ARGS_10,
2098 t_ARGS_11,
2099 t_ARGS_12,
2100 t_ARGS_13)> {
2101 enum {
2102 IS_MEMBER_FUNCTION_PTR = 1,
2103 IS_LVALREF_QUALIFIED = 0,
2104 IS_RVALREF_QUALIFIED = 0,
2105 IS_NOEXCEPT = 0
2106 };
2107 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2108 t_BSLMF_RETURN,
2109 t_TYPE,
2110 t_ARGS_01,
2111 t_ARGS_02,
2112 t_ARGS_03,
2113 t_ARGS_04,
2114 t_ARGS_05,
2115 t_ARGS_06,
2116 t_ARGS_07,
2117 t_ARGS_08,
2118 t_ARGS_09,
2119 t_ARGS_10,
2120 t_ARGS_11,
2121 t_ARGS_12,
2122 t_ARGS_13>::Type
2123 ClassType;
2124 typedef t_BSLMF_RETURN ResultType;
2125 typedef typename TypeList<t_ARGS_01,
2126 t_ARGS_02,
2127 t_ARGS_03,
2128 t_ARGS_04,
2129 t_ARGS_05,
2130 t_ARGS_06,
2131 t_ARGS_07,
2132 t_ARGS_08,
2133 t_ARGS_09,
2134 t_ARGS_10,
2135 t_ARGS_11,
2136 t_ARGS_12,
2137 t_ARGS_13>::Type ArgumentList;
2138};
2139#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
2140
2141#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
2142template <class t_PROTOTYPE,
2143 class t_BSLMF_RETURN,
2144 class t_TYPE,
2145 class t_ARGS_01,
2146 class t_ARGS_02,
2147 class t_ARGS_03,
2148 class t_ARGS_04,
2149 class t_ARGS_05,
2150 class t_ARGS_06,
2151 class t_ARGS_07,
2152 class t_ARGS_08,
2153 class t_ARGS_09,
2154 class t_ARGS_10,
2155 class t_ARGS_11,
2156 class t_ARGS_12,
2157 class t_ARGS_13,
2158 class t_ARGS_14>
2159struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2160 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2161 t_ARGS_02,
2162 t_ARGS_03,
2163 t_ARGS_04,
2164 t_ARGS_05,
2165 t_ARGS_06,
2166 t_ARGS_07,
2167 t_ARGS_08,
2168 t_ARGS_09,
2169 t_ARGS_10,
2170 t_ARGS_11,
2171 t_ARGS_12,
2172 t_ARGS_13,
2173 t_ARGS_14)> {
2174 enum {
2175 IS_MEMBER_FUNCTION_PTR = 1,
2176 IS_LVALREF_QUALIFIED = 0,
2177 IS_RVALREF_QUALIFIED = 0,
2178 IS_NOEXCEPT = 0
2179 };
2180 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2181 t_BSLMF_RETURN,
2182 t_TYPE,
2183 t_ARGS_01,
2184 t_ARGS_02,
2185 t_ARGS_03,
2186 t_ARGS_04,
2187 t_ARGS_05,
2188 t_ARGS_06,
2189 t_ARGS_07,
2190 t_ARGS_08,
2191 t_ARGS_09,
2192 t_ARGS_10,
2193 t_ARGS_11,
2194 t_ARGS_12,
2195 t_ARGS_13,
2196 t_ARGS_14>::Type
2197 ClassType;
2198 typedef t_BSLMF_RETURN ResultType;
2199 typedef typename TypeList<t_ARGS_01,
2200 t_ARGS_02,
2201 t_ARGS_03,
2202 t_ARGS_04,
2203 t_ARGS_05,
2204 t_ARGS_06,
2205 t_ARGS_07,
2206 t_ARGS_08,
2207 t_ARGS_09,
2208 t_ARGS_10,
2209 t_ARGS_11,
2210 t_ARGS_12,
2211 t_ARGS_13,
2212 t_ARGS_14>::Type ArgumentList;
2213};
2214#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
2215
2216#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
2217template <class t_PROTOTYPE, class t_BSLMF_RETURN, class t_TYPE>
2218struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2219 t_BSLMF_RETURN (t_TYPE::*)() const> {
2220 enum {
2221 IS_MEMBER_FUNCTION_PTR = 1,
2222 IS_LVALREF_QUALIFIED = 0,
2223 IS_RVALREF_QUALIFIED = 0,
2224 IS_NOEXCEPT = 0
2225 };
2226 typedef
2227 typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2228 t_BSLMF_RETURN,
2229 t_TYPE>::Type ClassType;
2230 typedef t_BSLMF_RETURN ResultType;
2231 typedef typename TypeList<>::Type ArgumentList;
2232};
2233#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
2234
2235#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
2236template <class t_PROTOTYPE,
2237 class t_BSLMF_RETURN,
2238 class t_TYPE,
2239 class t_ARGS_01>
2240struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2241 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01)
2242 const> {
2243 enum {
2244 IS_MEMBER_FUNCTION_PTR = 1,
2245 IS_LVALREF_QUALIFIED = 0,
2246 IS_RVALREF_QUALIFIED = 0,
2247 IS_NOEXCEPT = 0
2248 };
2249 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2250 t_BSLMF_RETURN,
2251 t_TYPE,
2252 t_ARGS_01>::Type
2253 ClassType;
2254 typedef t_BSLMF_RETURN ResultType;
2255 typedef typename TypeList<t_ARGS_01>::Type ArgumentList;
2256};
2257#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
2258
2259#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
2260template <class t_PROTOTYPE,
2261 class t_BSLMF_RETURN,
2262 class t_TYPE,
2263 class t_ARGS_01,
2264 class t_ARGS_02>
2265struct MemberFunctionPointerTraits_Imp<
2266 t_PROTOTYPE,
2267 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02) const> {
2268 enum {
2269 IS_MEMBER_FUNCTION_PTR = 1,
2270 IS_LVALREF_QUALIFIED = 0,
2271 IS_RVALREF_QUALIFIED = 0,
2272 IS_NOEXCEPT = 0
2273 };
2274 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2275 t_BSLMF_RETURN,
2276 t_TYPE,
2277 t_ARGS_01,
2278 t_ARGS_02>::Type
2279 ClassType;
2280 typedef t_BSLMF_RETURN ResultType;
2281 typedef typename TypeList<t_ARGS_01,
2282 t_ARGS_02>::Type ArgumentList;
2283};
2284#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
2285
2286#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
2287template <class t_PROTOTYPE,
2288 class t_BSLMF_RETURN,
2289 class t_TYPE,
2290 class t_ARGS_01,
2291 class t_ARGS_02,
2292 class t_ARGS_03>
2293struct MemberFunctionPointerTraits_Imp<
2294 t_PROTOTYPE,
2295 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03) const> {
2296 enum {
2297 IS_MEMBER_FUNCTION_PTR = 1,
2298 IS_LVALREF_QUALIFIED = 0,
2299 IS_RVALREF_QUALIFIED = 0,
2300 IS_NOEXCEPT = 0
2301 };
2302 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2303 t_BSLMF_RETURN,
2304 t_TYPE,
2305 t_ARGS_01,
2306 t_ARGS_02,
2307 t_ARGS_03>::Type
2308 ClassType;
2309 typedef t_BSLMF_RETURN ResultType;
2310 typedef typename TypeList<t_ARGS_01,
2311 t_ARGS_02,
2312 t_ARGS_03>::Type ArgumentList;
2313};
2314#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
2315
2316#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
2317template <class t_PROTOTYPE,
2318 class t_BSLMF_RETURN,
2319 class t_TYPE,
2320 class t_ARGS_01,
2321 class t_ARGS_02,
2322 class t_ARGS_03,
2323 class t_ARGS_04>
2324struct MemberFunctionPointerTraits_Imp<
2325 t_PROTOTYPE,
2326 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04)
2327 const> {
2328 enum {
2329 IS_MEMBER_FUNCTION_PTR = 1,
2330 IS_LVALREF_QUALIFIED = 0,
2331 IS_RVALREF_QUALIFIED = 0,
2332 IS_NOEXCEPT = 0
2333 };
2334 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2335 t_BSLMF_RETURN,
2336 t_TYPE,
2337 t_ARGS_01,
2338 t_ARGS_02,
2339 t_ARGS_03,
2340 t_ARGS_04>::Type
2341 ClassType;
2342 typedef t_BSLMF_RETURN ResultType;
2343 typedef typename TypeList<t_ARGS_01,
2344 t_ARGS_02,
2345 t_ARGS_03,
2346 t_ARGS_04>::Type ArgumentList;
2347};
2348#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
2349
2350#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
2351template <class t_PROTOTYPE,
2352 class t_BSLMF_RETURN,
2353 class t_TYPE,
2354 class t_ARGS_01,
2355 class t_ARGS_02,
2356 class t_ARGS_03,
2357 class t_ARGS_04,
2358 class t_ARGS_05>
2359struct MemberFunctionPointerTraits_Imp<
2360 t_PROTOTYPE,
2361 t_BSLMF_RETURN (
2362 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04, t_ARGS_05)
2363 const> {
2364 enum {
2365 IS_MEMBER_FUNCTION_PTR = 1,
2366 IS_LVALREF_QUALIFIED = 0,
2367 IS_RVALREF_QUALIFIED = 0,
2368 IS_NOEXCEPT = 0
2369 };
2370 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2371 t_BSLMF_RETURN,
2372 t_TYPE,
2373 t_ARGS_01,
2374 t_ARGS_02,
2375 t_ARGS_03,
2376 t_ARGS_04,
2377 t_ARGS_05>::Type
2378 ClassType;
2379 typedef t_BSLMF_RETURN ResultType;
2380 typedef typename TypeList<t_ARGS_01,
2381 t_ARGS_02,
2382 t_ARGS_03,
2383 t_ARGS_04,
2384 t_ARGS_05>::Type ArgumentList;
2385};
2386#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
2387
2388#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
2389template <class t_PROTOTYPE,
2390 class t_BSLMF_RETURN,
2391 class t_TYPE,
2392 class t_ARGS_01,
2393 class t_ARGS_02,
2394 class t_ARGS_03,
2395 class t_ARGS_04,
2396 class t_ARGS_05,
2397 class t_ARGS_06>
2398struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2399 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2400 t_ARGS_02,
2401 t_ARGS_03,
2402 t_ARGS_04,
2403 t_ARGS_05,
2404 t_ARGS_06)
2405 const> {
2406 enum {
2407 IS_MEMBER_FUNCTION_PTR = 1,
2408 IS_LVALREF_QUALIFIED = 0,
2409 IS_RVALREF_QUALIFIED = 0,
2410 IS_NOEXCEPT = 0
2411 };
2412 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2413 t_BSLMF_RETURN,
2414 t_TYPE,
2415 t_ARGS_01,
2416 t_ARGS_02,
2417 t_ARGS_03,
2418 t_ARGS_04,
2419 t_ARGS_05,
2420 t_ARGS_06>::Type
2421 ClassType;
2422 typedef t_BSLMF_RETURN ResultType;
2423 typedef typename TypeList<t_ARGS_01,
2424 t_ARGS_02,
2425 t_ARGS_03,
2426 t_ARGS_04,
2427 t_ARGS_05,
2428 t_ARGS_06>::Type ArgumentList;
2429};
2430#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
2431
2432#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
2433template <class t_PROTOTYPE,
2434 class t_BSLMF_RETURN,
2435 class t_TYPE,
2436 class t_ARGS_01,
2437 class t_ARGS_02,
2438 class t_ARGS_03,
2439 class t_ARGS_04,
2440 class t_ARGS_05,
2441 class t_ARGS_06,
2442 class t_ARGS_07>
2443struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2444 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2445 t_ARGS_02,
2446 t_ARGS_03,
2447 t_ARGS_04,
2448 t_ARGS_05,
2449 t_ARGS_06,
2450 t_ARGS_07)
2451 const> {
2452 enum {
2453 IS_MEMBER_FUNCTION_PTR = 1,
2454 IS_LVALREF_QUALIFIED = 0,
2455 IS_RVALREF_QUALIFIED = 0,
2456 IS_NOEXCEPT = 0
2457 };
2458 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2459 t_BSLMF_RETURN,
2460 t_TYPE,
2461 t_ARGS_01,
2462 t_ARGS_02,
2463 t_ARGS_03,
2464 t_ARGS_04,
2465 t_ARGS_05,
2466 t_ARGS_06,
2467 t_ARGS_07>::Type
2468 ClassType;
2469 typedef t_BSLMF_RETURN ResultType;
2470 typedef typename TypeList<t_ARGS_01,
2471 t_ARGS_02,
2472 t_ARGS_03,
2473 t_ARGS_04,
2474 t_ARGS_05,
2475 t_ARGS_06,
2476 t_ARGS_07>::Type ArgumentList;
2477};
2478#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
2479
2480#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
2481template <class t_PROTOTYPE,
2482 class t_BSLMF_RETURN,
2483 class t_TYPE,
2484 class t_ARGS_01,
2485 class t_ARGS_02,
2486 class t_ARGS_03,
2487 class t_ARGS_04,
2488 class t_ARGS_05,
2489 class t_ARGS_06,
2490 class t_ARGS_07,
2491 class t_ARGS_08>
2492struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2493 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2494 t_ARGS_02,
2495 t_ARGS_03,
2496 t_ARGS_04,
2497 t_ARGS_05,
2498 t_ARGS_06,
2499 t_ARGS_07,
2500 t_ARGS_08)
2501 const> {
2502 enum {
2503 IS_MEMBER_FUNCTION_PTR = 1,
2504 IS_LVALREF_QUALIFIED = 0,
2505 IS_RVALREF_QUALIFIED = 0,
2506 IS_NOEXCEPT = 0
2507 };
2508 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2509 t_BSLMF_RETURN,
2510 t_TYPE,
2511 t_ARGS_01,
2512 t_ARGS_02,
2513 t_ARGS_03,
2514 t_ARGS_04,
2515 t_ARGS_05,
2516 t_ARGS_06,
2517 t_ARGS_07,
2518 t_ARGS_08>::Type
2519 ClassType;
2520 typedef t_BSLMF_RETURN ResultType;
2521 typedef typename TypeList<t_ARGS_01,
2522 t_ARGS_02,
2523 t_ARGS_03,
2524 t_ARGS_04,
2525 t_ARGS_05,
2526 t_ARGS_06,
2527 t_ARGS_07,
2528 t_ARGS_08>::Type ArgumentList;
2529};
2530#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
2531
2532#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
2533template <class t_PROTOTYPE,
2534 class t_BSLMF_RETURN,
2535 class t_TYPE,
2536 class t_ARGS_01,
2537 class t_ARGS_02,
2538 class t_ARGS_03,
2539 class t_ARGS_04,
2540 class t_ARGS_05,
2541 class t_ARGS_06,
2542 class t_ARGS_07,
2543 class t_ARGS_08,
2544 class t_ARGS_09>
2545struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2546 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2547 t_ARGS_02,
2548 t_ARGS_03,
2549 t_ARGS_04,
2550 t_ARGS_05,
2551 t_ARGS_06,
2552 t_ARGS_07,
2553 t_ARGS_08,
2554 t_ARGS_09)
2555 const> {
2556 enum {
2557 IS_MEMBER_FUNCTION_PTR = 1,
2558 IS_LVALREF_QUALIFIED = 0,
2559 IS_RVALREF_QUALIFIED = 0,
2560 IS_NOEXCEPT = 0
2561 };
2562 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2563 t_BSLMF_RETURN,
2564 t_TYPE,
2565 t_ARGS_01,
2566 t_ARGS_02,
2567 t_ARGS_03,
2568 t_ARGS_04,
2569 t_ARGS_05,
2570 t_ARGS_06,
2571 t_ARGS_07,
2572 t_ARGS_08,
2573 t_ARGS_09>::Type
2574 ClassType;
2575 typedef t_BSLMF_RETURN ResultType;
2576 typedef typename TypeList<t_ARGS_01,
2577 t_ARGS_02,
2578 t_ARGS_03,
2579 t_ARGS_04,
2580 t_ARGS_05,
2581 t_ARGS_06,
2582 t_ARGS_07,
2583 t_ARGS_08,
2584 t_ARGS_09>::Type ArgumentList;
2585};
2586#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
2587
2588#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
2589template <class t_PROTOTYPE,
2590 class t_BSLMF_RETURN,
2591 class t_TYPE,
2592 class t_ARGS_01,
2593 class t_ARGS_02,
2594 class t_ARGS_03,
2595 class t_ARGS_04,
2596 class t_ARGS_05,
2597 class t_ARGS_06,
2598 class t_ARGS_07,
2599 class t_ARGS_08,
2600 class t_ARGS_09,
2601 class t_ARGS_10>
2602struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2603 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2604 t_ARGS_02,
2605 t_ARGS_03,
2606 t_ARGS_04,
2607 t_ARGS_05,
2608 t_ARGS_06,
2609 t_ARGS_07,
2610 t_ARGS_08,
2611 t_ARGS_09,
2612 t_ARGS_10)
2613 const> {
2614 enum {
2615 IS_MEMBER_FUNCTION_PTR = 1,
2616 IS_LVALREF_QUALIFIED = 0,
2617 IS_RVALREF_QUALIFIED = 0,
2618 IS_NOEXCEPT = 0
2619 };
2620 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2621 t_BSLMF_RETURN,
2622 t_TYPE,
2623 t_ARGS_01,
2624 t_ARGS_02,
2625 t_ARGS_03,
2626 t_ARGS_04,
2627 t_ARGS_05,
2628 t_ARGS_06,
2629 t_ARGS_07,
2630 t_ARGS_08,
2631 t_ARGS_09,
2632 t_ARGS_10>::Type
2633 ClassType;
2634 typedef t_BSLMF_RETURN ResultType;
2635 typedef typename TypeList<t_ARGS_01,
2636 t_ARGS_02,
2637 t_ARGS_03,
2638 t_ARGS_04,
2639 t_ARGS_05,
2640 t_ARGS_06,
2641 t_ARGS_07,
2642 t_ARGS_08,
2643 t_ARGS_09,
2644 t_ARGS_10>::Type ArgumentList;
2645};
2646#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
2647
2648#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
2649template <class t_PROTOTYPE,
2650 class t_BSLMF_RETURN,
2651 class t_TYPE,
2652 class t_ARGS_01,
2653 class t_ARGS_02,
2654 class t_ARGS_03,
2655 class t_ARGS_04,
2656 class t_ARGS_05,
2657 class t_ARGS_06,
2658 class t_ARGS_07,
2659 class t_ARGS_08,
2660 class t_ARGS_09,
2661 class t_ARGS_10,
2662 class t_ARGS_11>
2663struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2664 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2665 t_ARGS_02,
2666 t_ARGS_03,
2667 t_ARGS_04,
2668 t_ARGS_05,
2669 t_ARGS_06,
2670 t_ARGS_07,
2671 t_ARGS_08,
2672 t_ARGS_09,
2673 t_ARGS_10,
2674 t_ARGS_11)
2675 const> {
2676 enum {
2677 IS_MEMBER_FUNCTION_PTR = 1,
2678 IS_LVALREF_QUALIFIED = 0,
2679 IS_RVALREF_QUALIFIED = 0,
2680 IS_NOEXCEPT = 0
2681 };
2682 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2683 t_BSLMF_RETURN,
2684 t_TYPE,
2685 t_ARGS_01,
2686 t_ARGS_02,
2687 t_ARGS_03,
2688 t_ARGS_04,
2689 t_ARGS_05,
2690 t_ARGS_06,
2691 t_ARGS_07,
2692 t_ARGS_08,
2693 t_ARGS_09,
2694 t_ARGS_10,
2695 t_ARGS_11>::Type
2696 ClassType;
2697 typedef t_BSLMF_RETURN ResultType;
2698 typedef typename TypeList<t_ARGS_01,
2699 t_ARGS_02,
2700 t_ARGS_03,
2701 t_ARGS_04,
2702 t_ARGS_05,
2703 t_ARGS_06,
2704 t_ARGS_07,
2705 t_ARGS_08,
2706 t_ARGS_09,
2707 t_ARGS_10,
2708 t_ARGS_11>::Type ArgumentList;
2709};
2710#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
2711
2712#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
2713template <class t_PROTOTYPE,
2714 class t_BSLMF_RETURN,
2715 class t_TYPE,
2716 class t_ARGS_01,
2717 class t_ARGS_02,
2718 class t_ARGS_03,
2719 class t_ARGS_04,
2720 class t_ARGS_05,
2721 class t_ARGS_06,
2722 class t_ARGS_07,
2723 class t_ARGS_08,
2724 class t_ARGS_09,
2725 class t_ARGS_10,
2726 class t_ARGS_11,
2727 class t_ARGS_12>
2728struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2729 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2730 t_ARGS_02,
2731 t_ARGS_03,
2732 t_ARGS_04,
2733 t_ARGS_05,
2734 t_ARGS_06,
2735 t_ARGS_07,
2736 t_ARGS_08,
2737 t_ARGS_09,
2738 t_ARGS_10,
2739 t_ARGS_11,
2740 t_ARGS_12)
2741 const> {
2742 enum {
2743 IS_MEMBER_FUNCTION_PTR = 1,
2744 IS_LVALREF_QUALIFIED = 0,
2745 IS_RVALREF_QUALIFIED = 0,
2746 IS_NOEXCEPT = 0
2747 };
2748 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2749 t_BSLMF_RETURN,
2750 t_TYPE,
2751 t_ARGS_01,
2752 t_ARGS_02,
2753 t_ARGS_03,
2754 t_ARGS_04,
2755 t_ARGS_05,
2756 t_ARGS_06,
2757 t_ARGS_07,
2758 t_ARGS_08,
2759 t_ARGS_09,
2760 t_ARGS_10,
2761 t_ARGS_11,
2762 t_ARGS_12>::Type
2763 ClassType;
2764 typedef t_BSLMF_RETURN ResultType;
2765 typedef typename TypeList<t_ARGS_01,
2766 t_ARGS_02,
2767 t_ARGS_03,
2768 t_ARGS_04,
2769 t_ARGS_05,
2770 t_ARGS_06,
2771 t_ARGS_07,
2772 t_ARGS_08,
2773 t_ARGS_09,
2774 t_ARGS_10,
2775 t_ARGS_11,
2776 t_ARGS_12>::Type ArgumentList;
2777};
2778#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
2779
2780#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
2781template <class t_PROTOTYPE,
2782 class t_BSLMF_RETURN,
2783 class t_TYPE,
2784 class t_ARGS_01,
2785 class t_ARGS_02,
2786 class t_ARGS_03,
2787 class t_ARGS_04,
2788 class t_ARGS_05,
2789 class t_ARGS_06,
2790 class t_ARGS_07,
2791 class t_ARGS_08,
2792 class t_ARGS_09,
2793 class t_ARGS_10,
2794 class t_ARGS_11,
2795 class t_ARGS_12,
2796 class t_ARGS_13>
2797struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2798 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2799 t_ARGS_02,
2800 t_ARGS_03,
2801 t_ARGS_04,
2802 t_ARGS_05,
2803 t_ARGS_06,
2804 t_ARGS_07,
2805 t_ARGS_08,
2806 t_ARGS_09,
2807 t_ARGS_10,
2808 t_ARGS_11,
2809 t_ARGS_12,
2810 t_ARGS_13)
2811 const> {
2812 enum {
2813 IS_MEMBER_FUNCTION_PTR = 1,
2814 IS_LVALREF_QUALIFIED = 0,
2815 IS_RVALREF_QUALIFIED = 0,
2816 IS_NOEXCEPT = 0
2817 };
2818 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2819 t_BSLMF_RETURN,
2820 t_TYPE,
2821 t_ARGS_01,
2822 t_ARGS_02,
2823 t_ARGS_03,
2824 t_ARGS_04,
2825 t_ARGS_05,
2826 t_ARGS_06,
2827 t_ARGS_07,
2828 t_ARGS_08,
2829 t_ARGS_09,
2830 t_ARGS_10,
2831 t_ARGS_11,
2832 t_ARGS_12,
2833 t_ARGS_13>::Type
2834 ClassType;
2835 typedef t_BSLMF_RETURN ResultType;
2836 typedef typename TypeList<t_ARGS_01,
2837 t_ARGS_02,
2838 t_ARGS_03,
2839 t_ARGS_04,
2840 t_ARGS_05,
2841 t_ARGS_06,
2842 t_ARGS_07,
2843 t_ARGS_08,
2844 t_ARGS_09,
2845 t_ARGS_10,
2846 t_ARGS_11,
2847 t_ARGS_12,
2848 t_ARGS_13>::Type ArgumentList;
2849};
2850#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
2851
2852#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
2853template <class t_PROTOTYPE,
2854 class t_BSLMF_RETURN,
2855 class t_TYPE,
2856 class t_ARGS_01,
2857 class t_ARGS_02,
2858 class t_ARGS_03,
2859 class t_ARGS_04,
2860 class t_ARGS_05,
2861 class t_ARGS_06,
2862 class t_ARGS_07,
2863 class t_ARGS_08,
2864 class t_ARGS_09,
2865 class t_ARGS_10,
2866 class t_ARGS_11,
2867 class t_ARGS_12,
2868 class t_ARGS_13,
2869 class t_ARGS_14>
2870struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2871 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
2872 t_ARGS_02,
2873 t_ARGS_03,
2874 t_ARGS_04,
2875 t_ARGS_05,
2876 t_ARGS_06,
2877 t_ARGS_07,
2878 t_ARGS_08,
2879 t_ARGS_09,
2880 t_ARGS_10,
2881 t_ARGS_11,
2882 t_ARGS_12,
2883 t_ARGS_13,
2884 t_ARGS_14)
2885 const> {
2886 enum {
2887 IS_MEMBER_FUNCTION_PTR = 1,
2888 IS_LVALREF_QUALIFIED = 0,
2889 IS_RVALREF_QUALIFIED = 0,
2890 IS_NOEXCEPT = 0
2891 };
2892 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2893 t_BSLMF_RETURN,
2894 t_TYPE,
2895 t_ARGS_01,
2896 t_ARGS_02,
2897 t_ARGS_03,
2898 t_ARGS_04,
2899 t_ARGS_05,
2900 t_ARGS_06,
2901 t_ARGS_07,
2902 t_ARGS_08,
2903 t_ARGS_09,
2904 t_ARGS_10,
2905 t_ARGS_11,
2906 t_ARGS_12,
2907 t_ARGS_13,
2908 t_ARGS_14>::Type
2909 ClassType;
2910 typedef t_BSLMF_RETURN ResultType;
2911 typedef typename TypeList<t_ARGS_01,
2912 t_ARGS_02,
2913 t_ARGS_03,
2914 t_ARGS_04,
2915 t_ARGS_05,
2916 t_ARGS_06,
2917 t_ARGS_07,
2918 t_ARGS_08,
2919 t_ARGS_09,
2920 t_ARGS_10,
2921 t_ARGS_11,
2922 t_ARGS_12,
2923 t_ARGS_13,
2924 t_ARGS_14>::Type ArgumentList;
2925};
2926#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
2927
2928#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
2929template <class t_PROTOTYPE, class t_BSLMF_RETURN, class t_TYPE>
2930struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
2931 t_BSLMF_RETURN (t_TYPE::*)() volatile> {
2932 enum {
2933 IS_MEMBER_FUNCTION_PTR = 1,
2934 IS_LVALREF_QUALIFIED = 0,
2935 IS_RVALREF_QUALIFIED = 0,
2936 IS_NOEXCEPT = 0
2937 };
2938
2939 typedef
2940 typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2941 t_BSLMF_RETURN,
2942 t_TYPE>::Type ClassType;
2943 typedef t_BSLMF_RETURN ResultType;
2944 typedef typename TypeList<>::Type ArgumentList;
2945};
2946#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
2947
2948#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
2949template <class t_PROTOTYPE,
2950 class t_BSLMF_RETURN,
2951 class t_TYPE,
2952 class t_ARGS_01>
2953struct MemberFunctionPointerTraits_Imp<
2954 t_PROTOTYPE,
2955 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01) volatile> {
2956 enum {
2957 IS_MEMBER_FUNCTION_PTR = 1,
2958 IS_LVALREF_QUALIFIED = 0,
2959 IS_RVALREF_QUALIFIED = 0,
2960 IS_NOEXCEPT = 0
2961 };
2962
2963 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2964 t_BSLMF_RETURN,
2965 t_TYPE,
2966 t_ARGS_01>::Type
2967 ClassType;
2968 typedef t_BSLMF_RETURN ResultType;
2969 typedef typename TypeList<t_ARGS_01>::Type ArgumentList;
2970};
2971#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
2972
2973#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
2974template <class t_PROTOTYPE,
2975 class t_BSLMF_RETURN,
2976 class t_TYPE,
2977 class t_ARGS_01,
2978 class t_ARGS_02>
2979struct MemberFunctionPointerTraits_Imp<
2980 t_PROTOTYPE,
2981 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02) volatile> {
2982 enum {
2983 IS_MEMBER_FUNCTION_PTR = 1,
2984 IS_LVALREF_QUALIFIED = 0,
2985 IS_RVALREF_QUALIFIED = 0,
2986 IS_NOEXCEPT = 0
2987 };
2988
2989 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
2990 t_BSLMF_RETURN,
2991 t_TYPE,
2992 t_ARGS_01,
2993 t_ARGS_02>::Type
2994 ClassType;
2995 typedef t_BSLMF_RETURN ResultType;
2996 typedef typename TypeList<t_ARGS_01,
2997 t_ARGS_02>::Type ArgumentList;
2998};
2999#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
3000
3001#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
3002template <class t_PROTOTYPE,
3003 class t_BSLMF_RETURN,
3004 class t_TYPE,
3005 class t_ARGS_01,
3006 class t_ARGS_02,
3007 class t_ARGS_03>
3008struct MemberFunctionPointerTraits_Imp<
3009 t_PROTOTYPE,
3010 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03) volatile> {
3011 enum {
3012 IS_MEMBER_FUNCTION_PTR = 1,
3013 IS_LVALREF_QUALIFIED = 0,
3014 IS_RVALREF_QUALIFIED = 0,
3015 IS_NOEXCEPT = 0
3016 };
3017
3018 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3019 t_BSLMF_RETURN,
3020 t_TYPE,
3021 t_ARGS_01,
3022 t_ARGS_02,
3023 t_ARGS_03>::Type
3024 ClassType;
3025 typedef t_BSLMF_RETURN ResultType;
3026 typedef typename TypeList<t_ARGS_01,
3027 t_ARGS_02,
3028 t_ARGS_03>::Type ArgumentList;
3029};
3030#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
3031
3032#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
3033template <class t_PROTOTYPE,
3034 class t_BSLMF_RETURN,
3035 class t_TYPE,
3036 class t_ARGS_01,
3037 class t_ARGS_02,
3038 class t_ARGS_03,
3039 class t_ARGS_04>
3040struct MemberFunctionPointerTraits_Imp<
3041 t_PROTOTYPE,
3042 t_BSLMF_RETURN (
3043 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04) volatile> {
3044 enum {
3045 IS_MEMBER_FUNCTION_PTR = 1,
3046 IS_LVALREF_QUALIFIED = 0,
3047 IS_RVALREF_QUALIFIED = 0,
3048 IS_NOEXCEPT = 0
3049 };
3050
3051 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3052 t_BSLMF_RETURN,
3053 t_TYPE,
3054 t_ARGS_01,
3055 t_ARGS_02,
3056 t_ARGS_03,
3057 t_ARGS_04>::Type
3058 ClassType;
3059 typedef t_BSLMF_RETURN ResultType;
3060 typedef typename TypeList<t_ARGS_01,
3061 t_ARGS_02,
3062 t_ARGS_03,
3063 t_ARGS_04>::Type ArgumentList;
3064};
3065#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
3066
3067#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
3068template <class t_PROTOTYPE,
3069 class t_BSLMF_RETURN,
3070 class t_TYPE,
3071 class t_ARGS_01,
3072 class t_ARGS_02,
3073 class t_ARGS_03,
3074 class t_ARGS_04,
3075 class t_ARGS_05>
3076struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3077 t_BSLMF_RETURN (t_TYPE::*)(
3078 t_ARGS_01,
3079 t_ARGS_02,
3080 t_ARGS_03,
3081 t_ARGS_04,
3082 t_ARGS_05) volatile> {
3083 enum {
3084 IS_MEMBER_FUNCTION_PTR = 1,
3085 IS_LVALREF_QUALIFIED = 0,
3086 IS_RVALREF_QUALIFIED = 0,
3087 IS_NOEXCEPT = 0
3088 };
3089
3090 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3091 t_BSLMF_RETURN,
3092 t_TYPE,
3093 t_ARGS_01,
3094 t_ARGS_02,
3095 t_ARGS_03,
3096 t_ARGS_04,
3097 t_ARGS_05>::Type
3098 ClassType;
3099 typedef t_BSLMF_RETURN ResultType;
3100 typedef typename TypeList<t_ARGS_01,
3101 t_ARGS_02,
3102 t_ARGS_03,
3103 t_ARGS_04,
3104 t_ARGS_05>::Type ArgumentList;
3105};
3106#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
3107
3108#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
3109template <class t_PROTOTYPE,
3110 class t_BSLMF_RETURN,
3111 class t_TYPE,
3112 class t_ARGS_01,
3113 class t_ARGS_02,
3114 class t_ARGS_03,
3115 class t_ARGS_04,
3116 class t_ARGS_05,
3117 class t_ARGS_06>
3118struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3119 t_BSLMF_RETURN (t_TYPE::*)(
3120 t_ARGS_01,
3121 t_ARGS_02,
3122 t_ARGS_03,
3123 t_ARGS_04,
3124 t_ARGS_05,
3125 t_ARGS_06) volatile> {
3126 enum {
3127 IS_MEMBER_FUNCTION_PTR = 1,
3128 IS_LVALREF_QUALIFIED = 0,
3129 IS_RVALREF_QUALIFIED = 0,
3130 IS_NOEXCEPT = 0
3131 };
3132
3133 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3134 t_BSLMF_RETURN,
3135 t_TYPE,
3136 t_ARGS_01,
3137 t_ARGS_02,
3138 t_ARGS_03,
3139 t_ARGS_04,
3140 t_ARGS_05,
3141 t_ARGS_06>::Type
3142 ClassType;
3143 typedef t_BSLMF_RETURN ResultType;
3144 typedef typename TypeList<t_ARGS_01,
3145 t_ARGS_02,
3146 t_ARGS_03,
3147 t_ARGS_04,
3148 t_ARGS_05,
3149 t_ARGS_06>::Type ArgumentList;
3150};
3151#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
3152
3153#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
3154template <class t_PROTOTYPE,
3155 class t_BSLMF_RETURN,
3156 class t_TYPE,
3157 class t_ARGS_01,
3158 class t_ARGS_02,
3159 class t_ARGS_03,
3160 class t_ARGS_04,
3161 class t_ARGS_05,
3162 class t_ARGS_06,
3163 class t_ARGS_07>
3164struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3165 t_BSLMF_RETURN (t_TYPE::*)(
3166 t_ARGS_01,
3167 t_ARGS_02,
3168 t_ARGS_03,
3169 t_ARGS_04,
3170 t_ARGS_05,
3171 t_ARGS_06,
3172 t_ARGS_07) volatile> {
3173 enum {
3174 IS_MEMBER_FUNCTION_PTR = 1,
3175 IS_LVALREF_QUALIFIED = 0,
3176 IS_RVALREF_QUALIFIED = 0,
3177 IS_NOEXCEPT = 0
3178 };
3179
3180 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3181 t_BSLMF_RETURN,
3182 t_TYPE,
3183 t_ARGS_01,
3184 t_ARGS_02,
3185 t_ARGS_03,
3186 t_ARGS_04,
3187 t_ARGS_05,
3188 t_ARGS_06,
3189 t_ARGS_07>::Type
3190 ClassType;
3191 typedef t_BSLMF_RETURN ResultType;
3192 typedef typename TypeList<t_ARGS_01,
3193 t_ARGS_02,
3194 t_ARGS_03,
3195 t_ARGS_04,
3196 t_ARGS_05,
3197 t_ARGS_06,
3198 t_ARGS_07>::Type ArgumentList;
3199};
3200#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
3201
3202#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
3203template <class t_PROTOTYPE,
3204 class t_BSLMF_RETURN,
3205 class t_TYPE,
3206 class t_ARGS_01,
3207 class t_ARGS_02,
3208 class t_ARGS_03,
3209 class t_ARGS_04,
3210 class t_ARGS_05,
3211 class t_ARGS_06,
3212 class t_ARGS_07,
3213 class t_ARGS_08>
3214struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3215 t_BSLMF_RETURN (t_TYPE::*)(
3216 t_ARGS_01,
3217 t_ARGS_02,
3218 t_ARGS_03,
3219 t_ARGS_04,
3220 t_ARGS_05,
3221 t_ARGS_06,
3222 t_ARGS_07,
3223 t_ARGS_08) volatile> {
3224 enum {
3225 IS_MEMBER_FUNCTION_PTR = 1,
3226 IS_LVALREF_QUALIFIED = 0,
3227 IS_RVALREF_QUALIFIED = 0,
3228 IS_NOEXCEPT = 0
3229 };
3230
3231 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3232 t_BSLMF_RETURN,
3233 t_TYPE,
3234 t_ARGS_01,
3235 t_ARGS_02,
3236 t_ARGS_03,
3237 t_ARGS_04,
3238 t_ARGS_05,
3239 t_ARGS_06,
3240 t_ARGS_07,
3241 t_ARGS_08>::Type
3242 ClassType;
3243 typedef t_BSLMF_RETURN ResultType;
3244 typedef typename TypeList<t_ARGS_01,
3245 t_ARGS_02,
3246 t_ARGS_03,
3247 t_ARGS_04,
3248 t_ARGS_05,
3249 t_ARGS_06,
3250 t_ARGS_07,
3251 t_ARGS_08>::Type ArgumentList;
3252};
3253#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
3254
3255#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
3256template <class t_PROTOTYPE,
3257 class t_BSLMF_RETURN,
3258 class t_TYPE,
3259 class t_ARGS_01,
3260 class t_ARGS_02,
3261 class t_ARGS_03,
3262 class t_ARGS_04,
3263 class t_ARGS_05,
3264 class t_ARGS_06,
3265 class t_ARGS_07,
3266 class t_ARGS_08,
3267 class t_ARGS_09>
3268struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3269 t_BSLMF_RETURN (t_TYPE::*)(
3270 t_ARGS_01,
3271 t_ARGS_02,
3272 t_ARGS_03,
3273 t_ARGS_04,
3274 t_ARGS_05,
3275 t_ARGS_06,
3276 t_ARGS_07,
3277 t_ARGS_08,
3278 t_ARGS_09) volatile> {
3279 enum {
3280 IS_MEMBER_FUNCTION_PTR = 1,
3281 IS_LVALREF_QUALIFIED = 0,
3282 IS_RVALREF_QUALIFIED = 0,
3283 IS_NOEXCEPT = 0
3284 };
3285
3286 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3287 t_BSLMF_RETURN,
3288 t_TYPE,
3289 t_ARGS_01,
3290 t_ARGS_02,
3291 t_ARGS_03,
3292 t_ARGS_04,
3293 t_ARGS_05,
3294 t_ARGS_06,
3295 t_ARGS_07,
3296 t_ARGS_08,
3297 t_ARGS_09>::Type
3298 ClassType;
3299 typedef t_BSLMF_RETURN ResultType;
3300 typedef typename TypeList<t_ARGS_01,
3301 t_ARGS_02,
3302 t_ARGS_03,
3303 t_ARGS_04,
3304 t_ARGS_05,
3305 t_ARGS_06,
3306 t_ARGS_07,
3307 t_ARGS_08,
3308 t_ARGS_09>::Type ArgumentList;
3309};
3310#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
3311
3312#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
3313template <class t_PROTOTYPE,
3314 class t_BSLMF_RETURN,
3315 class t_TYPE,
3316 class t_ARGS_01,
3317 class t_ARGS_02,
3318 class t_ARGS_03,
3319 class t_ARGS_04,
3320 class t_ARGS_05,
3321 class t_ARGS_06,
3322 class t_ARGS_07,
3323 class t_ARGS_08,
3324 class t_ARGS_09,
3325 class t_ARGS_10>
3326struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3327 t_BSLMF_RETURN (t_TYPE::*)(
3328 t_ARGS_01,
3329 t_ARGS_02,
3330 t_ARGS_03,
3331 t_ARGS_04,
3332 t_ARGS_05,
3333 t_ARGS_06,
3334 t_ARGS_07,
3335 t_ARGS_08,
3336 t_ARGS_09,
3337 t_ARGS_10) volatile> {
3338 enum {
3339 IS_MEMBER_FUNCTION_PTR = 1,
3340 IS_LVALREF_QUALIFIED = 0,
3341 IS_RVALREF_QUALIFIED = 0,
3342 IS_NOEXCEPT = 0
3343 };
3344
3345 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3346 t_BSLMF_RETURN,
3347 t_TYPE,
3348 t_ARGS_01,
3349 t_ARGS_02,
3350 t_ARGS_03,
3351 t_ARGS_04,
3352 t_ARGS_05,
3353 t_ARGS_06,
3354 t_ARGS_07,
3355 t_ARGS_08,
3356 t_ARGS_09,
3357 t_ARGS_10>::Type
3358 ClassType;
3359 typedef t_BSLMF_RETURN ResultType;
3360 typedef typename TypeList<t_ARGS_01,
3361 t_ARGS_02,
3362 t_ARGS_03,
3363 t_ARGS_04,
3364 t_ARGS_05,
3365 t_ARGS_06,
3366 t_ARGS_07,
3367 t_ARGS_08,
3368 t_ARGS_09,
3369 t_ARGS_10>::Type ArgumentList;
3370};
3371#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
3372
3373#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
3374template <class t_PROTOTYPE,
3375 class t_BSLMF_RETURN,
3376 class t_TYPE,
3377 class t_ARGS_01,
3378 class t_ARGS_02,
3379 class t_ARGS_03,
3380 class t_ARGS_04,
3381 class t_ARGS_05,
3382 class t_ARGS_06,
3383 class t_ARGS_07,
3384 class t_ARGS_08,
3385 class t_ARGS_09,
3386 class t_ARGS_10,
3387 class t_ARGS_11>
3388struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3389 t_BSLMF_RETURN (t_TYPE::*)(
3390 t_ARGS_01,
3391 t_ARGS_02,
3392 t_ARGS_03,
3393 t_ARGS_04,
3394 t_ARGS_05,
3395 t_ARGS_06,
3396 t_ARGS_07,
3397 t_ARGS_08,
3398 t_ARGS_09,
3399 t_ARGS_10,
3400 t_ARGS_11) volatile> {
3401 enum {
3402 IS_MEMBER_FUNCTION_PTR = 1,
3403 IS_LVALREF_QUALIFIED = 0,
3404 IS_RVALREF_QUALIFIED = 0,
3405 IS_NOEXCEPT = 0
3406 };
3407
3408 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3409 t_BSLMF_RETURN,
3410 t_TYPE,
3411 t_ARGS_01,
3412 t_ARGS_02,
3413 t_ARGS_03,
3414 t_ARGS_04,
3415 t_ARGS_05,
3416 t_ARGS_06,
3417 t_ARGS_07,
3418 t_ARGS_08,
3419 t_ARGS_09,
3420 t_ARGS_10,
3421 t_ARGS_11>::Type
3422 ClassType;
3423 typedef t_BSLMF_RETURN ResultType;
3424 typedef typename TypeList<t_ARGS_01,
3425 t_ARGS_02,
3426 t_ARGS_03,
3427 t_ARGS_04,
3428 t_ARGS_05,
3429 t_ARGS_06,
3430 t_ARGS_07,
3431 t_ARGS_08,
3432 t_ARGS_09,
3433 t_ARGS_10,
3434 t_ARGS_11>::Type ArgumentList;
3435};
3436#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
3437
3438#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
3439template <class t_PROTOTYPE,
3440 class t_BSLMF_RETURN,
3441 class t_TYPE,
3442 class t_ARGS_01,
3443 class t_ARGS_02,
3444 class t_ARGS_03,
3445 class t_ARGS_04,
3446 class t_ARGS_05,
3447 class t_ARGS_06,
3448 class t_ARGS_07,
3449 class t_ARGS_08,
3450 class t_ARGS_09,
3451 class t_ARGS_10,
3452 class t_ARGS_11,
3453 class t_ARGS_12>
3454struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3455 t_BSLMF_RETURN (t_TYPE::*)(
3456 t_ARGS_01,
3457 t_ARGS_02,
3458 t_ARGS_03,
3459 t_ARGS_04,
3460 t_ARGS_05,
3461 t_ARGS_06,
3462 t_ARGS_07,
3463 t_ARGS_08,
3464 t_ARGS_09,
3465 t_ARGS_10,
3466 t_ARGS_11,
3467 t_ARGS_12) volatile> {
3468 enum {
3469 IS_MEMBER_FUNCTION_PTR = 1,
3470 IS_LVALREF_QUALIFIED = 0,
3471 IS_RVALREF_QUALIFIED = 0,
3472 IS_NOEXCEPT = 0
3473 };
3474
3475 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3476 t_BSLMF_RETURN,
3477 t_TYPE,
3478 t_ARGS_01,
3479 t_ARGS_02,
3480 t_ARGS_03,
3481 t_ARGS_04,
3482 t_ARGS_05,
3483 t_ARGS_06,
3484 t_ARGS_07,
3485 t_ARGS_08,
3486 t_ARGS_09,
3487 t_ARGS_10,
3488 t_ARGS_11,
3489 t_ARGS_12>::Type
3490 ClassType;
3491 typedef t_BSLMF_RETURN ResultType;
3492 typedef typename TypeList<t_ARGS_01,
3493 t_ARGS_02,
3494 t_ARGS_03,
3495 t_ARGS_04,
3496 t_ARGS_05,
3497 t_ARGS_06,
3498 t_ARGS_07,
3499 t_ARGS_08,
3500 t_ARGS_09,
3501 t_ARGS_10,
3502 t_ARGS_11,
3503 t_ARGS_12>::Type ArgumentList;
3504};
3505#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
3506
3507#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
3508template <class t_PROTOTYPE,
3509 class t_BSLMF_RETURN,
3510 class t_TYPE,
3511 class t_ARGS_01,
3512 class t_ARGS_02,
3513 class t_ARGS_03,
3514 class t_ARGS_04,
3515 class t_ARGS_05,
3516 class t_ARGS_06,
3517 class t_ARGS_07,
3518 class t_ARGS_08,
3519 class t_ARGS_09,
3520 class t_ARGS_10,
3521 class t_ARGS_11,
3522 class t_ARGS_12,
3523 class t_ARGS_13>
3524struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3525 t_BSLMF_RETURN (t_TYPE::*)(
3526 t_ARGS_01,
3527 t_ARGS_02,
3528 t_ARGS_03,
3529 t_ARGS_04,
3530 t_ARGS_05,
3531 t_ARGS_06,
3532 t_ARGS_07,
3533 t_ARGS_08,
3534 t_ARGS_09,
3535 t_ARGS_10,
3536 t_ARGS_11,
3537 t_ARGS_12,
3538 t_ARGS_13) volatile> {
3539 enum {
3540 IS_MEMBER_FUNCTION_PTR = 1,
3541 IS_LVALREF_QUALIFIED = 0,
3542 IS_RVALREF_QUALIFIED = 0,
3543 IS_NOEXCEPT = 0
3544 };
3545
3546 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3547 t_BSLMF_RETURN,
3548 t_TYPE,
3549 t_ARGS_01,
3550 t_ARGS_02,
3551 t_ARGS_03,
3552 t_ARGS_04,
3553 t_ARGS_05,
3554 t_ARGS_06,
3555 t_ARGS_07,
3556 t_ARGS_08,
3557 t_ARGS_09,
3558 t_ARGS_10,
3559 t_ARGS_11,
3560 t_ARGS_12,
3561 t_ARGS_13>::Type
3562 ClassType;
3563 typedef t_BSLMF_RETURN ResultType;
3564 typedef typename TypeList<t_ARGS_01,
3565 t_ARGS_02,
3566 t_ARGS_03,
3567 t_ARGS_04,
3568 t_ARGS_05,
3569 t_ARGS_06,
3570 t_ARGS_07,
3571 t_ARGS_08,
3572 t_ARGS_09,
3573 t_ARGS_10,
3574 t_ARGS_11,
3575 t_ARGS_12,
3576 t_ARGS_13>::Type ArgumentList;
3577};
3578#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
3579
3580#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
3581template <class t_PROTOTYPE,
3582 class t_BSLMF_RETURN,
3583 class t_TYPE,
3584 class t_ARGS_01,
3585 class t_ARGS_02,
3586 class t_ARGS_03,
3587 class t_ARGS_04,
3588 class t_ARGS_05,
3589 class t_ARGS_06,
3590 class t_ARGS_07,
3591 class t_ARGS_08,
3592 class t_ARGS_09,
3593 class t_ARGS_10,
3594 class t_ARGS_11,
3595 class t_ARGS_12,
3596 class t_ARGS_13,
3597 class t_ARGS_14>
3598struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3599 t_BSLMF_RETURN (t_TYPE::*)(
3600 t_ARGS_01,
3601 t_ARGS_02,
3602 t_ARGS_03,
3603 t_ARGS_04,
3604 t_ARGS_05,
3605 t_ARGS_06,
3606 t_ARGS_07,
3607 t_ARGS_08,
3608 t_ARGS_09,
3609 t_ARGS_10,
3610 t_ARGS_11,
3611 t_ARGS_12,
3612 t_ARGS_13,
3613 t_ARGS_14) volatile> {
3614 enum {
3615 IS_MEMBER_FUNCTION_PTR = 1,
3616 IS_LVALREF_QUALIFIED = 0,
3617 IS_RVALREF_QUALIFIED = 0,
3618 IS_NOEXCEPT = 0
3619 };
3620
3621 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3622 t_BSLMF_RETURN,
3623 t_TYPE,
3624 t_ARGS_01,
3625 t_ARGS_02,
3626 t_ARGS_03,
3627 t_ARGS_04,
3628 t_ARGS_05,
3629 t_ARGS_06,
3630 t_ARGS_07,
3631 t_ARGS_08,
3632 t_ARGS_09,
3633 t_ARGS_10,
3634 t_ARGS_11,
3635 t_ARGS_12,
3636 t_ARGS_13,
3637 t_ARGS_14>::Type
3638 ClassType;
3639 typedef t_BSLMF_RETURN ResultType;
3640 typedef typename TypeList<t_ARGS_01,
3641 t_ARGS_02,
3642 t_ARGS_03,
3643 t_ARGS_04,
3644 t_ARGS_05,
3645 t_ARGS_06,
3646 t_ARGS_07,
3647 t_ARGS_08,
3648 t_ARGS_09,
3649 t_ARGS_10,
3650 t_ARGS_11,
3651 t_ARGS_12,
3652 t_ARGS_13,
3653 t_ARGS_14>::Type ArgumentList;
3654};
3655#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
3656
3657#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
3658template <class t_PROTOTYPE, class t_BSLMF_RETURN, class t_TYPE>
3659struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3660 t_BSLMF_RETURN (t_TYPE::*)()
3661 const volatile> {
3662 enum {
3663 IS_MEMBER_FUNCTION_PTR = 1,
3664 IS_LVALREF_QUALIFIED = 0,
3665 IS_RVALREF_QUALIFIED = 0,
3666 IS_NOEXCEPT = 0
3667 };
3668 typedef
3669 typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3670 t_BSLMF_RETURN,
3671 t_TYPE>::Type ClassType;
3672 typedef t_BSLMF_RETURN ResultType;
3673 typedef typename TypeList<>::Type ArgumentList;
3674};
3675#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 0
3676
3677#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
3678template <class t_PROTOTYPE,
3679 class t_BSLMF_RETURN,
3680 class t_TYPE,
3681 class t_ARGS_01>
3682struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3683 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01)
3684 const volatile> {
3685 enum {
3686 IS_MEMBER_FUNCTION_PTR = 1,
3687 IS_LVALREF_QUALIFIED = 0,
3688 IS_RVALREF_QUALIFIED = 0,
3689 IS_NOEXCEPT = 0
3690 };
3691 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3692 t_BSLMF_RETURN,
3693 t_TYPE,
3694 t_ARGS_01>::Type
3695 ClassType;
3696 typedef t_BSLMF_RETURN ResultType;
3697 typedef typename TypeList<t_ARGS_01>::Type ArgumentList;
3698};
3699#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 1
3700
3701#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
3702template <class t_PROTOTYPE,
3703 class t_BSLMF_RETURN,
3704 class t_TYPE,
3705 class t_ARGS_01,
3706 class t_ARGS_02>
3707struct MemberFunctionPointerTraits_Imp<
3708 t_PROTOTYPE,
3709 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02) const volatile> {
3710 enum {
3711 IS_MEMBER_FUNCTION_PTR = 1,
3712 IS_LVALREF_QUALIFIED = 0,
3713 IS_RVALREF_QUALIFIED = 0,
3714 IS_NOEXCEPT = 0
3715 };
3716 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3717 t_BSLMF_RETURN,
3718 t_TYPE,
3719 t_ARGS_01,
3720 t_ARGS_02>::Type
3721 ClassType;
3722 typedef t_BSLMF_RETURN ResultType;
3723 typedef typename TypeList<t_ARGS_01,
3724 t_ARGS_02>::Type ArgumentList;
3725};
3726#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 2
3727
3728#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
3729template <class t_PROTOTYPE,
3730 class t_BSLMF_RETURN,
3731 class t_TYPE,
3732 class t_ARGS_01,
3733 class t_ARGS_02,
3734 class t_ARGS_03>
3735struct MemberFunctionPointerTraits_Imp<
3736 t_PROTOTYPE,
3737 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03)
3738 const volatile> {
3739 enum {
3740 IS_MEMBER_FUNCTION_PTR = 1,
3741 IS_LVALREF_QUALIFIED = 0,
3742 IS_RVALREF_QUALIFIED = 0,
3743 IS_NOEXCEPT = 0
3744 };
3745 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3746 t_BSLMF_RETURN,
3747 t_TYPE,
3748 t_ARGS_01,
3749 t_ARGS_02,
3750 t_ARGS_03>::Type
3751 ClassType;
3752 typedef t_BSLMF_RETURN ResultType;
3753 typedef typename TypeList<t_ARGS_01,
3754 t_ARGS_02,
3755 t_ARGS_03>::Type ArgumentList;
3756};
3757#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 3
3758
3759#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
3760template <class t_PROTOTYPE,
3761 class t_BSLMF_RETURN,
3762 class t_TYPE,
3763 class t_ARGS_01,
3764 class t_ARGS_02,
3765 class t_ARGS_03,
3766 class t_ARGS_04>
3767struct MemberFunctionPointerTraits_Imp<
3768 t_PROTOTYPE,
3769 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04)
3770 const volatile> {
3771 enum {
3772 IS_MEMBER_FUNCTION_PTR = 1,
3773 IS_LVALREF_QUALIFIED = 0,
3774 IS_RVALREF_QUALIFIED = 0,
3775 IS_NOEXCEPT = 0
3776 };
3777 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3778 t_BSLMF_RETURN,
3779 t_TYPE,
3780 t_ARGS_01,
3781 t_ARGS_02,
3782 t_ARGS_03,
3783 t_ARGS_04>::Type
3784 ClassType;
3785 typedef t_BSLMF_RETURN ResultType;
3786 typedef typename TypeList<t_ARGS_01,
3787 t_ARGS_02,
3788 t_ARGS_03,
3789 t_ARGS_04>::Type ArgumentList;
3790};
3791#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 4
3792
3793#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
3794template <class t_PROTOTYPE,
3795 class t_BSLMF_RETURN,
3796 class t_TYPE,
3797 class t_ARGS_01,
3798 class t_ARGS_02,
3799 class t_ARGS_03,
3800 class t_ARGS_04,
3801 class t_ARGS_05>
3802struct MemberFunctionPointerTraits_Imp<
3803 t_PROTOTYPE,
3804 t_BSLMF_RETURN (
3805 t_TYPE::*)(t_ARGS_01, t_ARGS_02, t_ARGS_03, t_ARGS_04, t_ARGS_05)
3806 const volatile> {
3807 enum {
3808 IS_MEMBER_FUNCTION_PTR = 1,
3809 IS_LVALREF_QUALIFIED = 0,
3810 IS_RVALREF_QUALIFIED = 0,
3811 IS_NOEXCEPT = 0
3812 };
3813 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3814 t_BSLMF_RETURN,
3815 t_TYPE,
3816 t_ARGS_01,
3817 t_ARGS_02,
3818 t_ARGS_03,
3819 t_ARGS_04,
3820 t_ARGS_05>::Type
3821 ClassType;
3822 typedef t_BSLMF_RETURN ResultType;
3823 typedef typename TypeList<t_ARGS_01,
3824 t_ARGS_02,
3825 t_ARGS_03,
3826 t_ARGS_04,
3827 t_ARGS_05>::Type ArgumentList;
3828};
3829#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 5
3830
3831#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
3832template <class t_PROTOTYPE,
3833 class t_BSLMF_RETURN,
3834 class t_TYPE,
3835 class t_ARGS_01,
3836 class t_ARGS_02,
3837 class t_ARGS_03,
3838 class t_ARGS_04,
3839 class t_ARGS_05,
3840 class t_ARGS_06>
3841struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3842 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
3843 t_ARGS_02,
3844 t_ARGS_03,
3845 t_ARGS_04,
3846 t_ARGS_05,
3847 t_ARGS_06)
3848 const volatile> {
3849 enum {
3850 IS_MEMBER_FUNCTION_PTR = 1,
3851 IS_LVALREF_QUALIFIED = 0,
3852 IS_RVALREF_QUALIFIED = 0,
3853 IS_NOEXCEPT = 0
3854 };
3855 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3856 t_BSLMF_RETURN,
3857 t_TYPE,
3858 t_ARGS_01,
3859 t_ARGS_02,
3860 t_ARGS_03,
3861 t_ARGS_04,
3862 t_ARGS_05,
3863 t_ARGS_06>::Type
3864 ClassType;
3865 typedef t_BSLMF_RETURN ResultType;
3866 typedef typename TypeList<t_ARGS_01,
3867 t_ARGS_02,
3868 t_ARGS_03,
3869 t_ARGS_04,
3870 t_ARGS_05,
3871 t_ARGS_06>::Type ArgumentList;
3872};
3873#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 6
3874
3875#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
3876template <class t_PROTOTYPE,
3877 class t_BSLMF_RETURN,
3878 class t_TYPE,
3879 class t_ARGS_01,
3880 class t_ARGS_02,
3881 class t_ARGS_03,
3882 class t_ARGS_04,
3883 class t_ARGS_05,
3884 class t_ARGS_06,
3885 class t_ARGS_07>
3886struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3887 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
3888 t_ARGS_02,
3889 t_ARGS_03,
3890 t_ARGS_04,
3891 t_ARGS_05,
3892 t_ARGS_06,
3893 t_ARGS_07)
3894 const volatile> {
3895 enum {
3896 IS_MEMBER_FUNCTION_PTR = 1,
3897 IS_LVALREF_QUALIFIED = 0,
3898 IS_RVALREF_QUALIFIED = 0,
3899 IS_NOEXCEPT = 0
3900 };
3901 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3902 t_BSLMF_RETURN,
3903 t_TYPE,
3904 t_ARGS_01,
3905 t_ARGS_02,
3906 t_ARGS_03,
3907 t_ARGS_04,
3908 t_ARGS_05,
3909 t_ARGS_06,
3910 t_ARGS_07>::Type
3911 ClassType;
3912 typedef t_BSLMF_RETURN ResultType;
3913 typedef typename TypeList<t_ARGS_01,
3914 t_ARGS_02,
3915 t_ARGS_03,
3916 t_ARGS_04,
3917 t_ARGS_05,
3918 t_ARGS_06,
3919 t_ARGS_07>::Type ArgumentList;
3920};
3921#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 7
3922
3923#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
3924template <class t_PROTOTYPE,
3925 class t_BSLMF_RETURN,
3926 class t_TYPE,
3927 class t_ARGS_01,
3928 class t_ARGS_02,
3929 class t_ARGS_03,
3930 class t_ARGS_04,
3931 class t_ARGS_05,
3932 class t_ARGS_06,
3933 class t_ARGS_07,
3934 class t_ARGS_08>
3935struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3936 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
3937 t_ARGS_02,
3938 t_ARGS_03,
3939 t_ARGS_04,
3940 t_ARGS_05,
3941 t_ARGS_06,
3942 t_ARGS_07,
3943 t_ARGS_08)
3944 const volatile> {
3945 enum {
3946 IS_MEMBER_FUNCTION_PTR = 1,
3947 IS_LVALREF_QUALIFIED = 0,
3948 IS_RVALREF_QUALIFIED = 0,
3949 IS_NOEXCEPT = 0
3950 };
3951 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
3952 t_BSLMF_RETURN,
3953 t_TYPE,
3954 t_ARGS_01,
3955 t_ARGS_02,
3956 t_ARGS_03,
3957 t_ARGS_04,
3958 t_ARGS_05,
3959 t_ARGS_06,
3960 t_ARGS_07,
3961 t_ARGS_08>::Type
3962 ClassType;
3963 typedef t_BSLMF_RETURN ResultType;
3964 typedef typename TypeList<t_ARGS_01,
3965 t_ARGS_02,
3966 t_ARGS_03,
3967 t_ARGS_04,
3968 t_ARGS_05,
3969 t_ARGS_06,
3970 t_ARGS_07,
3971 t_ARGS_08>::Type ArgumentList;
3972};
3973#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 8
3974
3975#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
3976template <class t_PROTOTYPE,
3977 class t_BSLMF_RETURN,
3978 class t_TYPE,
3979 class t_ARGS_01,
3980 class t_ARGS_02,
3981 class t_ARGS_03,
3982 class t_ARGS_04,
3983 class t_ARGS_05,
3984 class t_ARGS_06,
3985 class t_ARGS_07,
3986 class t_ARGS_08,
3987 class t_ARGS_09>
3988struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
3989 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
3990 t_ARGS_02,
3991 t_ARGS_03,
3992 t_ARGS_04,
3993 t_ARGS_05,
3994 t_ARGS_06,
3995 t_ARGS_07,
3996 t_ARGS_08,
3997 t_ARGS_09)
3998 const volatile> {
3999 enum {
4000 IS_MEMBER_FUNCTION_PTR = 1,
4001 IS_LVALREF_QUALIFIED = 0,
4002 IS_RVALREF_QUALIFIED = 0,
4003 IS_NOEXCEPT = 0
4004 };
4005 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4006 t_BSLMF_RETURN,
4007 t_TYPE,
4008 t_ARGS_01,
4009 t_ARGS_02,
4010 t_ARGS_03,
4011 t_ARGS_04,
4012 t_ARGS_05,
4013 t_ARGS_06,
4014 t_ARGS_07,
4015 t_ARGS_08,
4016 t_ARGS_09>::Type
4017 ClassType;
4018 typedef t_BSLMF_RETURN ResultType;
4019 typedef typename TypeList<t_ARGS_01,
4020 t_ARGS_02,
4021 t_ARGS_03,
4022 t_ARGS_04,
4023 t_ARGS_05,
4024 t_ARGS_06,
4025 t_ARGS_07,
4026 t_ARGS_08,
4027 t_ARGS_09>::Type ArgumentList;
4028};
4029#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 9
4030
4031#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
4032template <class t_PROTOTYPE,
4033 class t_BSLMF_RETURN,
4034 class t_TYPE,
4035 class t_ARGS_01,
4036 class t_ARGS_02,
4037 class t_ARGS_03,
4038 class t_ARGS_04,
4039 class t_ARGS_05,
4040 class t_ARGS_06,
4041 class t_ARGS_07,
4042 class t_ARGS_08,
4043 class t_ARGS_09,
4044 class t_ARGS_10>
4045struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4046 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4047 t_ARGS_02,
4048 t_ARGS_03,
4049 t_ARGS_04,
4050 t_ARGS_05,
4051 t_ARGS_06,
4052 t_ARGS_07,
4053 t_ARGS_08,
4054 t_ARGS_09,
4055 t_ARGS_10)
4056 const volatile> {
4057 enum {
4058 IS_MEMBER_FUNCTION_PTR = 1,
4059 IS_LVALREF_QUALIFIED = 0,
4060 IS_RVALREF_QUALIFIED = 0,
4061 IS_NOEXCEPT = 0
4062 };
4063 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4064 t_BSLMF_RETURN,
4065 t_TYPE,
4066 t_ARGS_01,
4067 t_ARGS_02,
4068 t_ARGS_03,
4069 t_ARGS_04,
4070 t_ARGS_05,
4071 t_ARGS_06,
4072 t_ARGS_07,
4073 t_ARGS_08,
4074 t_ARGS_09,
4075 t_ARGS_10>::Type
4076 ClassType;
4077 typedef t_BSLMF_RETURN ResultType;
4078 typedef typename TypeList<t_ARGS_01,
4079 t_ARGS_02,
4080 t_ARGS_03,
4081 t_ARGS_04,
4082 t_ARGS_05,
4083 t_ARGS_06,
4084 t_ARGS_07,
4085 t_ARGS_08,
4086 t_ARGS_09,
4087 t_ARGS_10>::Type ArgumentList;
4088};
4089#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 10
4090
4091#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
4092template <class t_PROTOTYPE,
4093 class t_BSLMF_RETURN,
4094 class t_TYPE,
4095 class t_ARGS_01,
4096 class t_ARGS_02,
4097 class t_ARGS_03,
4098 class t_ARGS_04,
4099 class t_ARGS_05,
4100 class t_ARGS_06,
4101 class t_ARGS_07,
4102 class t_ARGS_08,
4103 class t_ARGS_09,
4104 class t_ARGS_10,
4105 class t_ARGS_11>
4106struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4107 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4108 t_ARGS_02,
4109 t_ARGS_03,
4110 t_ARGS_04,
4111 t_ARGS_05,
4112 t_ARGS_06,
4113 t_ARGS_07,
4114 t_ARGS_08,
4115 t_ARGS_09,
4116 t_ARGS_10,
4117 t_ARGS_11)
4118 const volatile> {
4119 enum {
4120 IS_MEMBER_FUNCTION_PTR = 1,
4121 IS_LVALREF_QUALIFIED = 0,
4122 IS_RVALREF_QUALIFIED = 0,
4123 IS_NOEXCEPT = 0
4124 };
4125 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4126 t_BSLMF_RETURN,
4127 t_TYPE,
4128 t_ARGS_01,
4129 t_ARGS_02,
4130 t_ARGS_03,
4131 t_ARGS_04,
4132 t_ARGS_05,
4133 t_ARGS_06,
4134 t_ARGS_07,
4135 t_ARGS_08,
4136 t_ARGS_09,
4137 t_ARGS_10,
4138 t_ARGS_11>::Type
4139 ClassType;
4140 typedef t_BSLMF_RETURN ResultType;
4141 typedef typename TypeList<t_ARGS_01,
4142 t_ARGS_02,
4143 t_ARGS_03,
4144 t_ARGS_04,
4145 t_ARGS_05,
4146 t_ARGS_06,
4147 t_ARGS_07,
4148 t_ARGS_08,
4149 t_ARGS_09,
4150 t_ARGS_10,
4151 t_ARGS_11>::Type ArgumentList;
4152};
4153#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 11
4154
4155#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
4156template <class t_PROTOTYPE,
4157 class t_BSLMF_RETURN,
4158 class t_TYPE,
4159 class t_ARGS_01,
4160 class t_ARGS_02,
4161 class t_ARGS_03,
4162 class t_ARGS_04,
4163 class t_ARGS_05,
4164 class t_ARGS_06,
4165 class t_ARGS_07,
4166 class t_ARGS_08,
4167 class t_ARGS_09,
4168 class t_ARGS_10,
4169 class t_ARGS_11,
4170 class t_ARGS_12>
4171struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4172 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4173 t_ARGS_02,
4174 t_ARGS_03,
4175 t_ARGS_04,
4176 t_ARGS_05,
4177 t_ARGS_06,
4178 t_ARGS_07,
4179 t_ARGS_08,
4180 t_ARGS_09,
4181 t_ARGS_10,
4182 t_ARGS_11,
4183 t_ARGS_12)
4184 const volatile> {
4185 enum {
4186 IS_MEMBER_FUNCTION_PTR = 1,
4187 IS_LVALREF_QUALIFIED = 0,
4188 IS_RVALREF_QUALIFIED = 0,
4189 IS_NOEXCEPT = 0
4190 };
4191 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4192 t_BSLMF_RETURN,
4193 t_TYPE,
4194 t_ARGS_01,
4195 t_ARGS_02,
4196 t_ARGS_03,
4197 t_ARGS_04,
4198 t_ARGS_05,
4199 t_ARGS_06,
4200 t_ARGS_07,
4201 t_ARGS_08,
4202 t_ARGS_09,
4203 t_ARGS_10,
4204 t_ARGS_11,
4205 t_ARGS_12>::Type
4206 ClassType;
4207 typedef t_BSLMF_RETURN ResultType;
4208 typedef typename TypeList<t_ARGS_01,
4209 t_ARGS_02,
4210 t_ARGS_03,
4211 t_ARGS_04,
4212 t_ARGS_05,
4213 t_ARGS_06,
4214 t_ARGS_07,
4215 t_ARGS_08,
4216 t_ARGS_09,
4217 t_ARGS_10,
4218 t_ARGS_11,
4219 t_ARGS_12>::Type ArgumentList;
4220};
4221#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 12
4222
4223#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
4224template <class t_PROTOTYPE,
4225 class t_BSLMF_RETURN,
4226 class t_TYPE,
4227 class t_ARGS_01,
4228 class t_ARGS_02,
4229 class t_ARGS_03,
4230 class t_ARGS_04,
4231 class t_ARGS_05,
4232 class t_ARGS_06,
4233 class t_ARGS_07,
4234 class t_ARGS_08,
4235 class t_ARGS_09,
4236 class t_ARGS_10,
4237 class t_ARGS_11,
4238 class t_ARGS_12,
4239 class t_ARGS_13>
4240struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4241 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4242 t_ARGS_02,
4243 t_ARGS_03,
4244 t_ARGS_04,
4245 t_ARGS_05,
4246 t_ARGS_06,
4247 t_ARGS_07,
4248 t_ARGS_08,
4249 t_ARGS_09,
4250 t_ARGS_10,
4251 t_ARGS_11,
4252 t_ARGS_12,
4253 t_ARGS_13)
4254 const volatile> {
4255 enum {
4256 IS_MEMBER_FUNCTION_PTR = 1,
4257 IS_LVALREF_QUALIFIED = 0,
4258 IS_RVALREF_QUALIFIED = 0,
4259 IS_NOEXCEPT = 0
4260 };
4261 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4262 t_BSLMF_RETURN,
4263 t_TYPE,
4264 t_ARGS_01,
4265 t_ARGS_02,
4266 t_ARGS_03,
4267 t_ARGS_04,
4268 t_ARGS_05,
4269 t_ARGS_06,
4270 t_ARGS_07,
4271 t_ARGS_08,
4272 t_ARGS_09,
4273 t_ARGS_10,
4274 t_ARGS_11,
4275 t_ARGS_12,
4276 t_ARGS_13>::Type
4277 ClassType;
4278 typedef t_BSLMF_RETURN ResultType;
4279 typedef typename TypeList<t_ARGS_01,
4280 t_ARGS_02,
4281 t_ARGS_03,
4282 t_ARGS_04,
4283 t_ARGS_05,
4284 t_ARGS_06,
4285 t_ARGS_07,
4286 t_ARGS_08,
4287 t_ARGS_09,
4288 t_ARGS_10,
4289 t_ARGS_11,
4290 t_ARGS_12,
4291 t_ARGS_13>::Type ArgumentList;
4292};
4293#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 13
4294
4295#if BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
4296template <class t_PROTOTYPE,
4297 class t_BSLMF_RETURN,
4298 class t_TYPE,
4299 class t_ARGS_01,
4300 class t_ARGS_02,
4301 class t_ARGS_03,
4302 class t_ARGS_04,
4303 class t_ARGS_05,
4304 class t_ARGS_06,
4305 class t_ARGS_07,
4306 class t_ARGS_08,
4307 class t_ARGS_09,
4308 class t_ARGS_10,
4309 class t_ARGS_11,
4310 class t_ARGS_12,
4311 class t_ARGS_13,
4312 class t_ARGS_14>
4313struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4314 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS_01,
4315 t_ARGS_02,
4316 t_ARGS_03,
4317 t_ARGS_04,
4318 t_ARGS_05,
4319 t_ARGS_06,
4320 t_ARGS_07,
4321 t_ARGS_08,
4322 t_ARGS_09,
4323 t_ARGS_10,
4324 t_ARGS_11,
4325 t_ARGS_12,
4326 t_ARGS_13,
4327 t_ARGS_14)
4328 const volatile> {
4329 enum {
4330 IS_MEMBER_FUNCTION_PTR = 1,
4331 IS_LVALREF_QUALIFIED = 0,
4332 IS_RVALREF_QUALIFIED = 0,
4333 IS_NOEXCEPT = 0
4334 };
4335 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4336 t_BSLMF_RETURN,
4337 t_TYPE,
4338 t_ARGS_01,
4339 t_ARGS_02,
4340 t_ARGS_03,
4341 t_ARGS_04,
4342 t_ARGS_05,
4343 t_ARGS_06,
4344 t_ARGS_07,
4345 t_ARGS_08,
4346 t_ARGS_09,
4347 t_ARGS_10,
4348 t_ARGS_11,
4349 t_ARGS_12,
4350 t_ARGS_13,
4351 t_ARGS_14>::Type
4352 ClassType;
4353 typedef t_BSLMF_RETURN ResultType;
4354 typedef typename TypeList<t_ARGS_01,
4355 t_ARGS_02,
4356 t_ARGS_03,
4357 t_ARGS_04,
4358 t_ARGS_05,
4359 t_ARGS_06,
4360 t_ARGS_07,
4361 t_ARGS_08,
4362 t_ARGS_09,
4363 t_ARGS_10,
4364 t_ARGS_11,
4365 t_ARGS_12,
4366 t_ARGS_13,
4367 t_ARGS_14>::Type ArgumentList;
4368};
4369#endif // BSLMF_MEMBERFUNCTIONPOINTERTRAITS_VARIADIC_LIMIT_B >= 14
4370
4371#else // BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
4372// The generated code below is a workaround for the absence of perfect
4373// forwarding in some compilers.
4374template <class t_PROTOTYPE,
4375 class t_BSLMF_RETURN,
4376 class t_TYPE,
4377 class... t_ARGS>
4378struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4379 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)> {
4380 enum {
4381 IS_MEMBER_FUNCTION_PTR = 1,
4382 IS_LVALREF_QUALIFIED = 0,
4383 IS_RVALREF_QUALIFIED = 0,
4384 IS_NOEXCEPT = 0
4385 };
4386 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4387 t_BSLMF_RETURN,
4388 t_TYPE,
4389 t_ARGS...>::Type
4390 ClassType;
4391 typedef t_BSLMF_RETURN ResultType;
4392 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4393};
4394
4395template <class t_PROTOTYPE,
4396 class t_BSLMF_RETURN,
4397 class t_TYPE,
4398 class... t_ARGS>
4399struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4400 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4401 const> {
4402 enum {
4403 IS_MEMBER_FUNCTION_PTR = 1,
4404 IS_LVALREF_QUALIFIED = 0,
4405 IS_RVALREF_QUALIFIED = 0,
4406 IS_NOEXCEPT = 0
4407 };
4408 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4409 t_BSLMF_RETURN,
4410 t_TYPE,
4411 t_ARGS...>::Type
4412 ClassType;
4413 typedef t_BSLMF_RETURN ResultType;
4414 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4415};
4416
4417template <class t_PROTOTYPE,
4418 class t_BSLMF_RETURN,
4419 class t_TYPE,
4420 class... t_ARGS>
4421struct MemberFunctionPointerTraits_Imp<
4422 t_PROTOTYPE,
4423 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile> {
4424 enum {
4425 IS_MEMBER_FUNCTION_PTR = 1,
4426 IS_LVALREF_QUALIFIED = 0,
4427 IS_RVALREF_QUALIFIED = 0,
4428 IS_NOEXCEPT = 0
4429 };
4430
4431 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4432 t_BSLMF_RETURN,
4433 t_TYPE,
4434 t_ARGS...>::Type
4435 ClassType;
4436 typedef t_BSLMF_RETURN ResultType;
4437 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4438};
4439
4440template <class t_PROTOTYPE,
4441 class t_BSLMF_RETURN,
4442 class t_TYPE,
4443 class... t_ARGS>
4444struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4445 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4446 const volatile> {
4447 enum {
4448 IS_MEMBER_FUNCTION_PTR = 1,
4449 IS_LVALREF_QUALIFIED = 0,
4450 IS_RVALREF_QUALIFIED = 0,
4451 IS_NOEXCEPT = 0
4452 };
4453 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4454 t_BSLMF_RETURN,
4455 t_TYPE,
4456 t_ARGS...>::Type
4457 ClassType;
4458 typedef t_BSLMF_RETURN ResultType;
4459 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4460};
4461
4462// }}} END GENERATED CODE
4463#endif // BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
4464
4465#ifdef BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4466
4467/// Specialization to determine the traits of member functions. A modern
4468/// compiler will match only non-cv member functions, but some older
4469/// compilers might match this to any member function.
4470template <class t_PROTOTYPE,
4471 class t_BSLMF_RETURN,
4472 class t_TYPE,
4473 class... t_ARGS>
4474struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4475 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4476 noexcept> {
4477
4478 enum {
4479 IS_MEMBER_FUNCTION_PTR = 1,
4480 IS_LVALREF_QUALIFIED = 0,
4481 IS_RVALREF_QUALIFIED = 0,
4482 IS_NOEXCEPT = 1
4483 };
4484 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4485 t_BSLMF_RETURN,
4486 t_TYPE,
4487 t_ARGS...>::Type
4488 ClassType;
4489 typedef t_BSLMF_RETURN ResultType;
4490 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4491};
4492
4493/// Specialization to determine the traits of member functions. A modern
4494/// compiler will match only const member functions, but some older
4495/// compilers might match this to any member function.
4496template <class t_PROTOTYPE,
4497 class t_BSLMF_RETURN,
4498 class t_TYPE,
4499 class... t_ARGS>
4500struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4501 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4502 const noexcept> {
4503
4504 enum {
4505 IS_MEMBER_FUNCTION_PTR = 1,
4506 IS_LVALREF_QUALIFIED = 0,
4507 IS_RVALREF_QUALIFIED = 0,
4508 IS_NOEXCEPT = 1
4509 };
4510 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4511 t_BSLMF_RETURN,
4512 t_TYPE,
4513 t_ARGS...>::Type
4514 ClassType;
4515 typedef t_BSLMF_RETURN ResultType;
4516 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4517};
4518
4519/// Specialization to determine the traits of member functions. A modern
4520/// compiler will match only volatile member functions, but some older
4521/// compilers might match this to any member function.
4522template <class t_PROTOTYPE,
4523 class t_BSLMF_RETURN,
4524 class t_TYPE,
4525 class... t_ARGS>
4526struct MemberFunctionPointerTraits_Imp<
4527 t_PROTOTYPE,
4528 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile noexcept> {
4529
4530 enum {
4531 IS_MEMBER_FUNCTION_PTR = 1,
4532 IS_LVALREF_QUALIFIED = 0,
4533 IS_RVALREF_QUALIFIED = 0,
4534 IS_NOEXCEPT = 1
4535 };
4536
4537 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4538 t_BSLMF_RETURN,
4539 t_TYPE,
4540 t_ARGS...>::Type
4541 ClassType;
4542 typedef t_BSLMF_RETURN ResultType;
4543 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4544};
4545
4546/// Specialization to determine the traits of member functions. A modern
4547/// compiler will match only const volatile member functions, but some older
4548/// compilers might match this to any member function.
4549template <class t_PROTOTYPE,
4550 class t_BSLMF_RETURN,
4551 class t_TYPE,
4552 class... t_ARGS>
4553struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4554 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4555 const volatile noexcept> {
4556
4557 enum {
4558 IS_MEMBER_FUNCTION_PTR = 1,
4559 IS_LVALREF_QUALIFIED = 0,
4560 IS_RVALREF_QUALIFIED = 0,
4561 IS_NOEXCEPT = 1
4562 };
4563 typedef typename MemberFunctionPointerTraits_ClassType<t_PROTOTYPE,
4564 t_BSLMF_RETURN,
4565 t_TYPE,
4566 t_ARGS...>::Type
4567 ClassType;
4568 typedef t_BSLMF_RETURN ResultType;
4569 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4570};
4571#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4572
4573#ifdef BSLS_COMPILERFEATURES_SUPPORT_REF_QUALIFIERS
4574
4575/// Specialization to determine the traits of a pointer to lvalref-qualified
4576/// member function. The workarounds for older compilers are not needed
4577/// because only more modern compilers support ref-qualified member
4578/// functions.
4579template <class t_PROTOTYPE,
4580 class t_BSLMF_RETURN,
4581 class t_TYPE,
4582 class... t_ARGS>
4583struct MemberFunctionPointerTraits_Imp<
4584 t_PROTOTYPE,
4585 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)&> {
4586
4587 enum {
4588 IS_MEMBER_FUNCTION_PTR = 1,
4589 IS_LVALREF_QUALIFIED = 1,
4590 IS_RVALREF_QUALIFIED = 0,
4591 IS_NOEXCEPT = 0
4592 };
4593 typedef t_TYPE ClassType;
4594 typedef t_BSLMF_RETURN ResultType;
4595 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4596};
4597
4598/// Specialization to determine the traits of a pointer to const
4599/// lvalref-qualified member function. The workarounds for older compilers
4600/// are not needed because only more modern compilers support ref-qualified
4601/// member functions.
4602template <class t_PROTOTYPE,
4603 class t_BSLMF_RETURN,
4604 class t_TYPE,
4605 class... t_ARGS>
4606struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4607 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4608 const&> {
4609
4610 enum {
4611 IS_MEMBER_FUNCTION_PTR = 1,
4612 IS_LVALREF_QUALIFIED = 1,
4613 IS_RVALREF_QUALIFIED = 0,
4614 IS_NOEXCEPT = 0
4615 };
4616 typedef const t_TYPE ClassType;
4617 typedef t_BSLMF_RETURN ResultType;
4618 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4619};
4620
4621/// Specialization to determine the traits of a pointer to volatile
4622/// lvalref-qualified member function. The workarounds for older compilers
4623/// are not needed because only more modern compilers support ref-qualified
4624/// member functions.
4625template <class t_PROTOTYPE,
4626 class t_BSLMF_RETURN,
4627 class t_TYPE,
4628 class... t_ARGS>
4629struct MemberFunctionPointerTraits_Imp<
4630 t_PROTOTYPE,
4631 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile&> {
4632
4633 enum {
4634 IS_MEMBER_FUNCTION_PTR = 1,
4635 IS_LVALREF_QUALIFIED = 1,
4636 IS_RVALREF_QUALIFIED = 0,
4637 IS_NOEXCEPT = 0
4638 };
4639 typedef volatile t_TYPE ClassType;
4640 typedef t_BSLMF_RETURN ResultType;
4641 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4642};
4643
4644/// Specialization to determine the traits of a pointer to const volatile
4645/// lvalref-qualified member function. The workarounds for older compilers
4646/// are not needed because only more modern compilers support ref-qualified
4647/// member functions.
4648template <class t_PROTOTYPE,
4649 class t_BSLMF_RETURN,
4650 class t_TYPE,
4651 class... t_ARGS>
4652struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4653 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4654 const volatile&> {
4655
4656 enum {
4657 IS_MEMBER_FUNCTION_PTR = 1,
4658 IS_LVALREF_QUALIFIED = 1,
4659 IS_RVALREF_QUALIFIED = 0,
4660 IS_NOEXCEPT = 0
4661 };
4662 typedef const volatile t_TYPE ClassType;
4663 typedef t_BSLMF_RETURN ResultType;
4664 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4665};
4666
4667#ifdef BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4668
4669/// Specialization to determine the traits of a pointer to lvalref-qualified
4670/// member function. The workarounds for older compilers are not needed
4671/// because only more modern compilers support ref-qualified member
4672/// functions.
4673template <class t_PROTOTYPE,
4674 class t_BSLMF_RETURN,
4675 class t_TYPE,
4676 class... t_ARGS>
4677struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4678 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) &
4679 noexcept> {
4680
4681 enum {
4682 IS_MEMBER_FUNCTION_PTR = 1,
4683 IS_LVALREF_QUALIFIED = 1,
4684 IS_RVALREF_QUALIFIED = 0,
4685 IS_NOEXCEPT = 1
4686 };
4687 typedef t_TYPE ClassType;
4688 typedef t_BSLMF_RETURN ResultType;
4689 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4690};
4691
4692/// Specialization to determine the traits of a pointer to const
4693/// lvalref-qualified member function. The workarounds for older compilers
4694/// are not needed because only more modern compilers support ref-qualified
4695/// member functions.
4696template <class t_PROTOTYPE,
4697 class t_BSLMF_RETURN,
4698 class t_TYPE,
4699 class... t_ARGS>
4700struct MemberFunctionPointerTraits_Imp<
4701 t_PROTOTYPE,
4702 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const & noexcept> {
4703
4704 enum {
4705 IS_MEMBER_FUNCTION_PTR = 1,
4706 IS_LVALREF_QUALIFIED = 1,
4707 IS_RVALREF_QUALIFIED = 0,
4708 IS_NOEXCEPT = 1
4709 };
4710 typedef const t_TYPE ClassType;
4711 typedef t_BSLMF_RETURN ResultType;
4712 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4713};
4714
4715/// Specialization to determine the traits of a pointer to volatile
4716/// lvalref-qualified member function. The workarounds for older compilers
4717/// are not needed because only more modern compilers support ref-qualified
4718/// member functions.
4719template <class t_PROTOTYPE,
4720 class t_BSLMF_RETURN,
4721 class t_TYPE,
4722 class... t_ARGS>
4723struct MemberFunctionPointerTraits_Imp<
4724 t_PROTOTYPE,
4725 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile & noexcept> {
4726
4727 enum {
4728 IS_MEMBER_FUNCTION_PTR = 1,
4729 IS_LVALREF_QUALIFIED = 1,
4730 IS_RVALREF_QUALIFIED = 0,
4731 IS_NOEXCEPT = 1
4732 };
4733 typedef volatile t_TYPE ClassType;
4734 typedef t_BSLMF_RETURN ResultType;
4735 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4736};
4737
4738/// Specialization to determine the traits of a pointer to const volatile
4739/// lvalref-qualified member function. The workarounds for older compilers
4740/// are not needed because only more modern compilers support ref-qualified
4741/// member functions.
4742template <class t_PROTOTYPE,
4743 class t_BSLMF_RETURN,
4744 class t_TYPE,
4745 class... t_ARGS>
4746struct MemberFunctionPointerTraits_Imp<
4747 t_PROTOTYPE,
4748 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const volatile & noexcept> {
4749
4750 enum {
4751 IS_MEMBER_FUNCTION_PTR = 1,
4752 IS_LVALREF_QUALIFIED = 1,
4753 IS_RVALREF_QUALIFIED = 0,
4754 IS_NOEXCEPT = 1
4755 };
4756 typedef const volatile t_TYPE ClassType;
4757 typedef t_BSLMF_RETURN ResultType;
4758 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4759};
4760
4761#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4762
4763/// Specialization to determine the traits of a pointer to rvalref-qualified
4764/// member function. The workarounds for older compilers are not needed
4765/// because only more modern compilers support ref-qualified member
4766/// functions.
4767template <class t_PROTOTYPE,
4768 class t_BSLMF_RETURN,
4769 class t_TYPE,
4770 class... t_ARGS>
4771struct MemberFunctionPointerTraits_Imp<
4772 t_PROTOTYPE,
4773 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) &&> {
4774
4775 enum {
4776 IS_MEMBER_FUNCTION_PTR = 1,
4777 IS_LVALREF_QUALIFIED = 0,
4778 IS_RVALREF_QUALIFIED = 1,
4779 IS_NOEXCEPT = 0
4780 };
4781 typedef t_TYPE ClassType;
4782 typedef t_BSLMF_RETURN ResultType;
4783 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4784};
4785
4786/// Specialization to determine the traits of a pointer to const
4787/// rvalref-qualified member function. The workarounds for older compilers
4788/// are not needed because only more modern compilers support ref-qualified
4789/// member functions.
4790template <class t_PROTOTYPE,
4791 class t_BSLMF_RETURN,
4792 class t_TYPE,
4793 class... t_ARGS>
4794struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4795 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4796 const&&> {
4797
4798 enum {
4799 IS_MEMBER_FUNCTION_PTR = 1,
4800 IS_LVALREF_QUALIFIED = 0,
4801 IS_RVALREF_QUALIFIED = 1,
4802 IS_NOEXCEPT = 0
4803 };
4804 typedef const t_TYPE ClassType;
4805 typedef t_BSLMF_RETURN ResultType;
4806 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4807};
4808
4809/// Specialization to determine the traits of a pointer to volatile
4810/// rvalref-qualified member function. The workarounds for older compilers
4811/// are not needed because only more modern compilers support ref-qualified
4812/// member functions.
4813template <class t_PROTOTYPE,
4814 class t_BSLMF_RETURN,
4815 class t_TYPE,
4816 class... t_ARGS>
4817struct MemberFunctionPointerTraits_Imp<
4818 t_PROTOTYPE,
4819 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile&&> {
4820
4821 enum {
4822 IS_MEMBER_FUNCTION_PTR = 1,
4823 IS_LVALREF_QUALIFIED = 0,
4824 IS_RVALREF_QUALIFIED = 1,
4825 IS_NOEXCEPT = 0
4826 };
4827 typedef volatile t_TYPE ClassType;
4828 typedef t_BSLMF_RETURN ResultType;
4829 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4830};
4831
4832/// Specialization to determine the traits of a pointer to const volatile
4833/// rvalref-qualified member function. The workarounds for older compilers
4834/// are not needed because only more modern compilers support ref-qualified
4835/// member functions.
4836template <class t_PROTOTYPE,
4837 class t_BSLMF_RETURN,
4838 class t_TYPE,
4839 class... t_ARGS>
4840struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4841 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...)
4842 const volatile&&> {
4843
4844 enum {
4845 IS_MEMBER_FUNCTION_PTR = 1,
4846 IS_LVALREF_QUALIFIED = 0,
4847 IS_RVALREF_QUALIFIED = 1,
4848 IS_NOEXCEPT = 0
4849 };
4850 typedef const volatile t_TYPE ClassType;
4851 typedef t_BSLMF_RETURN ResultType;
4852 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4853};
4854
4855#ifdef BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4856
4857/// Specialization to determine the traits of a pointer to rvalref-qualified
4858/// member function. The workarounds for older compilers are not needed
4859/// because only more modern compilers support ref-qualified member
4860/// functions.
4861template <class t_PROTOTYPE,
4862 class t_BSLMF_RETURN,
4863 class t_TYPE,
4864 class... t_ARGS>
4865struct MemberFunctionPointerTraits_Imp<t_PROTOTYPE,
4866 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) &&
4867 noexcept> {
4868
4869 enum {
4870 IS_MEMBER_FUNCTION_PTR = 1,
4871 IS_LVALREF_QUALIFIED = 0,
4872 IS_RVALREF_QUALIFIED = 1,
4873 IS_NOEXCEPT = 1
4874 };
4875 typedef t_TYPE ClassType;
4876 typedef t_BSLMF_RETURN ResultType;
4877 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4878};
4879
4880/// Specialization to determine the traits of a pointer to const
4881/// rvalref-qualified member function. The workarounds for older compilers
4882/// are not needed because only more modern compilers support ref-qualified
4883/// member functions.
4884template <class t_PROTOTYPE,
4885 class t_BSLMF_RETURN,
4886 class t_TYPE,
4887 class... t_ARGS>
4888struct MemberFunctionPointerTraits_Imp<
4889 t_PROTOTYPE,
4890 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const && noexcept> {
4891
4892 enum {
4893 IS_MEMBER_FUNCTION_PTR = 1,
4894 IS_LVALREF_QUALIFIED = 0,
4895 IS_RVALREF_QUALIFIED = 1,
4896 IS_NOEXCEPT = 1
4897 };
4898 typedef const t_TYPE ClassType;
4899 typedef t_BSLMF_RETURN ResultType;
4900 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4901};
4902
4903/// Specialization to determine the traits of a pointer to volatile
4904/// rvalref-qualified member function. The workarounds for older compilers
4905/// are not needed because only more modern compilers support ref-qualified
4906/// member functions.
4907template <class t_PROTOTYPE,
4908 class t_BSLMF_RETURN,
4909 class t_TYPE,
4910 class... t_ARGS>
4911struct MemberFunctionPointerTraits_Imp<
4912 t_PROTOTYPE,
4913 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) volatile && noexcept> {
4914
4915 enum {
4916 IS_MEMBER_FUNCTION_PTR = 1,
4917 IS_LVALREF_QUALIFIED = 0,
4918 IS_RVALREF_QUALIFIED = 1,
4919 IS_NOEXCEPT = 1
4920 };
4921 typedef volatile t_TYPE ClassType;
4922 typedef t_BSLMF_RETURN ResultType;
4923 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4924};
4925
4926/// Specialization to determine the traits of a pointer to const volatile
4927/// rvalref-qualified member function. The workarounds for older compilers
4928/// are not needed because only more modern compilers support ref-qualified
4929/// member functions.
4930template <class t_PROTOTYPE,
4931 class t_BSLMF_RETURN,
4932 class t_TYPE,
4933 class... t_ARGS>
4934struct MemberFunctionPointerTraits_Imp<
4935 t_PROTOTYPE,
4936 t_BSLMF_RETURN (t_TYPE::*)(t_ARGS...) const volatile && noexcept> {
4937
4938 enum {
4939 IS_MEMBER_FUNCTION_PTR = 1,
4940 IS_LVALREF_QUALIFIED = 0,
4941 IS_RVALREF_QUALIFIED = 1,
4942 IS_NOEXCEPT = 1
4943 };
4944 typedef const volatile t_TYPE ClassType;
4945 typedef t_BSLMF_RETURN ResultType;
4946 typedef typename TypeList<t_ARGS...>::Type ArgumentList;
4947};
4948#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
4949
4950#endif // BSLS_COMPILERFEATURES_SUPPORT_REF_QUALIFIERS
4951
4952} // close package namespace
4953
4954#ifndef BDE_OPENSOURCE_PUBLICATION // BACKWARD_COMPATIBILITY
4955// ============================================================================
4956// BACKWARD COMPATIBILITY
4957// ============================================================================
4958
4959#ifdef bslmf_MemberFunctionPointerTraits
4960#undef bslmf_MemberFunctionPointerTraits
4961#endif
4962/// This alias is defined for backward compatibility.
4963#define bslmf_MemberFunctionPointerTraits bslmf::MemberFunctionPointerTraits
4964
4965#ifdef bslmf_IsMemberFunctionPointer
4966#undef bslmf_IsMemberFunctionPointer
4967#endif
4968/// This alias is defined for backward compatibility.
4969#define bslmf_IsMemberFunctionPointer bslmf::IsMemberFunctionPointer
4970
4971#ifdef bslmf_MemberFunctionPointerTraitsImp
4972#undef bslmf_MemberFunctionPointerTraitsImp
4973#endif
4974/// This alias is defined for backward compatibility.
4975#define bslmf_MemberFunctionPointerTraitsImp \
4976 bslmf::MemberFunctionPointerTraits_Imp
4977#endif // BDE_OPENSOURCE_PUBLICATION -- BACKWARD_COMPATIBILITY
4978
4979
4980
4981#endif
4982
4983// ----------------------------------------------------------------------------
4984// Copyright 2013-2019 Bloomberg Finance L.P.
4985//
4986// Licensed under the Apache License, Version 2.0 (the "License");
4987// you may not use this file except in compliance with the License.
4988// You may obtain a copy of the License at
4989//
4990// http://www.apache.org/licenses/LICENSE-2.0
4991//
4992// Unless required by applicable law or agreed to in writing, software
4993// distributed under the License is distributed on an "AS IS" BASIS,
4994// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4995// See the License for the specific language governing permissions and
4996// limitations under the License.
4997// ----------------------------- END-OF-FILE ----------------------------------
4998
4999/** @} */
5000/** @} */
5001/** @} */
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:172
BSLS_IDENT
#define BSLS_IDENT(str)
Definition bsls_ident.h:195
bslmf
Definition bdlbb_blob.h:576
bsl::integral_constant
Definition bslmf_integralconstant.h:244
bslmf::If::Type
bsl::conditional< t_CONDITION, t_IF_TRUE_TYPE, t_IF_FALSE_TYPE >::type Type
Definition bslmf_if.h:161
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:1447
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) const >::ArgumentList
TypeList< t_ARGS... >::Type ArgumentList
Definition bslmf_memberfunctionpointertraits.h:1448
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:1446
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:1473
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) volatile >::ResultType
t_BSLMF_RETURN ResultType
Definition bslmf_memberfunctionpointertraits.h:1474
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) volatile >::ArgumentList
TypeList< t_ARGS... >::Type ArgumentList
Definition bslmf_memberfunctionpointertraits.h:1475
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...)>::ResultType
t_BSLMF_RETURN ResultType
Definition bslmf_memberfunctionpointertraits.h:1421
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:1420
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...)>::ArgumentList
TypeList< t_ARGS... >::Type ArgumentList
Definition bslmf_memberfunctionpointertraits.h:1422
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) const volatile >::ResultType
t_BSLMF_RETURN ResultType
Definition bslmf_memberfunctionpointertraits.h:1500
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:1499
bslmf::MemberFunctionPointerTraits_Imp< t_PROTOTYPE, t_BSLMF_RETURN(t_TYPE::*)(t_ARGS...) const volatile >::ArgumentList
TypeList< t_ARGS... >::Type ArgumentList
Definition bslmf_memberfunctionpointertraits.h:1501
bslmf::MemberFunctionPointerTraits_Imp
Forward declaration.
Definition bslmf_memberfunctionpointertraits.h:1390
bslmf::MemberFunctionPointerTraits_Imp::IS_MEMBER_FUNCTION_PTR
@ IS_MEMBER_FUNCTION_PTR
Definition bslmf_memberfunctionpointertraits.h:1393
bslmf::MemberFunctionPointerTraits
Definition bslmf_memberfunctionpointertraits.h:150
bslmf::Tag
Definition bslmf_tag.h:163
bslmf::TypeList20::Type
ListType Type
Definition bslmf_typelist.h:2470
bslmf::TypeList
Definition bslmf_typelist.h:1609