1 #ifndef BOOST_BIND_BIND_HPP_INCLUDED
2 #define BOOST_BIND_BIND_HPP_INCLUDED
4 // MS compatible compilers support #pragma once
6 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
11 // bind.hpp - binds function objects to arguments
13 // Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
14 // Copyright (c) 2001 David Abrahams
15 // Copyright (c) 2005 Peter Dimov
17 // Distributed under the Boost Software License, Version 1.0. (See
18 // accompanying file LICENSE_1_0.txt or copy at
19 // http://www.boost.org/LICENSE_1_0.txt)
21 // See http://www.boost.org/libs/bind/bind.html for documentation.
24 #include <boost/config.hpp>
25 #include <boost/ref.hpp>
26 #include <boost/mem_fn.hpp>
27 #include <boost/type.hpp>
28 #include <boost/is_placeholder.hpp>
29 #include <boost/bind/arg.hpp>
30 #include <boost/detail/workaround.hpp>
31 #include <boost/visit_each.hpp>
32 #include <boost/core/enable_if.hpp>
33 #include <boost/core/is_same.hpp>
35 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
36 #include <utility> // std::forward
39 // Borland-specific bug, visit_each() silently fails to produce code
41 #if defined(__BORLANDC__)
42 # define BOOST_BIND_VISIT_EACH boost::visit_each
44 # define BOOST_BIND_VISIT_EACH visit_each
47 #include <boost/bind/storage.hpp>
50 # pragma warning(push)
51 # pragma warning(disable: 4512) // assignment operator could not be generated
57 template<class T> class weak_ptr;
59 namespace _bi // implementation details
64 template<class R, class F> struct result_traits
69 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
71 struct unspecified {};
73 template<class F> struct result_traits<unspecified, F>
75 typedef typename F::result_type type;
78 template<class F> struct result_traits< unspecified, reference_wrapper<F> >
80 typedef typename F::result_type type;
87 template<class T> bool ref_compare( T const & a, T const & b, long )
92 template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
97 template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
102 template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
104 return a.get_pointer() == b.get_pointer();
107 // bind_t forward declaration for listN
109 template<class R, class F, class L> class bind_t;
111 template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
113 return a.compare( b );
118 template<class T> class value
122 value(T const & t): t_(t) {}
124 T & get() { return t_; }
125 T const & get() const { return t_; }
127 bool operator==(value const & rhs) const
137 // ref_compare for weak_ptr
139 template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
141 return !(a.get() < b.get()) && !(b.get() < a.get());
146 template<class T> class type {};
150 template<class F> struct unwrapper
152 static inline F & unwrap( F & f, long )
157 template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
162 template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
164 return _mfi::dm<R, T>( pm );
176 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
178 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
180 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
182 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
184 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
186 template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
188 return unwrapper<F>::unwrap(f, 0)();
191 template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
193 return unwrapper<F const>::unwrap(f, 0)();
196 template<class F, class A> void operator()(type<void>, F & f, A &, int)
198 unwrapper<F>::unwrap(f, 0)();
201 template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
203 unwrapper<F const>::unwrap(f, 0)();
206 template<class V> void accept(V &) const
210 bool operator==(list0 const &) const
217 // MSVC is bright enough to realise that the parameter rhs
218 // in operator==may be unused for some template argument types:
219 #pragma warning(push)
220 #pragma warning(disable:4100)
223 template< class A1 > class list1: private storage1< A1 >
227 typedef storage1< A1 > base_type;
231 explicit list1( A1 a1 ): base_type( a1 ) {}
233 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
235 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
237 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
239 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
241 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
243 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
245 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
247 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
249 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
252 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
254 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
257 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
259 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
262 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
264 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
267 template<class V> void accept(V & v) const
269 base_type::accept(v);
272 bool operator==(list1 const & rhs) const
274 return ref_compare(base_type::a1_, rhs.a1_, 0);
281 template< class A1, class A2 > class list2: private storage2< A1, A2 >
285 typedef storage2< A1, A2 > base_type;
289 list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
291 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
292 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
294 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
295 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
297 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
299 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
301 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
303 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
305 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
307 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
309 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
312 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
314 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
317 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
319 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
322 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
324 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
327 template<class A> bool operator()( type<bool>, logical_and & /*f*/, A & a, int )
329 return a[ base_type::a1_ ] && a[ base_type::a2_ ];
332 template<class A> bool operator()( type<bool>, logical_and const & /*f*/, A & a, int ) const
334 return a[ base_type::a1_ ] && a[ base_type::a2_ ];
337 template<class A> bool operator()( type<bool>, logical_or & /*f*/, A & a, int )
339 return a[ base_type::a1_ ] || a[ base_type::a2_ ];
342 template<class A> bool operator()( type<bool>, logical_or const & /*f*/, A & a, int ) const
344 return a[ base_type::a1_ ] || a[ base_type::a2_ ];
347 template<class V> void accept(V & v) const
349 base_type::accept(v);
352 bool operator==(list2 const & rhs) const
354 return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
358 template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
362 typedef storage3< A1, A2, A3 > base_type;
366 list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
368 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
369 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
370 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
372 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
373 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
374 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
376 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
378 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
380 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
382 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
384 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
386 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
388 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
391 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
393 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
396 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
398 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
401 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
403 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
406 template<class V> void accept(V & v) const
408 base_type::accept(v);
411 bool operator==(list3 const & rhs) const
415 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
416 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
417 ref_compare( base_type::a3_, rhs.a3_, 0 );
421 template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
425 typedef storage4< A1, A2, A3, A4 > base_type;
429 list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
431 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
432 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
433 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
434 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
436 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
437 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
438 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
439 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
441 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
443 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
445 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
447 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
449 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
451 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
453 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
456 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
458 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
461 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
463 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
466 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
468 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
471 template<class V> void accept(V & v) const
473 base_type::accept(v);
476 bool operator==(list4 const & rhs) const
480 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
481 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
482 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
483 ref_compare( base_type::a4_, rhs.a4_, 0 );
487 template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
491 typedef storage5< A1, A2, A3, A4, A5 > base_type;
495 list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
497 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
498 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
499 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
500 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
501 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
503 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
504 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
505 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
506 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
507 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
509 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
511 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
513 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
515 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
517 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
519 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
521 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
524 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
526 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
529 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
531 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
534 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
536 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
539 template<class V> void accept(V & v) const
541 base_type::accept(v);
544 bool operator==(list5 const & rhs) const
548 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
549 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
550 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
551 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
552 ref_compare( base_type::a5_, rhs.a5_, 0 );
556 template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
560 typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
564 list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
566 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
567 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
568 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
569 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
570 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
571 A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
573 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
574 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
575 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
576 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
577 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
578 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
580 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
582 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
584 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
586 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
588 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
590 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
592 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
595 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
597 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
600 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
602 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
605 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
607 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
610 template<class V> void accept(V & v) const
612 base_type::accept(v);
615 bool operator==(list6 const & rhs) const
619 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
620 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
621 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
622 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
623 ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
624 ref_compare( base_type::a6_, rhs.a6_, 0 );
628 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
632 typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
636 list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
638 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
639 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
640 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
641 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
642 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
643 A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
644 A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
646 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
647 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
648 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
649 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
650 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
651 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
652 A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
654 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
656 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
658 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
660 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
662 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
664 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
666 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
669 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
671 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
674 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
676 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
679 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
681 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
684 template<class V> void accept(V & v) const
686 base_type::accept(v);
689 bool operator==(list7 const & rhs) const
693 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
694 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
695 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
696 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
697 ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
698 ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
699 ref_compare( base_type::a7_, rhs.a7_, 0 );
703 template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
707 typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
711 list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
713 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
714 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
715 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
716 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
717 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
718 A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
719 A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
720 A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
722 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
723 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
724 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
725 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
726 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
727 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
728 A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
729 A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
731 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
733 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
735 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
737 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
739 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
741 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
743 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
746 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
748 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
751 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
753 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
756 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
758 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
761 template<class V> void accept(V & v) const
763 base_type::accept(v);
766 bool operator==(list8 const & rhs) const
770 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
771 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
772 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
773 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
774 ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
775 ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
776 ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
777 ref_compare( base_type::a8_, rhs.a8_, 0 );
781 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
785 typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
789 list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}
791 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
792 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
793 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
794 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
795 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
796 A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
797 A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
798 A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
799 A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
801 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
802 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
803 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
804 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
805 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
806 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
807 A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
808 A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
809 A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
811 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
813 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
815 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
817 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
819 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
821 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
823 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
826 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
828 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
831 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
833 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
836 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
838 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
841 template<class V> void accept(V & v) const
843 base_type::accept(v);
846 bool operator==(list9 const & rhs) const
850 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
851 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
852 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
853 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
854 ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
855 ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
856 ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
857 ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
858 ref_compare( base_type::a9_, rhs.a9_, 0 );
868 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
870 template< class A1 > class rrlist1
874 A1 & a1_; // not A1&& because of msvc-10.0
878 explicit rrlist1( A1 & a1 ): a1_( a1 ) {}
880 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } // not static_cast because of g++ 4.9
882 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
884 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
886 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
888 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
890 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
892 rrlist1<A1&> a( a1_ );
896 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
898 rrlist1<A1&> a( a1_ );
903 template< class A1, class A2 > class rrlist2
912 rrlist2( A1 & a1, A2 & a2 ): a1_( a1 ), a2_( a2 ) {}
914 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
915 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
917 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
918 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
920 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
922 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
924 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
926 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
928 rrlist2<A1&, A2&> a( a1_, a2_ );
932 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
934 rrlist2<A1&, A2&> a( a1_, a2_ );
939 template< class A1, class A2, class A3 > class rrlist3
949 rrlist3( A1 & a1, A2 & a2, A3 & a3 ): a1_( a1 ), a2_( a2 ), a3_( a3 ) {}
951 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
952 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
953 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
955 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
956 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
957 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
959 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
961 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
963 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
965 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
967 rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );
971 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
973 rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );
978 template< class A1, class A2, class A3, class A4 > class rrlist4
989 rrlist4( A1 & a1, A2 & a2, A3 & a3, A4 & a4 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ) {}
991 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
992 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
993 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
994 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
996 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
997 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
998 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
999 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1001 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1003 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1005 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1007 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
1009 rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ );
1013 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
1015 rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ );
1020 template< class A1, class A2, class A3, class A4, class A5 > class rrlist5
1032 rrlist5( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ) {}
1034 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
1035 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
1036 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
1037 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
1038 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
1040 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1041 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1042 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1043 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1044 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1046 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1048 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1050 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1052 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
1054 rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ );
1058 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
1060 rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ );
1065 template< class A1, class A2, class A3, class A4, class A5, class A6 > class rrlist6
1078 rrlist6( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ) {}
1080 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
1081 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
1082 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
1083 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
1084 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
1085 A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
1087 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1088 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1089 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1090 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1091 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1092 A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
1094 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1096 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1098 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1100 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
1102 rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ );
1106 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
1108 rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ );
1113 template< class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class rrlist7
1127 rrlist7( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ) {}
1129 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
1130 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
1131 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
1132 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
1133 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
1134 A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
1135 A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
1137 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1138 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1139 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1140 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1141 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1142 A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
1143 A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
1145 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1147 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1149 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1151 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
1153 rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ );
1157 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
1159 rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ );
1164 template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class rrlist8
1179 rrlist8( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ) {}
1181 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
1182 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
1183 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
1184 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
1185 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
1186 A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
1187 A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
1188 A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }
1190 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1191 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1192 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1193 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1194 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1195 A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
1196 A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
1197 A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }
1199 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1201 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1203 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1205 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
1207 rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ );
1211 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
1213 rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ );
1218 template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 > class rrlist9
1234 rrlist9( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ), a9_( a9 ) {}
1236 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
1237 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
1238 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
1239 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
1240 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
1241 A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
1242 A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
1243 A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }
1244 A9 && operator[] (boost::arg<9>) const { return std::forward<A9>( a9_ ); }
1246 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1247 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1248 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1249 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1250 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1251 A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
1252 A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
1253 A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }
1254 A9 && operator[] (boost::arg<9> (*) ()) const { return std::forward<A9>( a9_ ); }
1256 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1258 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1260 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1262 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
1264 rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ );
1268 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
1270 rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ );
1275 template<class R, class F, class L> class bind_t
1284 typedef typename result_traits<R, F>::type result_type;
1285 typedef bind_t this_type;
1287 bind_t( F f, L const & l ): f_( f ), l_( l ) {}
1291 result_type operator()()
1294 return l_( type<result_type>(), f_, a, 0 );
1297 result_type operator()() const
1300 return l_( type<result_type>(), f_, a, 0 );
1303 template<class A1> result_type operator()( A1 && a1 )
1305 rrlist1< A1 > a( a1 );
1306 return l_( type<result_type>(), f_, a, 0 );
1309 template<class A1> result_type operator()( A1 && a1 ) const
1311 rrlist1< A1 > a( a1 );
1312 return l_(type<result_type>(), f_, a, 0);
1315 template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 )
1317 rrlist2< A1, A2 > a( a1, a2 );
1318 return l_( type<result_type>(), f_, a, 0 );
1321 template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 ) const
1323 rrlist2< A1, A2 > a( a1, a2 );
1324 return l_( type<result_type>(), f_, a, 0 );
1327 template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 )
1329 rrlist3< A1, A2, A3 > a( a1, a2, a3 );
1330 return l_( type<result_type>(), f_, a, 0 );
1333 template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) const
1335 rrlist3< A1, A2, A3 > a( a1, a2, a3 );
1336 return l_( type<result_type>(), f_, a, 0 );
1339 template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
1341 rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
1342 return l_( type<result_type>(), f_, a, 0 );
1345 template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) const
1347 rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
1348 return l_( type<result_type>(), f_, a, 0 );
1351 template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
1353 rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
1354 return l_( type<result_type>(), f_, a, 0 );
1357 template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 ) const
1359 rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
1360 return l_( type<result_type>(), f_, a, 0 );
1363 template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
1365 rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
1366 return l_( type<result_type>(), f_, a, 0 );
1369 template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 ) const
1371 rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
1372 return l_( type<result_type>(), f_, a, 0 );
1375 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
1377 rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
1378 return l_( type<result_type>(), f_, a, 0 );
1381 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 ) const
1383 rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
1384 return l_( type<result_type>(), f_, a, 0 );
1387 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
1389 rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
1390 return l_( type<result_type>(), f_, a, 0 );
1393 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 ) const
1395 rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
1396 return l_( type<result_type>(), f_, a, 0 );
1399 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
1401 rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
1402 return l_( type<result_type>(), f_, a, 0 );
1405 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 ) const
1407 rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
1408 return l_( type<result_type>(), f_, a, 0 );
1413 template<class A> result_type eval( A & a )
1415 return l_( type<result_type>(), f_, a, 0 );
1418 template<class A> result_type eval( A & a ) const
1420 return l_( type<result_type>(), f_, a, 0 );
1423 template<class V> void accept( V & v ) const
1425 #if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ )
1426 using boost::visit_each;
1429 BOOST_BIND_VISIT_EACH( v, f_, 0 );
1433 bool compare( this_type const & rhs ) const
1435 return ref_compare( f_, rhs.f_, 0 ) && l_ == rhs.l_;
1439 #elif !defined( BOOST_NO_VOID_RETURNS )
1441 template<class R, class F, class L> class bind_t
1445 typedef bind_t this_type;
1447 bind_t(F f, L const & l): f_(f), l_(l) {}
1449 #define BOOST_BIND_RETURN return
1450 #include <boost/bind/bind_template.hpp>
1451 #undef BOOST_BIND_RETURN
1455 #else // no void returns
1457 template<class R> struct bind_t_generator
1460 template<class F, class L> class implementation
1464 typedef implementation this_type;
1466 implementation(F f, L const & l): f_(f), l_(l) {}
1468 #define BOOST_BIND_RETURN return
1469 #include <boost/bind/bind_template.hpp>
1470 #undef BOOST_BIND_RETURN
1476 template<> struct bind_t_generator<void>
1479 template<class F, class L> class implementation
1487 typedef implementation this_type;
1489 implementation(F f, L const & l): f_(f), l_(l) {}
1491 #define BOOST_BIND_RETURN
1492 #include <boost/bind/bind_template.hpp>
1493 #undef BOOST_BIND_RETURN
1499 template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>
1503 bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}
1511 #ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
1513 // put overloads in _bi, rely on ADL
1515 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
1517 template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
1519 return a.compare(b);
1524 template<class R, class F, class L> bool function_equal_impl( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
1526 return a.compare(b);
1529 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
1531 #else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
1533 // put overloads in boost
1537 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
1539 template<class R, class F, class L> bool function_equal( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b )
1541 return a.compare(b);
1546 template<class R, class F, class L> bool function_equal_impl( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b, int )
1548 return a.compare(b);
1551 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
1556 #endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
1560 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
1562 #if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x582) )
1564 template<class T> struct add_value
1566 typedef _bi::value<T> type;
1571 template< class T, int I > struct add_value_2
1573 typedef boost::arg<I> type;
1576 template< class T > struct add_value_2< T, 0 >
1578 typedef _bi::value< T > type;
1581 template<class T> struct add_value
1583 typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
1588 template<class T> struct add_value< value<T> >
1590 typedef _bi::value<T> type;
1593 template<class T> struct add_value< reference_wrapper<T> >
1595 typedef reference_wrapper<T> type;
1598 template<int I> struct add_value< arg<I> >
1600 typedef boost::arg<I> type;
1603 template<int I> struct add_value< arg<I> (*) () >
1605 typedef boost::arg<I> (*type) ();
1608 template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
1610 typedef bind_t<R, F, L> type;
1615 template<int I> struct _avt_0;
1617 template<> struct _avt_0<1>
1619 template<class T> struct inner
1625 template<> struct _avt_0<2>
1627 template<class T> struct inner
1629 typedef value<T> type;
1633 typedef char (&_avt_r1) [1];
1634 typedef char (&_avt_r2) [2];
1636 template<class T> _avt_r1 _avt_f(value<T>);
1637 template<class T> _avt_r1 _avt_f(reference_wrapper<T>);
1638 template<int I> _avt_r1 _avt_f(arg<I>);
1639 template<int I> _avt_r1 _avt_f(arg<I> (*) ());
1640 template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>);
1642 _avt_r2 _avt_f(...);
1644 template<class T> struct add_value
1647 typedef typename _avt_0<sizeof(_avt_f(t()))>::template inner<T>::type type;
1654 template<class A1> struct list_av_1
1656 typedef typename add_value<A1>::type B1;
1657 typedef list1<B1> type;
1660 template<class A1, class A2> struct list_av_2
1662 typedef typename add_value<A1>::type B1;
1663 typedef typename add_value<A2>::type B2;
1664 typedef list2<B1, B2> type;
1667 template<class A1, class A2, class A3> struct list_av_3
1669 typedef typename add_value<A1>::type B1;
1670 typedef typename add_value<A2>::type B2;
1671 typedef typename add_value<A3>::type B3;
1672 typedef list3<B1, B2, B3> type;
1675 template<class A1, class A2, class A3, class A4> struct list_av_4
1677 typedef typename add_value<A1>::type B1;
1678 typedef typename add_value<A2>::type B2;
1679 typedef typename add_value<A3>::type B3;
1680 typedef typename add_value<A4>::type B4;
1681 typedef list4<B1, B2, B3, B4> type;
1684 template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
1686 typedef typename add_value<A1>::type B1;
1687 typedef typename add_value<A2>::type B2;
1688 typedef typename add_value<A3>::type B3;
1689 typedef typename add_value<A4>::type B4;
1690 typedef typename add_value<A5>::type B5;
1691 typedef list5<B1, B2, B3, B4, B5> type;
1694 template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
1696 typedef typename add_value<A1>::type B1;
1697 typedef typename add_value<A2>::type B2;
1698 typedef typename add_value<A3>::type B3;
1699 typedef typename add_value<A4>::type B4;
1700 typedef typename add_value<A5>::type B5;
1701 typedef typename add_value<A6>::type B6;
1702 typedef list6<B1, B2, B3, B4, B5, B6> type;
1705 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
1707 typedef typename add_value<A1>::type B1;
1708 typedef typename add_value<A2>::type B2;
1709 typedef typename add_value<A3>::type B3;
1710 typedef typename add_value<A4>::type B4;
1711 typedef typename add_value<A5>::type B5;
1712 typedef typename add_value<A6>::type B6;
1713 typedef typename add_value<A7>::type B7;
1714 typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
1717 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
1719 typedef typename add_value<A1>::type B1;
1720 typedef typename add_value<A2>::type B2;
1721 typedef typename add_value<A3>::type B3;
1722 typedef typename add_value<A4>::type B4;
1723 typedef typename add_value<A5>::type B5;
1724 typedef typename add_value<A6>::type B6;
1725 typedef typename add_value<A7>::type B7;
1726 typedef typename add_value<A8>::type B8;
1727 typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
1730 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
1732 typedef typename add_value<A1>::type B1;
1733 typedef typename add_value<A2>::type B2;
1734 typedef typename add_value<A3>::type B3;
1735 typedef typename add_value<A4>::type B4;
1736 typedef typename add_value<A5>::type B5;
1737 typedef typename add_value<A6>::type B6;
1738 typedef typename add_value<A7>::type B7;
1739 typedef typename add_value<A8>::type B8;
1740 typedef typename add_value<A9>::type B9;
1741 typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
1748 template<class V> bool operator()(V const & v) const { return !v; }
1751 template<class R, class F, class L>
1752 bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
1753 operator! (bind_t<R, F, L> const & f)
1755 typedef list1< bind_t<R, F, L> > list_type;
1756 return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
1759 // relational operators
1761 #define BOOST_BIND_OPERATOR( op, name ) \
1765 template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } \
1768 template<class R, class F, class L, class A2> \
1769 bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > \
1770 operator op (bind_t<R, F, L> const & f, A2 a2) \
1772 typedef typename add_value<A2>::type B2; \
1773 typedef list2< bind_t<R, F, L>, B2> list_type; \
1774 return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); \
1777 BOOST_BIND_OPERATOR( ==, equal )
1778 BOOST_BIND_OPERATOR( !=, not_equal )
1780 BOOST_BIND_OPERATOR( <, less )
1781 BOOST_BIND_OPERATOR( <=, less_equal )
1783 BOOST_BIND_OPERATOR( >, greater )
1784 BOOST_BIND_OPERATOR( >=, greater_equal )
1786 BOOST_BIND_OPERATOR( &&, logical_and )
1787 BOOST_BIND_OPERATOR( ||, logical_or )
1789 #undef BOOST_BIND_OPERATOR
1791 #if defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3)
1793 // resolve ambiguity with rel_ops
1795 #define BOOST_BIND_OPERATOR( op, name ) \
1797 template<class R, class F, class L> \
1798 bind_t< bool, name, list2< bind_t<R, F, L>, bind_t<R, F, L> > > \
1799 operator op (bind_t<R, F, L> const & f, bind_t<R, F, L> const & g) \
1801 typedef list2< bind_t<R, F, L>, bind_t<R, F, L> > list_type; \
1802 return bind_t<bool, name, list_type> ( name(), list_type(f, g) ); \
1805 BOOST_BIND_OPERATOR( !=, not_equal )
1806 BOOST_BIND_OPERATOR( <=, less_equal )
1807 BOOST_BIND_OPERATOR( >, greater )
1808 BOOST_BIND_OPERATOR( >=, greater_equal )
1814 #if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \
1815 && !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
1817 template<class V, class T> void visit_each( V & v, value<T> const & t, int )
1819 using boost::visit_each;
1820 BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
1823 template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
1832 // visit_each, no ADL
1834 #if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \
1835 || (defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
1837 template<class V, class T> void visit_each( V & v, _bi::value<T> const & t, int )
1839 BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
1842 template<class V, class R, class F, class L> void visit_each( V & v, _bi::bind_t<R, F, L> const & t, int )
1849 // is_bind_expression
1851 template< class T > struct is_bind_expression
1853 enum _vt { value = 0 };
1856 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
1858 template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
1860 enum _vt { value = 1 };
1868 #define BOOST_BIND bind
1871 // generic function objects
1873 template<class R, class F>
1874 _bi::bind_t<R, F, _bi::list0>
1877 typedef _bi::list0 list_type;
1878 return _bi::bind_t<R, F, list_type> (f, list_type());
1881 template<class R, class F, class A1>
1882 _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
1883 BOOST_BIND(F f, A1 a1)
1885 typedef typename _bi::list_av_1<A1>::type list_type;
1886 return _bi::bind_t<R, F, list_type> (f, list_type(a1));
1889 template<class R, class F, class A1, class A2>
1890 _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
1891 BOOST_BIND(F f, A1 a1, A2 a2)
1893 typedef typename _bi::list_av_2<A1, A2>::type list_type;
1894 return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
1897 template<class R, class F, class A1, class A2, class A3>
1898 _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
1899 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
1901 typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
1902 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
1905 template<class R, class F, class A1, class A2, class A3, class A4>
1906 _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
1907 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
1909 typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
1910 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
1913 template<class R, class F, class A1, class A2, class A3, class A4, class A5>
1914 _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
1915 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
1917 typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
1918 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
1921 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
1922 _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
1923 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
1925 typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
1926 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
1929 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1930 _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
1931 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
1933 typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
1934 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
1937 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
1938 _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
1939 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
1941 typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
1942 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
1945 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
1946 _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
1947 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
1949 typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
1950 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
1953 // generic function objects, alternative syntax
1955 template<class R, class F>
1956 _bi::bind_t<R, F, _bi::list0>
1957 BOOST_BIND(boost::type<R>, F f)
1959 typedef _bi::list0 list_type;
1960 return _bi::bind_t<R, F, list_type> (f, list_type());
1963 template<class R, class F, class A1>
1964 _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
1965 BOOST_BIND(boost::type<R>, F f, A1 a1)
1967 typedef typename _bi::list_av_1<A1>::type list_type;
1968 return _bi::bind_t<R, F, list_type> (f, list_type(a1));
1971 template<class R, class F, class A1, class A2>
1972 _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
1973 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2)
1975 typedef typename _bi::list_av_2<A1, A2>::type list_type;
1976 return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
1979 template<class R, class F, class A1, class A2, class A3>
1980 _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
1981 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
1983 typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
1984 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
1987 template<class R, class F, class A1, class A2, class A3, class A4>
1988 _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
1989 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
1991 typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
1992 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
1995 template<class R, class F, class A1, class A2, class A3, class A4, class A5>
1996 _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
1997 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
1999 typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
2000 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
2003 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
2004 _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
2005 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
2007 typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
2008 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
2011 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
2012 _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
2013 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
2015 typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
2016 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
2019 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
2020 _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
2021 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
2023 typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
2024 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
2027 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
2028 _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
2029 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
2031 typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
2032 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
2035 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
2037 // adaptable function objects
2040 _bi::bind_t<_bi::unspecified, F, _bi::list0>
2043 typedef _bi::list0 list_type;
2044 return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
2047 template<class F, class A1>
2048 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
2049 BOOST_BIND(F f, A1 a1)
2051 typedef typename _bi::list_av_1<A1>::type list_type;
2052 return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
2055 template<class F, class A1, class A2>
2056 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
2057 BOOST_BIND(F f, A1 a1, A2 a2)
2059 typedef typename _bi::list_av_2<A1, A2>::type list_type;
2060 return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
2063 template<class F, class A1, class A2, class A3>
2064 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
2065 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
2067 typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
2068 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
2071 template<class F, class A1, class A2, class A3, class A4>
2072 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
2073 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
2075 typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
2076 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
2079 template<class F, class A1, class A2, class A3, class A4, class A5>
2080 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
2081 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
2083 typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
2084 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
2087 template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
2088 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
2089 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
2091 typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
2092 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
2095 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
2096 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
2097 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
2099 typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
2100 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
2103 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
2104 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
2105 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
2107 typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
2108 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
2111 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
2112 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
2113 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
2115 typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
2116 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
2119 #endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
2121 // function pointers
2123 #define BOOST_BIND_CC
2124 #define BOOST_BIND_ST
2126 #include <boost/bind/bind_cc.hpp>
2128 #undef BOOST_BIND_CC
2129 #undef BOOST_BIND_ST
2131 #ifdef BOOST_BIND_ENABLE_STDCALL
2133 #define BOOST_BIND_CC __stdcall
2134 #define BOOST_BIND_ST
2136 #include <boost/bind/bind_cc.hpp>
2138 #undef BOOST_BIND_CC
2139 #undef BOOST_BIND_ST
2143 #ifdef BOOST_BIND_ENABLE_FASTCALL
2145 #define BOOST_BIND_CC __fastcall
2146 #define BOOST_BIND_ST
2148 #include <boost/bind/bind_cc.hpp>
2150 #undef BOOST_BIND_CC
2151 #undef BOOST_BIND_ST
2155 #ifdef BOOST_BIND_ENABLE_PASCAL
2157 #define BOOST_BIND_ST pascal
2158 #define BOOST_BIND_CC
2160 #include <boost/bind/bind_cc.hpp>
2162 #undef BOOST_BIND_ST
2163 #undef BOOST_BIND_CC
2167 // member function pointers
2169 #define BOOST_BIND_MF_NAME(X) X
2170 #define BOOST_BIND_MF_CC
2172 #include <boost/bind/bind_mf_cc.hpp>
2173 #include <boost/bind/bind_mf2_cc.hpp>
2175 #undef BOOST_BIND_MF_NAME
2176 #undef BOOST_BIND_MF_CC
2178 #ifdef BOOST_MEM_FN_ENABLE_CDECL
2180 #define BOOST_BIND_MF_NAME(X) X##_cdecl
2181 #define BOOST_BIND_MF_CC __cdecl
2183 #include <boost/bind/bind_mf_cc.hpp>
2184 #include <boost/bind/bind_mf2_cc.hpp>
2186 #undef BOOST_BIND_MF_NAME
2187 #undef BOOST_BIND_MF_CC
2191 #ifdef BOOST_MEM_FN_ENABLE_STDCALL
2193 #define BOOST_BIND_MF_NAME(X) X##_stdcall
2194 #define BOOST_BIND_MF_CC __stdcall
2196 #include <boost/bind/bind_mf_cc.hpp>
2197 #include <boost/bind/bind_mf2_cc.hpp>
2199 #undef BOOST_BIND_MF_NAME
2200 #undef BOOST_BIND_MF_CC
2204 #ifdef BOOST_MEM_FN_ENABLE_FASTCALL
2206 #define BOOST_BIND_MF_NAME(X) X##_fastcall
2207 #define BOOST_BIND_MF_CC __fastcall
2209 #include <boost/bind/bind_mf_cc.hpp>
2210 #include <boost/bind/bind_mf2_cc.hpp>
2212 #undef BOOST_BIND_MF_NAME
2213 #undef BOOST_BIND_MF_CC
2217 // data member pointers
2219 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
2220 || ( defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x620 ) ) )
2222 template<class R, class T, class A1>
2223 _bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
2224 BOOST_BIND(R T::*f, A1 a1)
2226 typedef _mfi::dm<R, T> F;
2227 typedef typename _bi::list_av_1<A1>::type list_type;
2228 return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) );
2236 template< class Pm, int I > struct add_cref;
2238 template< class M, class T > struct add_cref< M T::*, 0 >
2243 template< class M, class T > struct add_cref< M T::*, 1 >
2246 #pragma warning(push)
2247 #pragma warning(disable:4180)
2249 typedef M const & type;
2251 #pragma warning(pop)
2255 template< class R, class T > struct add_cref< R (T::*) (), 1 >
2260 #if !defined(__IBMCPP__) || __IBMCPP_FUNC_CV_TMPL_ARG_DEDUCTION
2262 template< class R, class T > struct add_cref< R (T::*) () const, 1 >
2267 #endif // __IBMCPP__
2269 template<class R> struct isref
2271 enum value_type { value = 0 };
2274 template<class R> struct isref< R& >
2276 enum value_type { value = 1 };
2279 template<class R> struct isref< R* >
2281 enum value_type { value = 1 };
2284 template<class Pm, class A1> struct dm_result
2286 typedef typename add_cref< Pm, 1 >::type type;
2289 template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
2291 typedef typename bind_t<R, F, L>::result_type result_type;
2292 typedef typename add_cref< Pm, isref< result_type >::value >::type type;
2297 template< class A1, class M, class T >
2300 typename _bi::dm_result< M T::*, A1 >::type,
2302 typename _bi::list_av_1<A1>::type
2305 BOOST_BIND( M T::*f, A1 a1 )
2307 typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
2308 typedef _mfi::dm<M, T> F;
2309 typedef typename _bi::list_av_1<A1>::type list_type;
2310 return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
2315 } // namespace boost
2317 #ifndef BOOST_BIND_NO_PLACEHOLDERS
2319 # include <boost/bind/placeholders.hpp>
2324 # pragma warning(default: 4512) // assignment operator could not be generated
2325 # pragma warning(pop)
2328 #endif // #ifndef BOOST_BIND_BIND_HPP_INCLUDED