bind/detail/bind_mf_cc.hpp

0001 //
0002 //  bind/bind_mf_cc.hpp - support for different calling conventions
0003 //
0004 //  Do not include this header directly.
0005 //
0006 //  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
0007 //
0008 // Distributed under the Boost Software License, Version 1.0. (See
0009 // accompanying file LICENSE_1_0.txt or copy at
0010 // http://www.boost.org/LICENSE_1_0.txt)
0011 //
0012 //  See http://www.boost.org/libs/bind/bind.html for documentation.
0013 //
0014
0015 // 0
0016
0017 template<class R, class T,
0018     class A1>
0019     auto
0020     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1)
0021     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1 ) )
0022 {
0023     return boost::BOOST_BIND( boost::mem_fn( f ), a1 );
0024 }
0025
0026 template<class R, class T,
0027     class A1>
0028     auto
0029     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1)
0030     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1 ) )
0031 {
0032     return boost::BOOST_BIND( boost::mem_fn( f ), a1 );
0033 }
0034
0035 template<class Rt2, class R, class T,
0036     class A1,
0037     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0038     auto
0039     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1)
0040     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1 ) )
0041 {
0042     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1 );
0043 }
0044
0045 template<class Rt2, class R, class T,
0046     class A1,
0047     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0048     auto
0049     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1)
0050     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1 ) )
0051 {
0052     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1 );
0053 }
0054
0055 // 1
0056
0057 template<class R, class T,
0058     class B1,
0059     class A1, class A2>
0060     auto
0061     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
0062     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2 ) )
0063 {
0064     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2 );
0065 }
0066
0067 template<class R, class T,
0068     class B1,
0069     class A1, class A2>
0070     auto
0071     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
0072     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2 ) )
0073 {
0074     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2 );
0075 }
0076
0077 template<class Rt2, class R, class T,
0078     class B1,
0079     class A1, class A2,
0080     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0081     auto
0082     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
0083     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2 ) )
0084 {
0085     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2 );
0086 }
0087
0088 template<class Rt2, class R, class T,
0089     class B1,
0090     class A1, class A2,
0091     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0092     auto
0093     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
0094     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2 ) )
0095 {
0096     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2 );
0097 }
0098
0099 // 2
0100
0101 template<class R, class T,
0102     class B1, class B2,
0103     class A1, class A2, class A3>
0104     auto
0105     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
0106     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3 ) )
0107 {
0108     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3 );
0109 }
0110
0111 template<class R, class T,
0112     class B1, class B2,
0113     class A1, class A2, class A3>
0114     auto
0115     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
0116     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3 ) )
0117 {
0118     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3 );
0119 }
0120
0121 template<class Rt2, class R, class T,
0122     class B1, class B2,
0123     class A1, class A2, class A3,
0124     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0125     auto
0126     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
0127     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3 ) )
0128 {
0129     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3 );
0130 }
0131
0132 template<class Rt2, class R, class T,
0133     class B1, class B2,
0134     class A1, class A2, class A3,
0135     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0136     auto
0137     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
0138     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3 ) )
0139 {
0140     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3 );
0141 }
0142
0143 // 3
0144
0145 template<class R, class T,
0146     class B1, class B2, class B3,
0147     class A1, class A2, class A3, class A4>
0148     auto
0149     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
0150     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4 ) )
0151 {
0152     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4 );
0153 }
0154
0155 template<class R, class T,
0156     class B1, class B2, class B3,
0157     class A1, class A2, class A3, class A4>
0158     auto
0159     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
0160     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4 ) )
0161 {
0162     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4 );
0163 }
0164
0165 template<class Rt2, class R, class T,
0166     class B1, class B2, class B3,
0167     class A1, class A2, class A3, class A4,
0168     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0169     auto
0170     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
0171     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4 ) )
0172 {
0173     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4 );
0174 }
0175
0176 template<class Rt2, class R, class T,
0177     class B1, class B2, class B3,
0178     class A1, class A2, class A3, class A4,
0179     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0180     auto
0181     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
0182     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4 ) )
0183 {
0184     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4 );
0185 }
0186
0187 // 4
0188
0189 template<class R, class T,
0190     class B1, class B2, class B3, class B4,
0191     class A1, class A2, class A3, class A4, class A5>
0192     auto
0193     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
0194     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5 ) )
0195 {
0196     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5 );
0197 }
0198
0199 template<class R, class T,
0200     class B1, class B2, class B3, class B4,
0201     class A1, class A2, class A3, class A4, class A5>
0202     auto
0203     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
0204     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5 ) )
0205 {
0206     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5 );
0207 }
0208
0209 template<class Rt2, class R, class T,
0210     class B1, class B2, class B3, class B4,
0211     class A1, class A2, class A3, class A4, class A5,
0212     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0213     auto
0214     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
0215     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5 ) )
0216 {
0217     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5 );
0218 }
0219
0220 template<class Rt2, class R, class T,
0221     class B1, class B2, class B3, class B4,
0222     class A1, class A2, class A3, class A4, class A5,
0223     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0224     auto
0225     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
0226     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5 ) )
0227 {
0228     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5 );
0229 }
0230
0231 // 5
0232
0233 template<class R, class T,
0234     class B1, class B2, class B3, class B4, class B5,
0235     class A1, class A2, class A3, class A4, class A5, class A6>
0236     auto
0237     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
0238     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 ) )
0239 {
0240     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
0241 }
0242
0243 template<class R, class T,
0244     class B1, class B2, class B3, class B4, class B5,
0245     class A1, class A2, class A3, class A4, class A5, class A6>
0246     auto
0247     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
0248     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 ) )
0249 {
0250     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
0251 }
0252
0253 template<class Rt2, class R, class T,
0254     class B1, class B2, class B3, class B4, class B5,
0255     class A1, class A2, class A3, class A4, class A5, class A6,
0256     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0257     auto
0258     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
0259     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 ) )
0260 {
0261     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
0262 }
0263
0264 template<class Rt2, class R, class T,
0265     class B1, class B2, class B3, class B4, class B5,
0266     class A1, class A2, class A3, class A4, class A5, class A6,
0267     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0268     auto
0269     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
0270     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 ) )
0271 {
0272     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6 );
0273 }
0274
0275 // 6
0276
0277 template<class R, class T,
0278     class B1, class B2, class B3, class B4, class B5, class B6,
0279     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
0280     auto
0281     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
0282     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 ) )
0283 {
0284     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
0285 }
0286
0287 template<class R, class T,
0288     class B1, class B2, class B3, class B4, class B5, class B6,
0289     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
0290     auto
0291     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
0292     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 ) )
0293 {
0294     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
0295 }
0296
0297 template<class Rt2, class R, class T,
0298     class B1, class B2, class B3, class B4, class B5, class B6,
0299     class A1, class A2, class A3, class A4, class A5, class A6, class A7,
0300     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0301     auto
0302     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
0303     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 ) )
0304 {
0305     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
0306 }
0307
0308 template<class Rt2, class R, class T,
0309     class B1, class B2, class B3, class B4, class B5, class B6,
0310     class A1, class A2, class A3, class A4, class A5, class A6, class A7,
0311     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0312     auto
0313     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
0314     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 ) )
0315 {
0316     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7 );
0317 }
0318
0319 // 7
0320
0321 template<class R, class T,
0322     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
0323     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
0324     auto
0325     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
0326     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 ) )
0327 {
0328     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
0329 }
0330
0331 template<class R, class T,
0332     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
0333     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
0334     auto
0335     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
0336     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 ) )
0337 {
0338     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
0339 }
0340
0341 template<class Rt2, class R, class T,
0342     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
0343     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8,
0344     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0345     auto
0346     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
0347     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 ) )
0348 {
0349     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
0350 }
0351
0352 template<class Rt2, class R, class T,
0353     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
0354     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8,
0355     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0356     auto
0357     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
0358     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 ) )
0359 {
0360     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8 );
0361 }
0362
0363 // 8
0364
0365 template<class R, class T,
0366     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
0367     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
0368     auto
0369     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
0370     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 ) )
0371 {
0372     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
0373 }
0374
0375 template<class R, class T,
0376     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
0377     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
0378     auto
0379     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
0380     -> decltype( boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 ) )
0381 {
0382     return boost::BOOST_BIND( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
0383 }
0384
0385 template<class Rt2, class R, class T,
0386     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
0387     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9,
0388     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0389     auto
0390     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
0391     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 ) )
0392 {
0393     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
0394 }
0395
0396 template<class Rt2, class R, class T,
0397     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
0398     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9,
0399     class En = typename std::enable_if< !std::is_same<Rt2, R>::value >::type>
0400     auto
0401     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
0402     -> decltype( boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 ) )
0403 {
0404     return boost::BOOST_BIND<Rt2>( boost::mem_fn( f ), a1, a2, a3, a4, a5, a6, a7, a8, a9 );
0405 }