00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00049 #ifndef STLSOFT_INCL_STLSOFT_FUNCTIONAL_HPP_METHOD_ADAPTORS
00050 #define STLSOFT_INCL_STLSOFT_FUNCTIONAL_HPP_METHOD_ADAPTORS
00051
00052 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00053 # define STLSOFT_VER_STLSOFT_FUNCTIONAL_HPP_METHOD_ADAPTORS_MAJOR 4
00054 # define STLSOFT_VER_STLSOFT_FUNCTIONAL_HPP_METHOD_ADAPTORS_MINOR 1
00055 # define STLSOFT_VER_STLSOFT_FUNCTIONAL_HPP_METHOD_ADAPTORS_REVISION 3
00056 # define STLSOFT_VER_STLSOFT_FUNCTIONAL_HPP_METHOD_ADAPTORS_EDIT 62
00057 #endif
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00074 # include <stlsoft/stlsoft.h>
00075 #endif
00076
00077 #if defined(STLSOFT_COMPILER_IS_GCC) && \
00078 ( __GNUC__ < 3 || \
00079 ( __GNUC__ == 3 && \
00080 __GNUC_MINOR__ < 3))
00081 # error This file is not compatible with GCC <3.3
00082 #endif
00083
00084 #ifndef STLSOFT_INCL_FUNCTIONAL
00085 # define STLSOFT_INCL_FUNCTIONAL
00086 # include <functional>
00087 #endif
00088
00089
00090
00091
00092
00093 #ifndef _STLSOFT_NO_NAMESPACE
00094 namespace stlsoft
00095 {
00096 #endif
00097
00098
00099
00100
00101
00102
00103 #ifdef STLSOFT_CF_THISCALL_SUPPORTED
00104
00109
00110 template< ss_typename_param_k R
00111 , ss_typename_param_k T
00112 >
00113 struct thiscall_mem_fun_t
00114 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00115 {
00116 public:
00117 typedef R return_type;
00118 typedef T operand_class_type;
00119 typedef return_type (T::*method_type)();
00120 public:
00121 ss_explicit_k thiscall_mem_fun_t(method_type func)
00122 : m_func(func)
00123 {}
00124 return_type operator ()(operand_class_type *pt) const
00125 {
00126 return (pt->*m_func)();
00127 }
00128 private:
00129 method_type m_func;
00130 };
00131
00137
00138 template< ss_typename_param_k R
00139 , ss_typename_param_k T
00140 >
00141 struct thiscall_mem_fun_const_t
00142 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00143 {
00144 public:
00145 typedef R return_type;
00146 typedef T operand_class_type;
00147 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00148 typedef return_type (T::*method_type)() const;
00149 # else
00150 typedef return_type (T::*method_type)() const;
00151 # endif
00152 public:
00153 ss_explicit_k thiscall_mem_fun_const_t(method_type func)
00154 : m_func(func)
00155 {}
00156 return_type operator ()(operand_class_type const* pt) const
00157 {
00158 return (pt->*m_func)();
00159 }
00160 private:
00161 method_type m_func;
00162 };
00163
00164 # ifndef STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID
00165
00166 template< ss_typename_param_k T
00167 >
00168 struct thiscall_mem_fun_void_t
00169 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00170 {
00171 public:
00172 typedef void return_type;
00173 typedef T operand_class_type;
00174 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00175 typedef return_type (T::*method_type)();
00176 # else
00177 typedef return_type (T::*method_type)();
00178 # endif
00179 public:
00180 ss_explicit_k thiscall_mem_fun_void_t(method_type func)
00181 : m_func(func)
00182 {}
00183 void operator ()(operand_class_type *pt) const
00184 {
00185 (pt->*m_func)();
00186 }
00187 private:
00188 method_type m_func;
00189 };
00190
00191 template< ss_typename_param_k T
00192 >
00193 struct thiscall_mem_fun_const_void_t
00194 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00195 {
00196 public:
00197 typedef void return_type;
00198 typedef T operand_class_type;
00199 typedef return_type (T::*method_type)() const;
00200 public:
00201 ss_explicit_k thiscall_mem_fun_const_void_t(method_type func)
00202 : m_func(func)
00203 {}
00204 void operator ()(operand_class_type const* pt) const
00205 {
00206 (pt->*m_func)();
00207 }
00208 private:
00209 method_type m_func;
00210 };
00211
00212 # endif
00213 #endif
00214
00215
00216
00217 #ifdef STLSOFT_CF_CDECL_SUPPORTED
00218
00223
00224 template< ss_typename_param_k R
00225 , ss_typename_param_k T
00226 >
00227 struct cdecl_mem_fun_t
00228 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00229 {
00230 public:
00231 typedef R return_type;
00232 typedef T operand_class_type;
00233 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00234 typedef return_type STLSOFT_CDECL (T::*method_type)();
00235 # else
00236 typedef return_type (STLSOFT_CDECL T::*method_type)();
00237 # endif
00238 public:
00239 ss_explicit_k cdecl_mem_fun_t(method_type func)
00240 : m_func(func)
00241 {}
00242 return_type operator ()(operand_class_type *pt) const
00243 {
00244 return (pt->*m_func)();
00245 }
00246 private:
00247 method_type m_func;
00248 };
00249
00255
00256 template< ss_typename_param_k R
00257 , ss_typename_param_k T
00258 >
00259 struct cdecl_mem_fun_const_t
00260 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00261 {
00262 public:
00263 typedef R return_type;
00264 typedef T operand_class_type;
00265 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00266 typedef return_type STLSOFT_CDECL (T::*method_type)() const;
00267 # else
00268 typedef return_type (STLSOFT_CDECL T::*method_type)() const;
00269 # endif
00270 public:
00271 ss_explicit_k cdecl_mem_fun_const_t(method_type func)
00272 : m_func(func)
00273 {}
00274 return_type operator ()(operand_class_type const* pt) const
00275 {
00276 return (pt->*m_func)();
00277 }
00278 private:
00279 method_type m_func;
00280 };
00281
00282 # ifndef STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID
00283
00284 template< ss_typename_param_k T
00285 >
00286 struct cdecl_mem_fun_void_t
00287 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00288 {
00289 public:
00290 typedef void return_type;
00291 typedef T operand_class_type;
00292 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00293 typedef return_type STLSOFT_CDECL (T::*method_type)();
00294 # else
00295 typedef return_type (STLSOFT_CDECL T::*method_type)();
00296 # endif
00297 public:
00298 ss_explicit_k cdecl_mem_fun_void_t(method_type func)
00299 : m_func(func)
00300 {}
00301 void operator ()(operand_class_type *pt) const
00302 {
00303 (pt->*m_func)();
00304 }
00305 private:
00306 method_type m_func;
00307 };
00308
00309 template< ss_typename_param_k T
00310 >
00311 struct cdecl_mem_fun_const_void_t
00312 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00313 {
00314 public:
00315 typedef void return_type;
00316 typedef T operand_class_type;
00317 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00318 typedef return_type STLSOFT_CDECL (T::*method_type)() const;
00319 # else
00320 typedef return_type (STLSOFT_CDECL T::*method_type)() const;
00321 # endif
00322 public:
00323 ss_explicit_k cdecl_mem_fun_const_void_t(method_type func)
00324 : m_func(func)
00325 {}
00326 void operator ()(operand_class_type const* pt) const
00327 {
00328 (pt->*m_func)();
00329 }
00330 private:
00331 method_type m_func;
00332 };
00333
00334 # endif
00335 #endif
00336
00337
00338
00339
00340
00341 #ifdef STLSOFT_CF_FASTCALL_SUPPORTED
00342
00348
00349 template< ss_typename_param_k R
00350 , ss_typename_param_k T
00351 >
00352 struct fastcall_mem_fun_t
00353 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00354 {
00355 public:
00356 typedef R return_type;
00357 typedef T operand_class_type;
00358 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00359 typedef return_type STLSOFT_FASTCALL (T::*method_type)();
00360 #else
00361 typedef return_type (STLSOFT_FASTCALL T::*method_type)();
00362 #endif
00363 public:
00364 ss_explicit_k fastcall_mem_fun_t(method_type func)
00365 : m_func(func)
00366 {}
00367 return_type operator ()(operand_class_type *pt) const
00368 {
00369 return (pt->*m_func)();
00370 }
00371 private:
00372 method_type m_func;
00373 };
00374
00380
00381 template< ss_typename_param_k R
00382 , ss_typename_param_k T
00383 >
00384 struct fastcall_mem_fun_const_t
00385 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00386 {
00387 public:
00388 typedef R return_type;
00389 typedef T operand_class_type;
00390 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00391 typedef return_type STLSOFT_FASTCALL (T::*method_type)() const;
00392 #else
00393 typedef return_type (STLSOFT_FASTCALL T::*method_type)() const;
00394 #endif
00395 public:
00396 ss_explicit_k fastcall_mem_fun_const_t(method_type func)
00397 : m_func(func)
00398 {}
00399 return_type operator ()(operand_class_type const* pt) const
00400 {
00401 return (pt->*m_func)();
00402 }
00403 private:
00404 method_type m_func;
00405 };
00406
00407 # ifndef STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID
00408
00409 template< ss_typename_param_k T
00410 >
00411 struct fastcall_mem_fun_void_t
00412 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00413 {
00414 public:
00415 typedef void return_type;
00416 typedef T operand_class_type;
00417 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00418 typedef return_type STLSOFT_FASTCALL (T::*method_type)();
00419 #else
00420 typedef return_type (STLSOFT_FASTCALL T::*method_type)();
00421 #endif
00422 public:
00423 ss_explicit_k fastcall_mem_fun_void_t(method_type func)
00424 : m_func(func)
00425 {}
00426 void operator ()(operand_class_type *pt) const
00427 {
00428 (pt->*m_func)();
00429 }
00430 private:
00431 method_type m_func;
00432 };
00433
00434 template< ss_typename_param_k T
00435 >
00436 struct fastcall_mem_fun_const_void_t
00437 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00438 {
00439 public:
00440 typedef void return_type;
00441 typedef T operand_class_type;
00442 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00443 typedef return_type STLSOFT_FASTCALL (T::*method_type)() const;
00444 #else
00445 typedef return_type (STLSOFT_FASTCALL T::*method_type)() const;
00446 #endif
00447 public:
00448 ss_explicit_k fastcall_mem_fun_const_void_t(method_type func)
00449 : m_func(func)
00450 {}
00451 void operator ()(operand_class_type const* pt) const
00452 {
00453 (pt->*m_func)();
00454 }
00455 private:
00456 method_type m_func;
00457 };
00458
00459 # endif
00460
00461 #endif
00462
00463
00464
00465
00466
00467 #ifdef STLSOFT_CF_STDCALL_SUPPORTED
00468
00474
00475 template< ss_typename_param_k R
00476 , ss_typename_param_k T
00477 >
00478 struct stdcall_mem_fun_t
00479 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00480 {
00481 public:
00482 typedef R return_type;
00483 typedef T operand_class_type;
00484 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00485 typedef return_type STLSOFT_STDCALL (T::*method_type)();
00486 #else
00487 typedef return_type (STLSOFT_STDCALL T::*method_type)();
00488 #endif
00489 public:
00490 ss_explicit_k stdcall_mem_fun_t(method_type func)
00491 : m_func(func)
00492 {}
00493 return_type operator ()(operand_class_type *pt) const
00494 {
00495 return (pt->*m_func)();
00496 }
00497 private:
00498 method_type m_func;
00499 };
00500
00506
00507 template< ss_typename_param_k R
00508 , ss_typename_param_k T
00509 >
00510 struct stdcall_mem_fun_const_t
00511 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00512 {
00513 public:
00514 typedef R return_type;
00515 typedef T operand_class_type;
00516 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00517 typedef return_type STLSOFT_STDCALL (T::*method_type)() const;
00518 #else
00519 typedef return_type (STLSOFT_STDCALL T::*method_type)() const;
00520 #endif
00521 public:
00522 ss_explicit_k stdcall_mem_fun_const_t(method_type func)
00523 : m_func(func)
00524 {}
00525 return_type operator ()(operand_class_type const* pt) const
00526 {
00527 return (pt->*m_func)();
00528 }
00529 private:
00530 method_type m_func;
00531 };
00532
00533 # ifndef STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID
00534
00535 template< ss_typename_param_k T
00536 >
00537 struct stdcall_mem_fun_void_t
00538 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00539 {
00540 public:
00541 typedef void return_type;
00542 typedef T operand_class_type;
00543 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00544 typedef return_type STLSOFT_STDCALL (T::*method_type)();
00545 #else
00546 typedef return_type (STLSOFT_STDCALL T::*method_type)();
00547 #endif
00548 public:
00549 ss_explicit_k stdcall_mem_fun_void_t(method_type func)
00550 : m_func(func)
00551 {}
00552 void operator ()(operand_class_type *pt) const
00553 {
00554 (pt->*m_func)();
00555 }
00556 private:
00557 method_type m_func;
00558 };
00559
00560 template< ss_typename_param_k T
00561 >
00562 struct stdcall_mem_fun_const_void_t
00563 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00564 {
00565 public:
00566 typedef void return_type;
00567 typedef T operand_class_type;
00568 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00569 typedef return_type STLSOFT_STDCALL (T::*method_type)() const;
00570 #else
00571 typedef return_type (STLSOFT_STDCALL T::*method_type)() const;
00572 #endif
00573 public:
00574 ss_explicit_k stdcall_mem_fun_const_void_t(method_type func)
00575 : m_func(func)
00576 {}
00577 void operator ()(operand_class_type const* pt) const
00578 {
00579 (pt->*m_func)();
00580 }
00581 private:
00582 method_type m_func;
00583 };
00584
00585 # endif
00586
00587 #endif
00588
00589
00590
00591 #ifdef STLSOFT_CF_THISCALL_SUPPORTED
00592
00597
00598 template< ss_typename_param_k R
00599 , ss_typename_param_k T
00600 >
00601 struct thiscall_mem_fun_ref_t
00602 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00603 {
00604 public:
00605 typedef R return_type;
00606 typedef T operand_class_type;
00607 typedef return_type (T::*method_type)();
00608 public:
00609 ss_explicit_k thiscall_mem_fun_ref_t(method_type func)
00610 : m_func(func)
00611 {}
00612 return_type operator ()(operand_class_type& rt) const
00613 {
00614 return (rt.*m_func)();
00615 }
00616 private:
00617 method_type m_func;
00618 };
00619
00625
00626 template< ss_typename_param_k R
00627 , ss_typename_param_k T
00628 >
00629 struct thiscall_mem_fun_ref_const_t
00630 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00631 {
00632 public:
00633 typedef R return_type;
00634 typedef T operand_class_type;
00635 typedef return_type (T::*method_type)() const;
00636 public:
00637 ss_explicit_k thiscall_mem_fun_ref_const_t(method_type func)
00638 : m_func(func)
00639 {}
00640 return_type operator ()(operand_class_type const& rt) const
00641 {
00642 return (rt.*m_func)();
00643 }
00644 private:
00645 method_type m_func;
00646 };
00647
00648 # ifndef STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID
00649
00650 template< ss_typename_param_k T
00651 >
00652 struct thiscall_mem_fun_ref_void_t
00653 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00654 {
00655 public:
00656 typedef void return_type;
00657 typedef T operand_class_type;
00658 typedef return_type (T::*method_type)();
00659 public:
00660 ss_explicit_k thiscall_mem_fun_ref_void_t(method_type func)
00661 : m_func(func)
00662 {}
00663 void operator ()(operand_class_type& rt) const
00664 {
00665 (rt.*m_func)();
00666 }
00667 private:
00668 method_type m_func;
00669 };
00670
00671 template< ss_typename_param_k T
00672 >
00673 struct thiscall_mem_fun_ref_const_void_t
00674 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00675 {
00676 public:
00677 typedef void return_type;
00678 typedef T operand_class_type;
00679 typedef return_type (T::*method_type)() const;
00680 public:
00681 ss_explicit_k thiscall_mem_fun_ref_const_void_t(method_type func)
00682 : m_func(func)
00683 {}
00684 void operator ()(operand_class_type const& rt) const
00685 {
00686 (rt.*m_func)();
00687 }
00688 private:
00689 method_type m_func;
00690 };
00691
00692 # endif
00693 #endif
00694
00695
00696
00697 #ifdef STLSOFT_CF_CDECL_SUPPORTED
00698
00704
00705 template< ss_typename_param_k R
00706 , ss_typename_param_k T
00707 >
00708 struct cdecl_mem_fun_ref_t
00709 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00710 {
00711 public:
00712 typedef R return_type;
00713 typedef T operand_class_type;
00714 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00715 typedef return_type STLSOFT_CDECL (T::*method_type)();
00716 # else
00717 typedef return_type (STLSOFT_CDECL T::*method_type)();
00718 # endif
00719 public:
00720 ss_explicit_k cdecl_mem_fun_ref_t(method_type func)
00721 : m_func(func)
00722 {}
00723 return_type operator ()(operand_class_type& rt) const
00724 {
00725 return (rt.*m_func)();
00726 }
00727 private:
00728 method_type m_func;
00729 };
00730
00736
00737 template< ss_typename_param_k R
00738 , ss_typename_param_k T
00739 >
00740 struct cdecl_mem_fun_ref_const_t
00741 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00742 {
00743 public:
00744 typedef R return_type;
00745 typedef T operand_class_type;
00746 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00747 typedef return_type STLSOFT_CDECL (T::*method_type)() const;
00748 # else
00749 typedef return_type (STLSOFT_CDECL T::*method_type)() const;
00750 # endif
00751 public:
00752 ss_explicit_k cdecl_mem_fun_ref_const_t(method_type func)
00753 : m_func(func)
00754 {}
00755 return_type operator ()(operand_class_type const& rt) const
00756 {
00757 return (rt.*m_func)();
00758 }
00759 private:
00760 method_type m_func;
00761 };
00762
00763 # ifndef STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID
00764
00765 template< ss_typename_param_k T
00766 >
00767 struct cdecl_mem_fun_ref_void_t
00768 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00769 {
00770 public:
00771 typedef void return_type;
00772 typedef T operand_class_type;
00773 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00774 typedef return_type STLSOFT_CDECL (T::*method_type)();
00775 # else
00776 typedef return_type (STLSOFT_CDECL T::*method_type)();
00777 # endif
00778 public:
00779 ss_explicit_k cdecl_mem_fun_ref_void_t(method_type func)
00780 : m_func(func)
00781 {}
00782 void operator ()(operand_class_type& rt) const
00783 {
00784 (rt.*m_func)();
00785 }
00786 private:
00787 method_type m_func;
00788 };
00789
00790 template< ss_typename_param_k T
00791 >
00792 struct cdecl_mem_fun_ref_const_void_t
00793 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00794 {
00795 public:
00796 typedef void return_type;
00797 typedef T operand_class_type;
00798 # ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00799 typedef return_type STLSOFT_CDECL (T::*method_type)() const;
00800 # else
00801 typedef return_type (STLSOFT_CDECL T::*method_type)() const;
00802 # endif
00803 public:
00804 ss_explicit_k cdecl_mem_fun_ref_const_void_t(method_type func)
00805 : m_func(func)
00806 {}
00807 void operator ()(operand_class_type const& rt) const
00808 {
00809 (rt.*m_func)();
00810 }
00811 private:
00812 method_type m_func;
00813 };
00814
00815 # endif
00816 #endif
00817
00818
00819 #ifdef STLSOFT_CF_FASTCALL_SUPPORTED
00820
00826
00827 template< ss_typename_param_k R
00828 , ss_typename_param_k T
00829 >
00830 struct fastcall_mem_fun_ref_t
00831 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00832 {
00833 public:
00834 typedef R return_type;
00835 typedef T operand_class_type;
00836 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00837 typedef return_type STLSOFT_FASTCALL (T::*method_type)();
00838 #else
00839 typedef return_type (STLSOFT_FASTCALL T::*method_type)();
00840 #endif
00841 public:
00842 ss_explicit_k fastcall_mem_fun_ref_t(method_type func)
00843 : m_func(func)
00844 {}
00845 return_type operator ()(operand_class_type& rt) const
00846 {
00847 return (rt.*m_func)();
00848 }
00849 private:
00850 method_type m_func;
00851 };
00852
00858
00859 template< ss_typename_param_k R
00860 , ss_typename_param_k T
00861 >
00862 struct fastcall_mem_fun_ref_const_t
00863 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00864 {
00865 public:
00866 typedef R return_type;
00867 typedef T operand_class_type;
00868 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00869 typedef return_type STLSOFT_FASTCALL (T::*method_type)() const;
00870 #else
00871 typedef return_type (STLSOFT_FASTCALL T::*method_type)() const;
00872 #endif
00873 public:
00874 ss_explicit_k fastcall_mem_fun_ref_const_t(method_type func)
00875 : m_func(func)
00876 {}
00877 return_type operator ()(operand_class_type const& rt) const
00878 {
00879 return (rt.*m_func)();
00880 }
00881 private:
00882 method_type m_func;
00883 };
00884
00885 # ifndef STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID
00886
00887 template< ss_typename_param_k T
00888 >
00889 struct fastcall_mem_fun_ref_void_t
00890 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00891 {
00892 public:
00893 typedef void return_type;
00894 typedef T operand_class_type;
00895 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00896 typedef return_type STLSOFT_FASTCALL (T::*method_type)();
00897 #else
00898 typedef return_type (STLSOFT_FASTCALL T::*method_type)();
00899 #endif
00900 public:
00901 ss_explicit_k fastcall_mem_fun_ref_void_t(method_type func)
00902 : m_func(func)
00903 {}
00904 void operator ()(operand_class_type& rt) const
00905 {
00906 (rt.*m_func)();
00907 }
00908 private:
00909 method_type m_func;
00910 };
00911
00912 template< ss_typename_param_k T
00913 >
00914 struct fastcall_mem_fun_ref_const_void_t
00915 : public stlsoft_ns_qual_std(unary_function)<T*, void>
00916 {
00917 public:
00918 typedef void return_type;
00919 typedef T operand_class_type;
00920 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00921 typedef return_type STLSOFT_FASTCALL (T::*method_type)() const;
00922 #else
00923 typedef return_type (STLSOFT_FASTCALL T::*method_type)() const;
00924 #endif
00925 public:
00926 ss_explicit_k fastcall_mem_fun_ref_const_void_t(method_type func)
00927 : m_func(func)
00928 {}
00929 void operator ()(operand_class_type const& rt) const
00930 {
00931 (rt.*m_func)();
00932 }
00933 private:
00934 method_type m_func;
00935 };
00936
00937 # endif
00938
00939 #endif
00940
00941
00942
00943 #ifdef STLSOFT_CF_STDCALL_SUPPORTED
00944
00950
00951 template< ss_typename_param_k R
00952 , ss_typename_param_k T
00953 >
00954 struct stdcall_mem_fun_ref_t
00955 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00956 {
00957 public:
00958 typedef R return_type;
00959 typedef T operand_class_type;
00960 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00961 typedef return_type STLSOFT_STDCALL (T::*method_type)();
00962 #else
00963 typedef return_type (STLSOFT_STDCALL T::*method_type)();
00964 #endif
00965 public:
00966 ss_explicit_k stdcall_mem_fun_ref_t(method_type func)
00967 : m_func(func)
00968 {}
00969 return_type operator ()(operand_class_type& rt) const
00970 {
00971 return (rt.*m_func)();
00972 }
00973 private:
00974 method_type m_func;
00975 };
00976
00982
00983 template< ss_typename_param_k R
00984 , ss_typename_param_k T
00985 >
00986 struct stdcall_mem_fun_ref_const_t
00987 : public stlsoft_ns_qual_std(unary_function)<T*, R>
00988 {
00989 public:
00990 typedef R return_type;
00991 typedef T operand_class_type;
00992 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
00993 typedef return_type STLSOFT_STDCALL (T::*method_type)() const;
00994 #else
00995 typedef return_type (STLSOFT_STDCALL T::*method_type)() const;
00996 #endif
00997 public:
00998 ss_explicit_k stdcall_mem_fun_ref_const_t(method_type func)
00999 : m_func(func)
01000 {}
01001 return_type operator ()(operand_class_type const& rt) const
01002 {
01003 return (rt.*m_func)();
01004 }
01005 private:
01006 method_type m_func;
01007 };
01008
01009 # ifndef STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID
01010
01011 template< ss_typename_param_k T
01012 >
01013 struct stdcall_mem_fun_ref_void_t
01014 : public stlsoft_ns_qual_std(unary_function)<T*, void>
01015 {
01016 public:
01017 typedef void return_type;
01018 typedef T operand_class_type;
01019 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01020 typedef return_type STLSOFT_STDCALL (T::*method_type)();
01021 #else
01022 typedef return_type (STLSOFT_STDCALL T::*method_type)();
01023 #endif
01024 public:
01025 ss_explicit_k stdcall_mem_fun_ref_void_t(method_type func)
01026 : m_func(func)
01027 {}
01028 void operator ()(operand_class_type& rt) const
01029 {
01030 (rt.*m_func)();
01031 }
01032 private:
01033 method_type m_func;
01034 };
01035
01036 template< ss_typename_param_k T
01037 >
01038 struct stdcall_mem_fun_ref_const_void_t
01039 : public stlsoft_ns_qual_std(unary_function)<T*, void>
01040 {
01041 public:
01042 typedef void return_type;
01043 typedef T operand_class_type;
01044 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01045 typedef return_type STLSOFT_STDCALL (T::*method_type)() const;
01046 #else
01047 typedef return_type (STLSOFT_STDCALL T::*method_type)() const;
01048 #endif
01049 public:
01050 ss_explicit_k stdcall_mem_fun_ref_const_void_t(method_type func)
01051 : m_func(func)
01052 {}
01053 void operator ()(operand_class_type const& rt) const
01054 {
01055 (rt.*m_func)();
01056 }
01057 private:
01058 method_type m_func;
01059 };
01060
01061 # endif
01062
01063 #endif
01064
01065
01066
01067
01068
01069
01070 #ifdef STLSOFT_CF_CDECL_SUPPORTED
01071
01077 template< ss_typename_param_k R
01078 , ss_typename_param_k T
01079 >
01080 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01081 inline cdecl_mem_fun_t<R, T> mem_fun(R (T::*STLSOFT_CDECL func)())
01082 #else
01083 inline cdecl_mem_fun_t<R, T> mem_fun(R (STLSOFT_CDECL T::*func)())
01084 #endif
01085 {
01086 return cdecl_mem_fun_t<R, T>(func);
01087 }
01088
01089 #if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01090
01091
01092
01093 template< ss_typename_param_k T
01094 >
01095 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01096 inline cdecl_mem_fun_t<void, T> mem_fun_void(void (T::*STLSOFT_CDECL func)())
01097 #else
01098 inline cdecl_mem_fun_t<void, T> mem_fun_void(void (STLSOFT_CDECL T::*func)())
01099 #endif
01100 {
01101 return cdecl_mem_fun_t<void, T>(func);
01102 }
01103
01104 #else
01105
01106 template< ss_typename_param_k T
01107 >
01108 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01109 inline cdecl_mem_fun_void_t<T> mem_fun(void (T::*STLSOFT_CDECL func)())
01110 #else
01111 inline cdecl_mem_fun_void_t<T> mem_fun(void (STLSOFT_CDECL T::*func)())
01112 #endif
01113 {
01114 return cdecl_mem_fun_void_t<T>(func);
01115 }
01116
01117 template< ss_typename_param_k T
01118 >
01119 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01120 inline cdecl_mem_fun_void_t<T> mem_fun_void(void (T::*STLSOFT_CDECL func)())
01121 #else
01122 inline cdecl_mem_fun_void_t<T> mem_fun_void(void (STLSOFT_CDECL T::*func)())
01123 #endif
01124 {
01125 return cdecl_mem_fun_void_t<T>(func);
01126 }
01127
01128 #endif
01129
01130
01136 template< ss_typename_param_k R
01137 , ss_typename_param_k T
01138 >
01139 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01140 inline cdecl_mem_fun_const_t<R, T> mem_fun(R (T::*STLSOFT_CDECL func)() const)
01141 #else
01142 inline cdecl_mem_fun_const_t<R, T> mem_fun(R (STLSOFT_CDECL T::*func)() const)
01143 #endif
01144 {
01145 return cdecl_mem_fun_const_t<R, T>(func);
01146 }
01147
01148 #if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01149
01150
01151
01152 template< ss_typename_param_k T
01153 >
01154 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01155 inline cdecl_mem_fun_const_t<void, T> mem_fun_void(void (T::*STLSOFT_CDECL func)() const)
01156 #else
01157 inline cdecl_mem_fun_const_t<void, T> mem_fun_void(void (STLSOFT_CDECL T::*func)() const)
01158 #endif
01159 {
01160 return cdecl_mem_fun_const_t<void, T>(func);
01161 }
01162
01163 #else
01164
01165 template< ss_typename_param_k T
01166 >
01167 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01168 inline cdecl_mem_fun_const_void_t<T> mem_fun(void (T::*STLSOFT_CDECL func)() const)
01169 #else
01170 inline cdecl_mem_fun_const_void_t<T> mem_fun(void (STLSOFT_CDECL T::*func)() const)
01171 #endif
01172 {
01173 return cdecl_mem_fun_const_void_t<T>(func);
01174 }
01175
01176 template< ss_typename_param_k T
01177 >
01178 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01179 inline cdecl_mem_fun_const_void_t<T> mem_fun_void(void (T::*STLSOFT_CDECL func)() const)
01180 #else
01181 inline cdecl_mem_fun_const_void_t<T> mem_fun_void(void (STLSOFT_CDECL T::*func)() const)
01182 #endif
01183 {
01184 return cdecl_mem_fun_const_void_t<T>(func);
01185 }
01186
01187 #endif
01188 #endif
01189
01190
01191
01192 #ifdef STLSOFT_CF_FASTCALL_SUPPORTED
01193
01200 template< ss_typename_param_k R
01201 , ss_typename_param_k T
01202 >
01203 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01204 inline fastcall_mem_fun_t<R, T> mem_fun(R (T::*STLSOFT_FASTCALL func)())
01205 #else
01206 inline fastcall_mem_fun_t<R, T> mem_fun(R (STLSOFT_FASTCALL T::*func)())
01207 #endif
01208 {
01209 return fastcall_mem_fun_t<R, T>(func);
01210 }
01211
01212 # if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01213
01214
01215
01216 template< ss_typename_param_k T
01217 >
01218 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01219 inline fastcall_mem_fun_t<void, T> mem_fun_void(void (T::*STLSOFT_FASTCALL func)())
01220 #else
01221 inline fastcall_mem_fun_t<void, T> mem_fun_void(void (STLSOFT_FASTCALL T::*func)())
01222 #endif
01223 {
01224 return fastcall_mem_fun_t<void, T>(func);
01225 }
01226
01227 # else
01228
01229 template< ss_typename_param_k T
01230 >
01231 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01232 inline fastcall_mem_fun_void_t<T> mem_fun(void (T::*STLSOFT_FASTCALL func)())
01233 #else
01234 inline fastcall_mem_fun_void_t<T> mem_fun(void (STLSOFT_FASTCALL T::*func)())
01235 #endif
01236 {
01237 return fastcall_mem_fun_void_t<T>(func);
01238 }
01239
01240 template< ss_typename_param_k T
01241 >
01242 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01243 inline fastcall_mem_fun_void_t<T> mem_fun_void(void (T::*STLSOFT_FASTCALL func)())
01244 #else
01245 inline fastcall_mem_fun_void_t<T> mem_fun_void(void (STLSOFT_FASTCALL T::*func)())
01246 #endif
01247 {
01248 return fastcall_mem_fun_void_t<T>(func);
01249 }
01250
01251 # endif
01252
01253 #endif
01254
01255
01261 #ifdef STLSOFT_CF_FASTCALL_SUPPORTED
01262
01263 template< ss_typename_param_k R
01264 , ss_typename_param_k T
01265 >
01266 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01267 inline fastcall_mem_fun_const_t<R, T> mem_fun(R (T::*STLSOFT_FASTCALL func)() const)
01268 #else
01269 inline fastcall_mem_fun_const_t<R, T> mem_fun(R (STLSOFT_FASTCALL T::*func)() const)
01270 #endif
01271 {
01272 return fastcall_mem_fun_const_t<R, T>(func);
01273 }
01274
01275 # if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01276
01277
01278
01279 template< ss_typename_param_k T
01280 >
01281 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01282 inline fastcall_mem_fun_const_t<void, T> mem_fun_void(void (T::*STLSOFT_FASTCALL func)() const)
01283 #else
01284 inline fastcall_mem_fun_const_t<void, T> mem_fun_void(void (STLSOFT_FASTCALL T::*func)() const)
01285 #endif
01286 {
01287 return fastcall_mem_fun_const_t<void, T>(func);
01288 }
01289
01290 # else
01291
01292 template< ss_typename_param_k T
01293 >
01294 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01295 inline fastcall_mem_fun_const_void_t<T> mem_fun(void (T::*STLSOFT_FASTCALL func)() const)
01296 #else
01297 inline fastcall_mem_fun_const_void_t<T> mem_fun(void (STLSOFT_FASTCALL T::*func)() const)
01298 #endif
01299 {
01300 return fastcall_mem_fun_const_void_t<T>(func);
01301 }
01302
01303 template< ss_typename_param_k T
01304 >
01305 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01306 inline fastcall_mem_fun_const_void_t<T> mem_fun_void(void (T::*STLSOFT_FASTCALL func)() const)
01307 #else
01308 inline fastcall_mem_fun_const_void_t<T> mem_fun_void(void (STLSOFT_FASTCALL T::*func)() const)
01309 #endif
01310 {
01311 return fastcall_mem_fun_const_void_t<T>(func);
01312 }
01313
01314 # endif
01315
01316 #endif
01317
01318
01319
01320
01326 #ifdef STLSOFT_CF_STDCALL_SUPPORTED
01327
01328 template< ss_typename_param_k R
01329 , ss_typename_param_k T
01330 >
01331 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01332 inline stdcall_mem_fun_t<R, T> mem_fun(R (T::*STLSOFT_STDCALL func)())
01333 #else
01334 inline stdcall_mem_fun_t<R, T> mem_fun(R (STLSOFT_STDCALL T::*func)())
01335 #endif
01336 {
01337 return stdcall_mem_fun_t<R, T>(func);
01338 }
01339
01340 # if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01341
01342
01343
01344 template< ss_typename_param_k T
01345 >
01346 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01347 inline stdcall_mem_fun_t<void, T> mem_fun_void(void (T::*STLSOFT_STDCALL func)())
01348 #else
01349 inline stdcall_mem_fun_t<void, T> mem_fun_void(void (STLSOFT_STDCALL T::*func)())
01350 #endif
01351 {
01352 return stdcall_mem_fun_t<void, T>(func);
01353 }
01354
01355 # else
01356
01357 template< ss_typename_param_k T
01358 >
01359 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01360 inline stdcall_mem_fun_void_t<T> mem_fun(void (T::*STLSOFT_STDCALL func)())
01361 #else
01362 inline stdcall_mem_fun_void_t<T> mem_fun(void (STLSOFT_STDCALL T::*func)())
01363 #endif
01364 {
01365 return stdcall_mem_fun_void_t<T>(func);
01366 }
01367
01368 template< ss_typename_param_k T
01369 >
01370 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01371 inline stdcall_mem_fun_void_t<T> mem_fun_void(void (T::*STLSOFT_STDCALL func)())
01372 #else
01373 inline stdcall_mem_fun_void_t<T> mem_fun_void(void (STLSOFT_STDCALL T::*func)())
01374 #endif
01375 {
01376 return stdcall_mem_fun_void_t<T>(func);
01377 }
01378
01379 # endif
01380
01381 #endif
01382
01383
01389 #ifdef STLSOFT_CF_STDCALL_SUPPORTED
01390
01391 template< ss_typename_param_k R
01392 , ss_typename_param_k T
01393 >
01394 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01395 inline stdcall_mem_fun_const_t<R, T> mem_fun(R (T::*STLSOFT_STDCALL func)() const)
01396 #else
01397 inline stdcall_mem_fun_const_t<R, T> mem_fun(R (STLSOFT_STDCALL T::*func)() const)
01398 #endif
01399 {
01400 return stdcall_mem_fun_const_t<R, T>(func);
01401 }
01402
01403 # if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01404
01405
01406
01407 template< ss_typename_param_k T
01408 >
01409 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01410 inline stdcall_mem_fun_const_t<void, T> mem_fun_void(void (T::*STLSOFT_STDCALL func)() const)
01411 #else
01412 inline stdcall_mem_fun_const_t<void, T> mem_fun_void(void (STLSOFT_STDCALL T::*func)() const)
01413 #endif
01414 {
01415 return stdcall_mem_fun_const_t<void, T>(func);
01416 }
01417
01418 # else
01419
01420 template< ss_typename_param_k T
01421 >
01422 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01423 inline stdcall_mem_fun_const_void_t<T> mem_fun(void (T::*STLSOFT_STDCALL func)() const)
01424 #else
01425 inline stdcall_mem_fun_const_void_t<T> mem_fun(void (STLSOFT_STDCALL T::*func)() const)
01426 #endif
01427 {
01428 return stdcall_mem_fun_const_void_t<T>(func);
01429 }
01430
01431 template< ss_typename_param_k T
01432 >
01433 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01434 inline stdcall_mem_fun_const_void_t<T> mem_fun_void(void (T::*STLSOFT_STDCALL func)() const)
01435 #else
01436 inline stdcall_mem_fun_const_void_t<T> mem_fun_void(void (STLSOFT_STDCALL T::*func)() const)
01437 #endif
01438 {
01439 return stdcall_mem_fun_const_void_t<T>(func);
01440 }
01441
01442 # endif
01443
01444 #endif
01445
01446
01447
01448
01449 #ifdef STLSOFT_CF_THISCALL_SUPPORTED
01450
01456 template< ss_typename_param_k R
01457 , ss_typename_param_k T
01458 >
01459 inline thiscall_mem_fun_ref_t<R, T> mem_fun_ref(R (T::*func)())
01460 {
01461 return thiscall_mem_fun_ref_t<R, T>(func);
01462 }
01463
01464 #if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01465
01466
01467
01468 template< ss_typename_param_k T
01469 >
01470 inline thiscall_mem_fun_ref_t<void, T> mem_fun_ref_void(void (T::*func)())
01471 {
01472 return thiscall_mem_fun_ref_t<void, T>(func);
01473 }
01474
01475 #else
01476
01477 template< ss_typename_param_k T
01478 >
01479 inline thiscall_mem_fun_ref_void_t<T> mem_fun_ref(void (T::*func)())
01480 {
01481 return thiscall_mem_fun_ref_void_t<T>(func);
01482 }
01483
01484 template< ss_typename_param_k T
01485 >
01486 inline thiscall_mem_fun_ref_void_t<T> mem_fun_ref_void(void (T::*func)())
01487 {
01488 return thiscall_mem_fun_ref_void_t<T>(func);
01489 }
01490
01491 #endif
01492
01493
01499 template< ss_typename_param_k R
01500 , ss_typename_param_k T
01501 >
01502 inline thiscall_mem_fun_ref_const_t<R, T> mem_fun_ref(R (T::*func)() const)
01503 {
01504 return thiscall_mem_fun_ref_const_t<R, T>(func);
01505 }
01506
01507 #if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01508
01509
01510
01511 template< ss_typename_param_k T
01512 >
01513 inline thiscall_mem_fun_ref_const_t<void, T> mem_fun_ref_void(void (T::*func)() const)
01514 {
01515 return thiscall_mem_fun_ref_const_t<void, T>(func);
01516 }
01517
01518 #else
01519
01520 template< ss_typename_param_k T
01521 >
01522 inline thiscall_mem_fun_ref_const_void_t<T> mem_fun_ref(void (T::*func)() const)
01523 {
01524 return thiscall_mem_fun_ref_const_void_t<T>(func);
01525 }
01526
01527 template< ss_typename_param_k T
01528 >
01529 inline thiscall_mem_fun_ref_const_void_t<T> mem_fun_ref_void(void (T::*func)() const)
01530 {
01531 return thiscall_mem_fun_ref_const_void_t<T>(func);
01532 }
01533
01534 # endif
01535 #endif
01536
01537
01538 #ifdef STLSOFT_CF_CDECL_SUPPORTED
01539
01545 template< ss_typename_param_k R
01546 , ss_typename_param_k T
01547 >
01548 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01549 inline cdecl_mem_fun_ref_t<R, T> mem_fun_ref(R (T::*STLSOFT_CDECL func)())
01550 #else
01551 inline cdecl_mem_fun_ref_t<R, T> mem_fun_ref(R (STLSOFT_CDECL T::*func)())
01552 #endif
01553 {
01554 return cdecl_mem_fun_ref_t<R, T>(func);
01555 }
01556
01557 #if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01558
01559
01560
01561 template< ss_typename_param_k T
01562 >
01563 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01564 inline cdecl_mem_fun_ref_t<void, T> mem_fun_ref_void(void (T::*STLSOFT_CDECL func)())
01565 #else
01566 inline cdecl_mem_fun_ref_t<void, T> mem_fun_ref_void(void (STLSOFT_CDECL T::*func)())
01567 #endif
01568 {
01569 return cdecl_mem_fun_ref_t<void, T>(func);
01570 }
01571
01572 #else
01573
01574 template< ss_typename_param_k T
01575 >
01576 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01577 inline cdecl_mem_fun_ref_void_t<T> mem_fun_ref(void (T::*STLSOFT_CDECL func)())
01578 #else
01579 inline cdecl_mem_fun_ref_void_t<T> mem_fun_ref(void (STLSOFT_CDECL T::*func)())
01580 #endif
01581 {
01582 return cdecl_mem_fun_ref_void_t<T>(func);
01583 }
01584
01585 template< ss_typename_param_k T
01586 >
01587 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01588 inline cdecl_mem_fun_ref_void_t<T> mem_fun_ref_void(void (T::*STLSOFT_CDECL func)())
01589 #else
01590 inline cdecl_mem_fun_ref_void_t<T> mem_fun_ref_void(void (STLSOFT_CDECL T::*func)())
01591 #endif
01592 {
01593 return cdecl_mem_fun_ref_void_t<T>(func);
01594 }
01595
01596 #endif
01597
01598
01604 template< ss_typename_param_k R
01605 , ss_typename_param_k T
01606 >
01607 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01608 inline cdecl_mem_fun_ref_const_t<R, T> mem_fun_ref(R (T::*STLSOFT_CDECL func)() const)
01609 #else
01610 inline cdecl_mem_fun_ref_const_t<R, T> mem_fun_ref(R (STLSOFT_CDECL T::*func)() const)
01611 #endif
01612 {
01613 return cdecl_mem_fun_ref_const_t<R, T>(func);
01614 }
01615
01616 #if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01617
01618
01619
01620 template< ss_typename_param_k T
01621 >
01622 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01623 inline cdecl_mem_fun_ref_const_t<void, T> mem_fun_ref_void(void (T::*STLSOFT_CDECL func)() const)
01624 #else
01625 inline cdecl_mem_fun_ref_const_t<void, T> mem_fun_ref_void(void (STLSOFT_CDECL T::*func)() const)
01626 #endif
01627 {
01628 return cdecl_mem_fun_ref_const_t<void, T>(func);
01629 }
01630
01631 #else
01632
01633 template< ss_typename_param_k T
01634 >
01635 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01636 inline cdecl_mem_fun_ref_const_void_t<T> mem_fun_ref(void (T::*STLSOFT_CDECL func)() const)
01637 #else
01638 inline cdecl_mem_fun_ref_const_void_t<T> mem_fun_ref(void (STLSOFT_CDECL T::*func)() const)
01639 #endif
01640 {
01641 return cdecl_mem_fun_ref_const_void_t<T>(func);
01642 }
01643
01644 template< ss_typename_param_k T
01645 >
01646 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01647 inline cdecl_mem_fun_ref_const_void_t<T> mem_fun_ref_void(void (T::*STLSOFT_CDECL func)() const)
01648 #else
01649 inline cdecl_mem_fun_ref_const_void_t<T> mem_fun_ref_void(void (STLSOFT_CDECL T::*func)() const)
01650 #endif
01651 {
01652 return cdecl_mem_fun_ref_const_void_t<T>(func);
01653 }
01654
01655 # endif
01656 #endif
01657
01658
01659
01660
01661 #ifdef STLSOFT_CF_FASTCALL_SUPPORTED
01662
01668 template< ss_typename_param_k R
01669 , ss_typename_param_k T
01670 >
01671 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01672 inline fastcall_mem_fun_ref_t<R, T> mem_fun_ref(R (T::*STLSOFT_FASTCALL func)())
01673 #else
01674 inline fastcall_mem_fun_ref_t<R, T> mem_fun_ref(R (STLSOFT_FASTCALL T::*func)())
01675 #endif
01676 {
01677 return fastcall_mem_fun_ref_t<R, T>(func);
01678 }
01679
01680 # if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01681
01682
01683
01684 template< ss_typename_param_k T
01685 >
01686 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01687 inline fastcall_mem_fun_ref_t<void, T> mem_fun_ref_void(void (T::*STLSOFT_FASTCALL func)())
01688 #else
01689 inline fastcall_mem_fun_ref_t<void, T> mem_fun_ref_void(void (STLSOFT_FASTCALL T::*func)())
01690 #endif
01691 {
01692 return fastcall_mem_fun_ref_t<void, T>(func);
01693 }
01694
01695 # else
01696
01697 template< ss_typename_param_k T
01698 >
01699 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01700 inline fastcall_mem_fun_ref_void_t<T> mem_fun_ref(void (T::*STLSOFT_FASTCALL func)())
01701 #else
01702 inline fastcall_mem_fun_ref_void_t<T> mem_fun_ref(void (STLSOFT_FASTCALL T::*func)())
01703 #endif
01704 {
01705 return fastcall_mem_fun_ref_void_t<T>(func);
01706 }
01707
01708 template< ss_typename_param_k T
01709 >
01710 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01711 inline fastcall_mem_fun_ref_void_t<T> mem_fun_ref_void(void (T::*STLSOFT_FASTCALL func)())
01712 #else
01713 inline fastcall_mem_fun_ref_void_t<T> mem_fun_ref_void(void (STLSOFT_FASTCALL T::*func)())
01714 #endif
01715 {
01716 return fastcall_mem_fun_ref_void_t<T>(func);
01717 }
01718
01719 # endif
01720
01721 #endif
01722
01723
01724 #ifdef STLSOFT_CF_FASTCALL_SUPPORTED
01725
01731 template< ss_typename_param_k R
01732 , ss_typename_param_k T
01733 >
01734 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01735 inline fastcall_mem_fun_ref_const_t<R, T> mem_fun_ref(R (T::*STLSOFT_FASTCALL func)() const)
01736 #else
01737 inline fastcall_mem_fun_ref_const_t<R, T> mem_fun_ref(R (STLSOFT_FASTCALL T::*func)() const)
01738 #endif
01739 {
01740 return fastcall_mem_fun_ref_const_t<R, T>(func);
01741 }
01742
01743 # if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01744
01745
01746
01747 template< ss_typename_param_k T
01748 >
01749 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01750 inline fastcall_mem_fun_ref_const_t<void, T> mem_fun_ref_void(void (T::*STLSOFT_FASTCALL func)() const)
01751 #else
01752 inline fastcall_mem_fun_ref_const_t<void, T> mem_fun_ref_void(void (STLSOFT_FASTCALL T::*func)() const)
01753 #endif
01754 {
01755 return fastcall_mem_fun_ref_const_t<void, T>(func);
01756 }
01757
01758 # else
01759
01760 template< ss_typename_param_k T
01761 >
01762 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01763 inline fastcall_mem_fun_ref_const_void_t<T> mem_fun_ref(void (T::*STLSOFT_FASTCALL func)() const)
01764 #else
01765 inline fastcall_mem_fun_ref_const_void_t<T> mem_fun_ref(void (STLSOFT_FASTCALL T::*func)() const)
01766 #endif
01767 {
01768 return fastcall_mem_fun_ref_const_void_t<T>(func);
01769 }
01770
01771 template< ss_typename_param_k T
01772 >
01773 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01774 inline fastcall_mem_fun_ref_const_void_t<T> mem_fun_ref_void(void (T::*STLSOFT_FASTCALL func)() const)
01775 #else
01776 inline fastcall_mem_fun_ref_const_void_t<T> mem_fun_ref_void(void (STLSOFT_FASTCALL T::*func)() const)
01777 #endif
01778 {
01779 return fastcall_mem_fun_ref_const_void_t<T>(func);
01780 }
01781
01782 # endif
01783
01784 #endif
01785
01786
01787
01788
01789 #ifdef STLSOFT_CF_STDCALL_SUPPORTED
01790
01796 template< ss_typename_param_k R
01797 , ss_typename_param_k T
01798 >
01799 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01800 inline stdcall_mem_fun_ref_t<R, T> mem_fun_ref(R (T::*STLSOFT_STDCALL func)())
01801 #else
01802 inline stdcall_mem_fun_ref_t<R, T> mem_fun_ref(R (STLSOFT_STDCALL T::*func)())
01803 #endif
01804 {
01805 return stdcall_mem_fun_ref_t<R, T>(func);
01806 }
01807
01808 # if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01809
01810
01811
01812 template< ss_typename_param_k T
01813 >
01814 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01815 inline stdcall_mem_fun_ref_t<void, T> mem_fun_ref_void(void (T::*STLSOFT_STDCALL func)())
01816 #else
01817 inline stdcall_mem_fun_ref_t<void, T> mem_fun_ref_void(void (STLSOFT_STDCALL T::*func)())
01818 #endif
01819 {
01820 return stdcall_mem_fun_ref_t<void, T>(func);
01821 }
01822
01823 # else
01824
01825 template< ss_typename_param_k T
01826 >
01827 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01828 inline stdcall_mem_fun_ref_void_t<T> mem_fun_ref(void (T::*STLSOFT_STDCALL func)())
01829 #else
01830 inline stdcall_mem_fun_ref_void_t<T> mem_fun_ref(void (STLSOFT_STDCALL T::*func)())
01831 #endif
01832 {
01833 return stdcall_mem_fun_ref_void_t<T>(func);
01834 }
01835
01836 template< ss_typename_param_k T
01837 >
01838 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01839 inline stdcall_mem_fun_ref_void_t<T> mem_fun_ref_void(void (T::*STLSOFT_STDCALL func)())
01840 #else
01841 inline stdcall_mem_fun_ref_void_t<T> mem_fun_ref_void(void (STLSOFT_STDCALL T::*func)())
01842 #endif
01843 {
01844 return stdcall_mem_fun_ref_void_t<T>(func);
01845 }
01846
01847 # endif
01848
01849 #endif
01850
01851
01852 #ifdef STLSOFT_CF_STDCALL_SUPPORTED
01853
01859 template< ss_typename_param_k R
01860 , ss_typename_param_k T
01861 >
01862 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01863 inline stdcall_mem_fun_ref_const_t<R, T> mem_fun_ref(R (T::*STLSOFT_STDCALL func)() const)
01864 #else
01865 inline stdcall_mem_fun_ref_const_t<R, T> mem_fun_ref(R (STLSOFT_STDCALL T::*func)() const)
01866 #endif
01867 {
01868 return stdcall_mem_fun_ref_const_t<R, T>(func);
01869 }
01870
01871 # if defined(STLSOFT_CF_COMPILER_SUPPORTS_RETURN_VOID)
01872
01873
01874
01875 template< ss_typename_param_k T
01876 >
01877 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01878 inline stdcall_mem_fun_ref_const_t<void, T> mem_fun_ref_void(void (T::*STLSOFT_STDCALL func)() const)
01879 #else
01880 inline stdcall_mem_fun_ref_const_t<void, T> mem_fun_ref_void(void (STLSOFT_STDCALL T::*func)() const)
01881 #endif
01882 {
01883 return stdcall_mem_fun_ref_const_t<void, T>(func);
01884 }
01885
01886 # else
01887
01888 template< ss_typename_param_k T
01889 >
01890 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01891 inline stdcall_mem_fun_ref_const_void_t<T> mem_fun_ref(void (T::*STLSOFT_STDCALL func)() const)
01892 #else
01893 inline stdcall_mem_fun_ref_const_void_t<T> mem_fun_ref(void (STLSOFT_STDCALL T::*func)() const)
01894 #endif
01895 {
01896 return stdcall_mem_fun_ref_const_void_t<T>(func);
01897 }
01898
01899 template< ss_typename_param_k T
01900 >
01901 #ifdef STLSOFT_CF_CALLING_CONVENTION_OUTSIDE_BRACE_REQUIRED
01902 inline stdcall_mem_fun_ref_const_void_t<T> mem_fun_ref_void(void (T::*STLSOFT_STDCALL func)() const)
01903 #else
01904 inline stdcall_mem_fun_ref_const_void_t<T> mem_fun_ref_void(void (STLSOFT_STDCALL T::*func)() const)
01905 #endif
01906 {
01907 return stdcall_mem_fun_ref_const_void_t<T>(func);
01908 }
01909
01910 # endif
01911
01912 #endif
01913
01914
01915
01916 #ifndef _STLSOFT_NO_NAMESPACE
01917 }
01918 #endif
01919
01920
01921
01922 #endif
01923
01924