1 #ifndef BOOST_BIND_BIND_HPP_INCLUDED
\r
2 #define BOOST_BIND_BIND_HPP_INCLUDED
\r
4 // MS compatible compilers support #pragma once
\r
6 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
\r
11 // bind.hpp - binds function objects to arguments
\r
13 // Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
\r
14 // Copyright (c) 2001 David Abrahams
\r
15 // Copyright (c) 2005 Peter Dimov
\r
17 // Distributed under the Boost Software License, Version 1.0. (See
\r
18 // accompanying file LICENSE_1_0.txt or copy at
\r
19 // http://www.boost.org/LICENSE_1_0.txt)
\r
21 // See http://www.boost.org/libs/bind/bind.html for documentation.
\r
24 #include <boost/config.hpp>
\r
25 #include <boost/ref.hpp>
\r
26 #include <boost/mem_fn.hpp>
\r
27 #include <boost/type.hpp>
\r
28 #include <boost/is_placeholder.hpp>
\r
29 #include <boost/bind/arg.hpp>
\r
30 #include <boost/detail/workaround.hpp>
\r
31 #include <boost/visit_each.hpp>
\r
33 // Borland-specific bug, visit_each() silently fails to produce code
\r
35 #if defined(__BORLANDC__)
\r
36 # define BOOST_BIND_VISIT_EACH boost::visit_each
\r
38 # define BOOST_BIND_VISIT_EACH visit_each
\r
41 #include <boost/bind/storage.hpp>
\r
44 # pragma warning(push)
\r
45 # pragma warning(disable: 4512) // assignment operator could not be generated
\r
51 template<class T> class weak_ptr;
\r
53 namespace _bi // implementation details
\r
58 template<class R, class F> struct result_traits
\r
63 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
\r
65 struct unspecified {};
\r
67 template<class F> struct result_traits<unspecified, F>
\r
69 typedef typename F::result_type type;
\r
72 template<class F> struct result_traits< unspecified, reference_wrapper<F> >
\r
74 typedef typename F::result_type type;
\r
81 template<class T> bool ref_compare( T const & a, T const & b, long )
\r
86 template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
\r
91 template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
\r
96 template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
\r
98 return a.get_pointer() == b.get_pointer();
\r
101 // bind_t forward declaration for listN
\r
103 template<class R, class F, class L> class bind_t;
\r
105 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 )
\r
107 return a.compare( b );
\r
112 template<class T> class value
\r
116 value(T const & t): t_(t) {}
\r
118 T & get() { return t_; }
\r
119 T const & get() const { return t_; }
\r
121 bool operator==(value const & rhs) const
\r
123 return t_ == rhs.t_;
\r
131 // ref_compare for weak_ptr
\r
133 template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
\r
135 return !(a.get() < b.get()) && !(b.get() < a.get());
\r
140 template<class T> class type {};
\r
144 template<class F> struct unwrapper
\r
146 static inline F & unwrap( F & f, long )
\r
151 template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
\r
156 template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
\r
158 return _mfi::dm<R, T>( pm );
\r
170 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
\r
172 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
\r
174 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
176 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); }
\r
178 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); }
\r
180 template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
\r
182 return unwrapper<F>::unwrap(f, 0)();
\r
185 template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
\r
187 return unwrapper<F const>::unwrap(f, 0)();
\r
190 template<class F, class A> void operator()(type<void>, F & f, A &, int)
\r
192 unwrapper<F>::unwrap(f, 0)();
\r
195 template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
\r
197 unwrapper<F const>::unwrap(f, 0)();
\r
200 template<class V> void accept(V &) const
\r
204 bool operator==(list0 const &) const
\r
210 template< class A1 > class list1: private storage1< A1 >
\r
214 typedef storage1< A1 > base_type;
\r
218 explicit list1( A1 a1 ): base_type( a1 ) {}
\r
220 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
\r
222 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
\r
224 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
\r
226 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
\r
228 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
230 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); }
\r
232 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); }
\r
234 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
\r
236 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
\r
239 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
\r
241 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
\r
244 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
\r
246 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
\r
249 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
\r
251 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
\r
254 template<class V> void accept(V & v) const
\r
256 base_type::accept(v);
\r
259 bool operator==(list1 const & rhs) const
\r
261 return ref_compare(base_type::a1_, rhs.a1_, 0);
\r
265 struct logical_and;
\r
268 template< class A1, class A2 > class list2: private storage2< A1, A2 >
\r
272 typedef storage2< A1, A2 > base_type;
\r
276 list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
\r
278 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
\r
279 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
\r
281 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
\r
282 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
\r
284 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
\r
286 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
\r
288 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
290 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); }
\r
292 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); }
\r
294 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
\r
296 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
\r
299 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
\r
301 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
\r
304 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
\r
306 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
\r
309 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
\r
311 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
\r
314 template<class A> bool operator()( type<bool>, logical_and & /*f*/, A & a, int )
\r
316 return a[ base_type::a1_ ] && a[ base_type::a2_ ];
\r
319 template<class A> bool operator()( type<bool>, logical_and const & /*f*/, A & a, int ) const
\r
321 return a[ base_type::a1_ ] && a[ base_type::a2_ ];
\r
324 template<class A> bool operator()( type<bool>, logical_or & /*f*/, A & a, int )
\r
326 return a[ base_type::a1_ ] || a[ base_type::a2_ ];
\r
329 template<class A> bool operator()( type<bool>, logical_or const & /*f*/, A & a, int ) const
\r
331 return a[ base_type::a1_ ] || a[ base_type::a2_ ];
\r
334 template<class V> void accept(V & v) const
\r
336 base_type::accept(v);
\r
339 bool operator==(list2 const & rhs) const
\r
341 return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
\r
345 template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
\r
349 typedef storage3< A1, A2, A3 > base_type;
\r
353 list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
\r
355 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
\r
356 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
\r
357 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
\r
359 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
\r
360 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
\r
361 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
\r
363 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
\r
365 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
\r
367 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
369 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); }
\r
371 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); }
\r
373 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
\r
375 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
\r
378 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
\r
380 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
\r
383 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
\r
385 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
\r
388 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
\r
390 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
\r
393 template<class V> void accept(V & v) const
\r
395 base_type::accept(v);
\r
398 bool operator==(list3 const & rhs) const
\r
402 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
\r
403 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
\r
404 ref_compare( base_type::a3_, rhs.a3_, 0 );
\r
408 template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
\r
412 typedef storage4< A1, A2, A3, A4 > base_type;
\r
416 list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
\r
418 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
\r
419 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
\r
420 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
\r
421 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
\r
423 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
\r
424 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
\r
425 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
\r
426 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
\r
428 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
\r
430 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
\r
432 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
434 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); }
\r
436 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); }
\r
438 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
\r
440 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
\r
443 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
\r
445 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
\r
448 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
\r
450 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
\r
453 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
\r
455 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
\r
458 template<class V> void accept(V & v) const
\r
460 base_type::accept(v);
\r
463 bool operator==(list4 const & rhs) const
\r
467 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
\r
468 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
\r
469 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
\r
470 ref_compare( base_type::a4_, rhs.a4_, 0 );
\r
474 template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
\r
478 typedef storage5< A1, A2, A3, A4, A5 > base_type;
\r
482 list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
\r
484 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
\r
485 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
\r
486 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
\r
487 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
\r
488 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
\r
490 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
\r
491 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
\r
492 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
\r
493 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
\r
494 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
\r
496 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
\r
498 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
\r
500 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
502 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); }
\r
504 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); }
\r
506 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
\r
508 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_]);
\r
511 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
\r
513 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_]);
\r
516 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
\r
518 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_]);
\r
521 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
\r
523 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_]);
\r
526 template<class V> void accept(V & v) const
\r
528 base_type::accept(v);
\r
531 bool operator==(list5 const & rhs) const
\r
535 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
\r
536 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
\r
537 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
\r
538 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
\r
539 ref_compare( base_type::a5_, rhs.a5_, 0 );
\r
543 template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
\r
547 typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
\r
551 list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
\r
553 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
\r
554 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
\r
555 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
\r
556 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
\r
557 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
\r
558 A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
\r
560 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
\r
561 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
\r
562 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
\r
563 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
\r
564 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
\r
565 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
\r
567 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
\r
569 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
\r
571 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
573 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); }
\r
575 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); }
\r
577 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
\r
579 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_]);
\r
582 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
\r
584 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_]);
\r
587 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
\r
589 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_]);
\r
592 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
\r
594 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_]);
\r
597 template<class V> void accept(V & v) const
\r
599 base_type::accept(v);
\r
602 bool operator==(list6 const & rhs) const
\r
606 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
\r
607 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
\r
608 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
\r
609 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
\r
610 ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
\r
611 ref_compare( base_type::a6_, rhs.a6_, 0 );
\r
615 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 >
\r
619 typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
\r
623 list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
\r
625 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
\r
626 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
\r
627 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
\r
628 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
\r
629 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
\r
630 A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
\r
631 A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
\r
633 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
\r
634 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
\r
635 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
\r
636 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
\r
637 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
\r
638 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
\r
639 A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
\r
641 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
\r
643 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
\r
645 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
647 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); }
\r
649 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); }
\r
651 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
\r
653 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_]);
\r
656 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
\r
658 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_]);
\r
661 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
\r
663 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_]);
\r
666 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
\r
668 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_]);
\r
671 template<class V> void accept(V & v) const
\r
673 base_type::accept(v);
\r
676 bool operator==(list7 const & rhs) const
\r
680 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
\r
681 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
\r
682 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
\r
683 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
\r
684 ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
\r
685 ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
\r
686 ref_compare( base_type::a7_, rhs.a7_, 0 );
\r
690 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 >
\r
694 typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
\r
698 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 ) {}
\r
700 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
\r
701 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
\r
702 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
\r
703 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
\r
704 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
\r
705 A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
\r
706 A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
\r
707 A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
\r
709 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
\r
710 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
\r
711 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
\r
712 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
\r
713 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
\r
714 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
\r
715 A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
\r
716 A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
\r
718 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
\r
720 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
\r
722 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
724 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); }
\r
726 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); }
\r
728 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
\r
730 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_]);
\r
733 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
\r
735 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_]);
\r
738 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
\r
740 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_]);
\r
743 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
\r
745 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_]);
\r
748 template<class V> void accept(V & v) const
\r
750 base_type::accept(v);
\r
753 bool operator==(list8 const & rhs) const
\r
757 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
\r
758 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
\r
759 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
\r
760 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
\r
761 ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
\r
762 ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
\r
763 ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
\r
764 ref_compare( base_type::a8_, rhs.a8_, 0 );
\r
768 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 >
\r
772 typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
\r
776 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 ) {}
\r
778 A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
\r
779 A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
\r
780 A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
\r
781 A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
\r
782 A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
\r
783 A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
\r
784 A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
\r
785 A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
\r
786 A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
\r
788 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
\r
789 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
\r
790 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
\r
791 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
\r
792 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
\r
793 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
\r
794 A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
\r
795 A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
\r
796 A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
\r
798 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
\r
800 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
\r
802 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
\r
804 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); }
\r
806 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); }
\r
808 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
\r
810 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_]);
\r
813 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
\r
815 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_]);
\r
818 template<class F, class A> void operator()(type<void>, F & f, A & a, int)
\r
820 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_]);
\r
823 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
\r
825 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_]);
\r
828 template<class V> void accept(V & v) const
\r
830 base_type::accept(v);
\r
833 bool operator==(list9 const & rhs) const
\r
837 ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
\r
838 ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
\r
839 ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
\r
840 ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
\r
841 ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
\r
842 ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
\r
843 ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
\r
844 ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
\r
845 ref_compare( base_type::a9_, rhs.a9_, 0 );
\r
851 #ifndef BOOST_NO_VOID_RETURNS
\r
853 template<class R, class F, class L> class bind_t
\r
857 typedef bind_t this_type;
\r
859 bind_t(F f, L const & l): f_(f), l_(l) {}
\r
861 #define BOOST_BIND_RETURN return
\r
862 #include <boost/bind/bind_template.hpp>
\r
863 #undef BOOST_BIND_RETURN
\r
869 template<class R> struct bind_t_generator
\r
872 template<class F, class L> class implementation
\r
876 typedef implementation this_type;
\r
878 implementation(F f, L const & l): f_(f), l_(l) {}
\r
880 #define BOOST_BIND_RETURN return
\r
881 #include <boost/bind/bind_template.hpp>
\r
882 #undef BOOST_BIND_RETURN
\r
888 template<> struct bind_t_generator<void>
\r
891 template<class F, class L> class implementation
\r
899 typedef implementation this_type;
\r
901 implementation(F f, L const & l): f_(f), l_(l) {}
\r
903 #define BOOST_BIND_RETURN
\r
904 #include <boost/bind/bind_template.hpp>
\r
905 #undef BOOST_BIND_RETURN
\r
911 template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>
\r
915 bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}
\r
923 #ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
\r
925 // put overloads in _bi, rely on ADL
\r
927 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
\r
929 template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
\r
931 return a.compare(b);
\r
936 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 )
\r
938 return a.compare(b);
\r
941 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
\r
943 #else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
\r
945 // put overloads in boost
\r
949 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
\r
951 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 )
\r
953 return a.compare(b);
\r
958 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 )
\r
960 return a.compare(b);
\r
963 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
\r
968 #endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
\r
972 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
\r
974 #if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x582) )
\r
976 template<class T> struct add_value
\r
978 typedef _bi::value<T> type;
\r
983 template< class T, int I > struct add_value_2
\r
985 typedef boost::arg<I> type;
\r
988 template< class T > struct add_value_2< T, 0 >
\r
990 typedef _bi::value< T > type;
\r
993 template<class T> struct add_value
\r
995 typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
\r
1000 template<class T> struct add_value< value<T> >
\r
1002 typedef _bi::value<T> type;
\r
1005 template<class T> struct add_value< reference_wrapper<T> >
\r
1007 typedef reference_wrapper<T> type;
\r
1010 template<int I> struct add_value< arg<I> >
\r
1012 typedef boost::arg<I> type;
\r
1015 template<int I> struct add_value< arg<I> (*) () >
\r
1017 typedef boost::arg<I> (*type) ();
\r
1020 template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
\r
1022 typedef bind_t<R, F, L> type;
\r
1027 template<int I> struct _avt_0;
\r
1029 template<> struct _avt_0<1>
\r
1031 template<class T> struct inner
\r
1037 template<> struct _avt_0<2>
\r
1039 template<class T> struct inner
\r
1041 typedef value<T> type;
\r
1045 typedef char (&_avt_r1) [1];
\r
1046 typedef char (&_avt_r2) [2];
\r
1048 template<class T> _avt_r1 _avt_f(value<T>);
\r
1049 template<class T> _avt_r1 _avt_f(reference_wrapper<T>);
\r
1050 template<int I> _avt_r1 _avt_f(arg<I>);
\r
1051 template<int I> _avt_r1 _avt_f(arg<I> (*) ());
\r
1052 template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>);
\r
1054 _avt_r2 _avt_f(...);
\r
1056 template<class T> struct add_value
\r
1059 typedef typename _avt_0<sizeof(_avt_f(t()))>::template inner<T>::type type;
\r
1066 template<class A1> struct list_av_1
\r
1068 typedef typename add_value<A1>::type B1;
\r
1069 typedef list1<B1> type;
\r
1072 template<class A1, class A2> struct list_av_2
\r
1074 typedef typename add_value<A1>::type B1;
\r
1075 typedef typename add_value<A2>::type B2;
\r
1076 typedef list2<B1, B2> type;
\r
1079 template<class A1, class A2, class A3> struct list_av_3
\r
1081 typedef typename add_value<A1>::type B1;
\r
1082 typedef typename add_value<A2>::type B2;
\r
1083 typedef typename add_value<A3>::type B3;
\r
1084 typedef list3<B1, B2, B3> type;
\r
1087 template<class A1, class A2, class A3, class A4> struct list_av_4
\r
1089 typedef typename add_value<A1>::type B1;
\r
1090 typedef typename add_value<A2>::type B2;
\r
1091 typedef typename add_value<A3>::type B3;
\r
1092 typedef typename add_value<A4>::type B4;
\r
1093 typedef list4<B1, B2, B3, B4> type;
\r
1096 template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
\r
1098 typedef typename add_value<A1>::type B1;
\r
1099 typedef typename add_value<A2>::type B2;
\r
1100 typedef typename add_value<A3>::type B3;
\r
1101 typedef typename add_value<A4>::type B4;
\r
1102 typedef typename add_value<A5>::type B5;
\r
1103 typedef list5<B1, B2, B3, B4, B5> type;
\r
1106 template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
\r
1108 typedef typename add_value<A1>::type B1;
\r
1109 typedef typename add_value<A2>::type B2;
\r
1110 typedef typename add_value<A3>::type B3;
\r
1111 typedef typename add_value<A4>::type B4;
\r
1112 typedef typename add_value<A5>::type B5;
\r
1113 typedef typename add_value<A6>::type B6;
\r
1114 typedef list6<B1, B2, B3, B4, B5, B6> type;
\r
1117 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
\r
1119 typedef typename add_value<A1>::type B1;
\r
1120 typedef typename add_value<A2>::type B2;
\r
1121 typedef typename add_value<A3>::type B3;
\r
1122 typedef typename add_value<A4>::type B4;
\r
1123 typedef typename add_value<A5>::type B5;
\r
1124 typedef typename add_value<A6>::type B6;
\r
1125 typedef typename add_value<A7>::type B7;
\r
1126 typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
\r
1129 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
\r
1131 typedef typename add_value<A1>::type B1;
\r
1132 typedef typename add_value<A2>::type B2;
\r
1133 typedef typename add_value<A3>::type B3;
\r
1134 typedef typename add_value<A4>::type B4;
\r
1135 typedef typename add_value<A5>::type B5;
\r
1136 typedef typename add_value<A6>::type B6;
\r
1137 typedef typename add_value<A7>::type B7;
\r
1138 typedef typename add_value<A8>::type B8;
\r
1139 typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
\r
1142 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
\r
1144 typedef typename add_value<A1>::type B1;
\r
1145 typedef typename add_value<A2>::type B2;
\r
1146 typedef typename add_value<A3>::type B3;
\r
1147 typedef typename add_value<A4>::type B4;
\r
1148 typedef typename add_value<A5>::type B5;
\r
1149 typedef typename add_value<A6>::type B6;
\r
1150 typedef typename add_value<A7>::type B7;
\r
1151 typedef typename add_value<A8>::type B8;
\r
1152 typedef typename add_value<A9>::type B9;
\r
1153 typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
\r
1158 struct logical_not
\r
1160 template<class V> bool operator()(V const & v) const { return !v; }
\r
1163 template<class R, class F, class L>
\r
1164 bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
\r
1165 operator! (bind_t<R, F, L> const & f)
\r
1167 typedef list1< bind_t<R, F, L> > list_type;
\r
1168 return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
\r
1171 // relational operators
\r
1173 #define BOOST_BIND_OPERATOR( op, name ) \
\r
1177 template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } \
\r
1180 template<class R, class F, class L, class A2> \
\r
1181 bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > \
\r
1182 operator op (bind_t<R, F, L> const & f, A2 a2) \
\r
1184 typedef typename add_value<A2>::type B2; \
\r
1185 typedef list2< bind_t<R, F, L>, B2> list_type; \
\r
1186 return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); \
\r
1189 BOOST_BIND_OPERATOR( ==, equal )
\r
1190 BOOST_BIND_OPERATOR( !=, not_equal )
\r
1192 BOOST_BIND_OPERATOR( <, less )
\r
1193 BOOST_BIND_OPERATOR( <=, less_equal )
\r
1195 BOOST_BIND_OPERATOR( >, greater )
\r
1196 BOOST_BIND_OPERATOR( >=, greater_equal )
\r
1198 BOOST_BIND_OPERATOR( &&, logical_and )
\r
1199 BOOST_BIND_OPERATOR( ||, logical_or )
\r
1201 #undef BOOST_BIND_OPERATOR
\r
1203 #if defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3)
\r
1205 // resolve ambiguity with rel_ops
\r
1207 #define BOOST_BIND_OPERATOR( op, name ) \
\r
1209 template<class R, class F, class L> \
\r
1210 bind_t< bool, name, list2< bind_t<R, F, L>, bind_t<R, F, L> > > \
\r
1211 operator op (bind_t<R, F, L> const & f, bind_t<R, F, L> const & g) \
\r
1213 typedef list2< bind_t<R, F, L>, bind_t<R, F, L> > list_type; \
\r
1214 return bind_t<bool, name, list_type> ( name(), list_type(f, g) ); \
\r
1217 BOOST_BIND_OPERATOR( !=, not_equal )
\r
1218 BOOST_BIND_OPERATOR( <=, less_equal )
\r
1219 BOOST_BIND_OPERATOR( >, greater )
\r
1220 BOOST_BIND_OPERATOR( >=, greater_equal )
\r
1224 // visit_each, ADL
\r
1226 #if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \
\r
1227 && !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
\r
1229 template<class V, class T> void visit_each( V & v, value<T> const & t, int )
\r
1231 using boost::visit_each;
\r
1232 BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
\r
1235 template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
\r
1242 } // namespace _bi
\r
1244 // visit_each, no ADL
\r
1246 #if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \
\r
1247 || (defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
\r
1249 template<class V, class T> void visit_each( V & v, _bi::value<T> const & t, int )
\r
1251 BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
\r
1254 template<class V, class R, class F, class L> void visit_each( V & v, _bi::bind_t<R, F, L> const & t, int )
\r
1261 // is_bind_expression
\r
1263 template< class T > struct is_bind_expression
\r
1265 enum _vt { value = 0 };
\r
1268 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
\r
1270 template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
\r
1272 enum _vt { value = 1 };
\r
1279 #ifndef BOOST_BIND
\r
1280 #define BOOST_BIND bind
\r
1283 // generic function objects
\r
1285 template<class R, class F>
\r
1286 _bi::bind_t<R, F, _bi::list0>
\r
1289 typedef _bi::list0 list_type;
\r
1290 return _bi::bind_t<R, F, list_type> (f, list_type());
\r
1293 template<class R, class F, class A1>
\r
1294 _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
\r
1295 BOOST_BIND(F f, A1 a1)
\r
1297 typedef typename _bi::list_av_1<A1>::type list_type;
\r
1298 return _bi::bind_t<R, F, list_type> (f, list_type(a1));
\r
1301 template<class R, class F, class A1, class A2>
\r
1302 _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
\r
1303 BOOST_BIND(F f, A1 a1, A2 a2)
\r
1305 typedef typename _bi::list_av_2<A1, A2>::type list_type;
\r
1306 return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
\r
1309 template<class R, class F, class A1, class A2, class A3>
\r
1310 _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
\r
1311 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
\r
1313 typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
\r
1314 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
\r
1317 template<class R, class F, class A1, class A2, class A3, class A4>
\r
1318 _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
\r
1319 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
\r
1321 typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
\r
1322 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
\r
1325 template<class R, class F, class A1, class A2, class A3, class A4, class A5>
\r
1326 _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
\r
1327 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
\r
1329 typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
\r
1330 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
\r
1333 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
\r
1334 _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
\r
1335 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
\r
1337 typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
\r
1338 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
\r
1341 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
\r
1342 _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
\r
1343 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
\r
1345 typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
\r
1346 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
\r
1349 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
\r
1350 _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
\r
1351 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
\r
1353 typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
\r
1354 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
\r
1357 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
\r
1358 _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
\r
1359 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
\r
1361 typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
\r
1362 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
\r
1365 // generic function objects, alternative syntax
\r
1367 template<class R, class F>
\r
1368 _bi::bind_t<R, F, _bi::list0>
\r
1369 BOOST_BIND(boost::type<R>, F f)
\r
1371 typedef _bi::list0 list_type;
\r
1372 return _bi::bind_t<R, F, list_type> (f, list_type());
\r
1375 template<class R, class F, class A1>
\r
1376 _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
\r
1377 BOOST_BIND(boost::type<R>, F f, A1 a1)
\r
1379 typedef typename _bi::list_av_1<A1>::type list_type;
\r
1380 return _bi::bind_t<R, F, list_type> (f, list_type(a1));
\r
1383 template<class R, class F, class A1, class A2>
\r
1384 _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
\r
1385 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2)
\r
1387 typedef typename _bi::list_av_2<A1, A2>::type list_type;
\r
1388 return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
\r
1391 template<class R, class F, class A1, class A2, class A3>
\r
1392 _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
\r
1393 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
\r
1395 typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
\r
1396 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
\r
1399 template<class R, class F, class A1, class A2, class A3, class A4>
\r
1400 _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
\r
1401 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
\r
1403 typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
\r
1404 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
\r
1407 template<class R, class F, class A1, class A2, class A3, class A4, class A5>
\r
1408 _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
\r
1409 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
\r
1411 typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
\r
1412 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
\r
1415 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
\r
1416 _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
\r
1417 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
\r
1419 typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
\r
1420 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
\r
1423 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
\r
1424 _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
\r
1425 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
\r
1427 typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
\r
1428 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
\r
1431 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
\r
1432 _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
\r
1433 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
\r
1435 typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
\r
1436 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
\r
1439 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
\r
1440 _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
\r
1441 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)
\r
1443 typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
\r
1444 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
\r
1447 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
\r
1449 // adaptable function objects
\r
1452 _bi::bind_t<_bi::unspecified, F, _bi::list0>
\r
1455 typedef _bi::list0 list_type;
\r
1456 return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
\r
1459 template<class F, class A1>
\r
1460 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
\r
1461 BOOST_BIND(F f, A1 a1)
\r
1463 typedef typename _bi::list_av_1<A1>::type list_type;
\r
1464 return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
\r
1467 template<class F, class A1, class A2>
\r
1468 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
\r
1469 BOOST_BIND(F f, A1 a1, A2 a2)
\r
1471 typedef typename _bi::list_av_2<A1, A2>::type list_type;
\r
1472 return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
\r
1475 template<class F, class A1, class A2, class A3>
\r
1476 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
\r
1477 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
\r
1479 typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
\r
1480 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
\r
1483 template<class F, class A1, class A2, class A3, class A4>
\r
1484 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
\r
1485 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
\r
1487 typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
\r
1488 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
\r
1491 template<class F, class A1, class A2, class A3, class A4, class A5>
\r
1492 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
\r
1493 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
\r
1495 typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
\r
1496 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
\r
1499 template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
\r
1500 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
\r
1501 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
\r
1503 typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
\r
1504 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
\r
1507 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
\r
1508 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
\r
1509 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
\r
1511 typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
\r
1512 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
\r
1515 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
\r
1516 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
\r
1517 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
\r
1519 typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
\r
1520 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
\r
1523 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
\r
1524 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
\r
1525 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
\r
1527 typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
\r
1528 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
\r
1531 #endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
\r
1533 // function pointers
\r
1535 #define BOOST_BIND_CC
\r
1536 #define BOOST_BIND_ST
\r
1538 #include <boost/bind/bind_cc.hpp>
\r
1540 #undef BOOST_BIND_CC
\r
1541 #undef BOOST_BIND_ST
\r
1543 #ifdef BOOST_BIND_ENABLE_STDCALL
\r
1545 #define BOOST_BIND_CC __stdcall
\r
1546 #define BOOST_BIND_ST
\r
1548 #include <boost/bind/bind_cc.hpp>
\r
1550 #undef BOOST_BIND_CC
\r
1551 #undef BOOST_BIND_ST
\r
1555 #ifdef BOOST_BIND_ENABLE_FASTCALL
\r
1557 #define BOOST_BIND_CC __fastcall
\r
1558 #define BOOST_BIND_ST
\r
1560 #include <boost/bind/bind_cc.hpp>
\r
1562 #undef BOOST_BIND_CC
\r
1563 #undef BOOST_BIND_ST
\r
1567 #ifdef BOOST_BIND_ENABLE_PASCAL
\r
1569 #define BOOST_BIND_ST pascal
\r
1570 #define BOOST_BIND_CC
\r
1572 #include <boost/bind/bind_cc.hpp>
\r
1574 #undef BOOST_BIND_ST
\r
1575 #undef BOOST_BIND_CC
\r
1579 // member function pointers
\r
1581 #define BOOST_BIND_MF_NAME(X) X
\r
1582 #define BOOST_BIND_MF_CC
\r
1584 #include <boost/bind/bind_mf_cc.hpp>
\r
1585 #include <boost/bind/bind_mf2_cc.hpp>
\r
1587 #undef BOOST_BIND_MF_NAME
\r
1588 #undef BOOST_BIND_MF_CC
\r
1590 #ifdef BOOST_MEM_FN_ENABLE_CDECL
\r
1592 #define BOOST_BIND_MF_NAME(X) X##_cdecl
\r
1593 #define BOOST_BIND_MF_CC __cdecl
\r
1595 #include <boost/bind/bind_mf_cc.hpp>
\r
1596 #include <boost/bind/bind_mf2_cc.hpp>
\r
1598 #undef BOOST_BIND_MF_NAME
\r
1599 #undef BOOST_BIND_MF_CC
\r
1603 #ifdef BOOST_MEM_FN_ENABLE_STDCALL
\r
1605 #define BOOST_BIND_MF_NAME(X) X##_stdcall
\r
1606 #define BOOST_BIND_MF_CC __stdcall
\r
1608 #include <boost/bind/bind_mf_cc.hpp>
\r
1609 #include <boost/bind/bind_mf2_cc.hpp>
\r
1611 #undef BOOST_BIND_MF_NAME
\r
1612 #undef BOOST_BIND_MF_CC
\r
1616 #ifdef BOOST_MEM_FN_ENABLE_FASTCALL
\r
1618 #define BOOST_BIND_MF_NAME(X) X##_fastcall
\r
1619 #define BOOST_BIND_MF_CC __fastcall
\r
1621 #include <boost/bind/bind_mf_cc.hpp>
\r
1622 #include <boost/bind/bind_mf2_cc.hpp>
\r
1624 #undef BOOST_BIND_MF_NAME
\r
1625 #undef BOOST_BIND_MF_CC
\r
1629 // data member pointers
\r
1631 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
\r
1632 || ( defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, <= 0x610 ) )
\r
1634 template<class R, class T, class A1>
\r
1635 _bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
\r
1636 BOOST_BIND(R T::*f, A1 a1)
\r
1638 typedef _mfi::dm<R, T> F;
\r
1639 typedef typename _bi::list_av_1<A1>::type list_type;
\r
1640 return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) );
\r
1648 template< class Pm, int I > struct add_cref;
\r
1650 template< class M, class T > struct add_cref< M T::*, 0 >
\r
1655 template< class M, class T > struct add_cref< M T::*, 1 >
\r
1657 typedef M const & type;
\r
1660 template< class R, class T > struct add_cref< R (T::*) (), 1 >
\r
1662 typedef void type;
\r
1665 #if !( defined(__IBMCPP__) && BOOST_WORKAROUND( __IBMCPP__, BOOST_TESTED_AT(600) ) )
\r
1667 template< class R, class T > struct add_cref< R (T::*) () const, 1 >
\r
1669 typedef void type;
\r
1672 #endif // __IBMCPP__
\r
1674 template<class R> struct isref
\r
1676 enum value_type { value = 0 };
\r
1679 template<class R> struct isref< R& >
\r
1681 enum value_type { value = 1 };
\r
1684 template<class R> struct isref< R* >
\r
1686 enum value_type { value = 1 };
\r
1689 template<class Pm, class A1> struct dm_result
\r
1691 typedef typename add_cref< Pm, 1 >::type type;
\r
1694 template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
\r
1696 typedef typename bind_t<R, F, L>::result_type result_type;
\r
1697 typedef typename add_cref< Pm, isref< result_type >::value >::type type;
\r
1700 } // namespace _bi
\r
1702 template< class A1, class M, class T >
\r
1705 typename _bi::dm_result< M T::*, A1 >::type,
\r
1707 typename _bi::list_av_1<A1>::type
\r
1710 BOOST_BIND( M T::*f, A1 a1 )
\r
1712 typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
\r
1713 typedef _mfi::dm<M, T> F;
\r
1714 typedef typename _bi::list_av_1<A1>::type list_type;
\r
1715 return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
\r
1720 } // namespace boost
\r
1722 #ifndef BOOST_BIND_NO_PLACEHOLDERS
\r
1724 # include <boost/bind/placeholders.hpp>
\r
1729 # pragma warning(default: 4512) // assignment operator could not be generated
\r
1730 # pragma warning(pop)
\r
1733 #endif // #ifndef BOOST_BIND_BIND_HPP_INCLUDED
\r