1	#ifndef BOOST_BIND_BIND_HPP_INCLUDED
2	#define BOOST_BIND_BIND_HPP_INCLUDED
3
4	// MS compatible compilers support #pragma once
5
6	#if defined(_MSC_VER) && (_MSC_VER >= 1020)
7	# pragma once
8	#endif
9
10	//
11	// bind.hpp - binds function objects to arguments
12	//
13	// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
14	// Copyright (c) 2001 David Abrahams
15	// Copyright (c) 2005 Peter Dimov
16	//
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)
20	//
21	// See http://www.boost.org/libs/bind/bind.html for documentation.
22	//
23
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>
34
35	#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
36	#include <utility> // std::forward
37	#endif
38
39	// Borland-specific bug, visit_each() silently fails to produce code
40
41	#if defined(__BORLANDC__)
42	# define BOOST_BIND_VISIT_EACH boost::visit_each
43	#else
44	# define BOOST_BIND_VISIT_EACH visit_each
45	#endif
46
47	#include <boost/bind/storage.hpp>
48
49	#ifdef BOOST_MSVC
50	# pragma warning(push)
51	# pragma warning(disable: 4512) // assignment operator could not be generated
52	#endif
53
54	namespace boost
55	{
56
57	template<class T> class weak_ptr;
58
59	namespace _bi // implementation details
60	{
61
62	// result_traits
63
64	template<class R, class F> struct result_traits
65	{
66	typedef R type;
67	};
68
69	#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
70
71	struct unspecified {};
72
73	template<class F> struct result_traits<unspecified, F>
74	{
75	typedef typename F::result_type type;
76	};
77
78	template<class F> struct result_traits< unspecified, reference_wrapper<F> >
79	{
80	typedef typename F::result_type type;
81	};
82
83	#endif
84
85	// ref_compare
86
87	template<class T> bool ref_compare( T const & a, T const & b, long )
88	{
89	return a == b;
90	}
91
92	template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
93	{
94	return true;
95	}
96
97	template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
98	{
99	return true;
100	}
101
102	template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
103	{
104	return a.get_pointer() == b.get_pointer();
105	}
106
107	// bind_t forward declaration for listN
108
109	template<class R, class F, class L> class bind_t;
110
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 )
112	{
113	return a.compare( b );
114	}
115
116	// value
117
118	template<class T> class value
119	{
120	public:
121
122	value(T const & t): t_(t) {}
123
124	T & get() { return t_; }
125	T const & get() const { return t_; }
126
127	bool operator==(value const & rhs) const
128	{
129	return t_ == rhs.t_;
130	}
131
132	private:
133
134	T t_;
135	};
136
137	// ref_compare for weak_ptr
138
139	template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
140	{
141	return !(a.get() < b.get()) && !(b.get() < a.get());
142	}
143
144	// type
145
146	template<class T> class type {};
147
148	// unwrap
149
150	template<class F> struct unwrapper
151	{
152	static inline F & unwrap( F & f, long )
153	{
154	return f;
155	}
156
157	template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
158	{
159	return rf.get();
160	}
161
162	template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
163	{
164	return _mfi::dm<R, T>( pm );
165	}
166	};
167
168	// listN
169
170	class list0
171	{
172	public:
173
174	list0() {}
175
176	template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
177
178	template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
179
180	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
181
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); }
183
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); }
185
186	template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
187	{
188	return unwrapper<F>::unwrap(f, 0)();
189	}
190
191	template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
192	{
193	return unwrapper<F const>::unwrap(f, 0)();
194	}
195
196	template<class F, class A> void operator()(type<void>, F & f, A &, int)
197	{
198	unwrapper<F>::unwrap(f, 0)();
199	}
200
201	template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
202	{
203	unwrapper<F const>::unwrap(f, 0)();
204	}
205
206	template<class V> void accept(V &) const
207	{
208	}
209
210	bool operator==(list0 const &) const
211	{
212	return true;
213	}
214	};
215
216	#ifdef BOOST_MSVC
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)
221	#endif
222
223	template< class A1 > class list1: private storage1< A1 >
224	{
225	private:
226
227	typedef storage1< A1 > base_type;
228
229	public:
230
231	explicit list1( A1 a1 ): base_type( a1 ) {}
232
233	A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
234
235	A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
236
237	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
238
239	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
240
241	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
242
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); }
244
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); }
246
247	template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
248	{
249	return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
250	}
251
252	template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
253	{
254	return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
255	}
256
257	template<class F, class A> void operator()(type<void>, F & f, A & a, int)
258	{
259	unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
260	}
261
262	template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
263	{
264	unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
265	}
266
267	template<class V> void accept(V & v) const
268	{
269	base_type::accept(v);
270	}
271
272	bool operator==(list1 const & rhs) const
273	{
274	return ref_compare(base_type::a1_, rhs.a1_, 0);
275	}
276	};
277
278	struct logical_and;
279	struct logical_or;
280
281	template< class A1, class A2 > class list2: private storage2< A1, A2 >
282	{
283	private:
284
285	typedef storage2< A1, A2 > base_type;
286
287	public:
288
289	list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
290
291	A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
292	A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
293
294	A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
295	A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
296
297	template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
298
299	template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
300
301	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
302
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); }
304
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); }
306
307	template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
308	{
309	return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
310	}
311
312	template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
313	{
314	return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
315	}
316
317	template<class F, class A> void operator()(type<void>, F & f, A & a, int)
318	{
319	unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
320	}
321
322	template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
323	{
324	unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
325	}
326
327	template<class A> bool operator()( type<bool>, logical_and & /*f*/, A & a, int )
328	{
329	return a[ base_type::a1_ ] && a[ base_type::a2_ ];
330	}
331
332	template<class A> bool operator()( type<bool>, logical_and const & /*f*/, A & a, int ) const
333	{
334	return a[ base_type::a1_ ] && a[ base_type::a2_ ];
335	}
336
337	template<class A> bool operator()( type<bool>, logical_or & /*f*/, A & a, int )
338	{
339	return a[ base_type::a1_ ] || a[ base_type::a2_ ];
340	}
341
342	template<class A> bool operator()( type<bool>, logical_or const & /*f*/, A & a, int ) const
343	{
344	return a[ base_type::a1_ ] || a[ base_type::a2_ ];
345	}
346
347	template<class V> void accept(V & v) const
348	{
349	base_type::accept(v);
350	}
351
352	bool operator==(list2 const & rhs) const
353	{
354	return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
355	}
356	};
357
358	template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
359	{
360	private:
361
362	typedef storage3< A1, A2, A3 > base_type;
363
364	public:
365
366	list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
367
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_; }
371
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_; }
375
376	template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
377
378	template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
379
380	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
381
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); }
383
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); }
385
386	template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
387	{
388	return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
389	}
390
391	template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
392	{
393	return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
394	}
395
396	template<class F, class A> void operator()(type<void>, F & f, A & a, int)
397	{
398	unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
399	}
400
401	template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
402	{
403	unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
404	}
405
406	template<class V> void accept(V & v) const
407	{
408	base_type::accept(v);
409	}
410
411	bool operator==(list3 const & rhs) const
412	{
413	return
414
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 );
418	}
419	};
420
421	template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
422	{
423	private:
424
425	typedef storage4< A1, A2, A3, A4 > base_type;
426
427	public:
428
429	list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
430
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_; }
435
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_; }
440
441	template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
442
443	template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
444
445	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
446
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); }
448
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); }
450
451	template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
452	{
453	return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
454	}
455
456	template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
457	{
458	return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
459	}
460
461	template<class F, class A> void operator()(type<void>, F & f, A & a, int)
462	{
463	unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
464	}
465
466	template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
467	{
468	unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
469	}
470
471	template<class V> void accept(V & v) const
472	{
473	base_type::accept(v);
474	}
475
476	bool operator==(list4 const & rhs) const
477	{
478	return
479
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 );
484	}
485	};
486
487	template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
488	{
489	private:
490
491	typedef storage5< A1, A2, A3, A4, A5 > base_type;
492
493	public:
494
495	list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
496
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_; }
502
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_; }
508
509	template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
510
511	template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
512
513	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
514
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); }
516
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); }
518
519	template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
520	{
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_]);
522	}
523
524	template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
525	{
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_]);
527	}
528
529	template<class F, class A> void operator()(type<void>, F & f, A & a, int)
530	{
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_]);
532	}
533
534	template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
535	{
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_]);
537	}
538
539	template<class V> void accept(V & v) const
540	{
541	base_type::accept(v);
542	}
543
544	bool operator==(list5 const & rhs) const
545	{
546	return
547
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 );
553	}
554	};
555
556	template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
557	{
558	private:
559
560	typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
561
562	public:
563
564	list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
565
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_; }
572
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_; }
579
580	template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
581
582	template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
583
584	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
585
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); }
587
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); }
589
590	template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
591	{
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_]);
593	}
594
595	template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
596	{
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_]);
598	}
599
600	template<class F, class A> void operator()(type<void>, F & f, A & a, int)
601	{
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_]);
603	}
604
605	template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
606	{
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_]);
608	}
609
610	template<class V> void accept(V & v) const
611	{
612	base_type::accept(v);
613	}
614
615	bool operator==(list6 const & rhs) const
616	{
617	return
618
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 );
625	}
626	};
627
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 >
629	{
630	private:
631
632	typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
633
634	public:
635
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 ) {}
637
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_; }
645
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_; }
653
654	template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
655
656	template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
657
658	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
659
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); }
661
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); }
663
664	template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
665	{
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_]);
667	}
668
669	template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
670	{
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_]);
672	}
673
674	template<class F, class A> void operator()(type<void>, F & f, A & a, int)
675	{
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_]);
677	}
678
679	template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
680	{
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_]);
682	}
683
684	template<class V> void accept(V & v) const
685	{
686	base_type::accept(v);
687	}
688
689	bool operator==(list7 const & rhs) const
690	{
691	return
692
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 );
700	}
701	};
702
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 >
704	{
705	private:
706
707	typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
708
709	public:
710
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 ) {}
712
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_; }
721
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_; }
730
731	template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
732
733	template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
734
735	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
736
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); }
738
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); }
740
741	template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
742	{
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_]);
744	}
745
746	template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
747	{
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_]);
749	}
750
751	template<class F, class A> void operator()(type<void>, F & f, A & a, int)
752	{
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_]);
754	}
755
756	template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
757	{
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_]);
759	}
760
761	template<class V> void accept(V & v) const
762	{
763	base_type::accept(v);
764	}
765
766	bool operator==(list8 const & rhs) const
767	{
768	return
769
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 );
778	}
779	};
780
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 >
782	{
783	private:
784
785	typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
786
787	public:
788
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 ) {}
790
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_; }
800
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_; }
810
811	template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
812
813	template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
814
815	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
816
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); }
818
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); }
820
821	template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
822	{
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_]);
824	}
825
826	template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
827	{
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_]);
829	}
830
831	template<class F, class A> void operator()(type<void>, F & f, A & a, int)
832	{
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_]);
834	}
835
836	template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
837	{
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_]);
839	}
840
841	template<class V> void accept(V & v) const
842	{
843	base_type::accept(v);
844	}
845
846	bool operator==(list9 const & rhs) const
847	{
848	return
849
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 );
859	}
860	};
861
862	#ifdef BOOST_MSVC
863	#pragma warning(pop)
864	#endif
865
866	// bind_t
867
868	#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
869
870	template< class A1 > class rrlist1
871	{
872	private:
873
874	A1 & a1_; // not A1&& because of msvc-10.0
875
876	public:
877
878	explicit rrlist1( A1 & a1 ): a1_( a1 ) {}
879
880	A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } // not static_cast because of g++ 4.9
881
882	A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
883
884	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
885
886	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
887
888	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
889
890	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); }
891
892	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); }
893	};
894
895	template< class A1, class A2 > class rrlist2
896	{
897	private:
898
899	A1 & a1_;
900	A2 & a2_;
901
902	public:
903
904	rrlist2( A1 & a1, A2 & a2 ): a1_( a1 ), a2_( a2 ) {}
905
906	A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
907	A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
908
909	A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
910	A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
911
912	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
913
914	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
915
916	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
917
918	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); }
919
920	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); }
921	};
922
923	template< class A1, class A2, class A3 > class rrlist3
924	{
925	private:
926
927	A1 & a1_;
928	A2 & a2_;
929	A3 & a3_;
930
931	public:
932
933	rrlist3( A1 & a1, A2 & a2, A3 & a3 ): a1_( a1 ), a2_( a2 ), a3_( a3 ) {}
934
935	A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
936	A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
937	A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
938
939	A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
940	A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
941	A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
942
943	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
944
945	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
946
947	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
948
949	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); }
950
951	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); }
952	};
953
954	template< class A1, class A2, class A3, class A4 > class rrlist4
955	{
956	private:
957
958	A1 & a1_;
959	A2 & a2_;
960	A3 & a3_;
961	A4 & a4_;
962
963	public:
964
965	rrlist4( A1 & a1, A2 & a2, A3 & a3, A4 & a4 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ) {}
966
967	A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
968	A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
969	A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
970	A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
971
972	A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
973	A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
974	A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
975	A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
976
977	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
978
979	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
980
981	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
982
983	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); }
984
985	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); }
986	};
987
988	template< class A1, class A2, class A3, class A4, class A5 > class rrlist5
989	{
990	private:
991
992	A1 & a1_;
993	A2 & a2_;
994	A3 & a3_;
995	A4 & a4_;
996	A5 & a5_;
997
998	public:
999
1000	rrlist5( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ) {}
1001
1002	A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
1003	A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
1004	A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
1005	A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
1006	A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
1007
1008	A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1009	A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1010	A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1011	A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1012	A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1013
1014	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1015
1016	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1017
1018	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1019
1020	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); }
1021
1022	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); }
1023	};
1024
1025	template< class A1, class A2, class A3, class A4, class A5, class A6 > class rrlist6
1026	{
1027	private:
1028
1029	A1 & a1_;
1030	A2 & a2_;
1031	A3 & a3_;
1032	A4 & a4_;
1033	A5 & a5_;
1034	A6 & a6_;
1035
1036	public:
1037
1038	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 ) {}
1039
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_ ); }
1045	A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
1046
1047	A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1048	A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1049	A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1050	A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1051	A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1052	A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
1053
1054	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1055
1056	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1057
1058	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1059
1060	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); }
1061
1062	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); }
1063	};
1064
1065	template< class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class rrlist7
1066	{
1067	private:
1068
1069	A1 & a1_;
1070	A2 & a2_;
1071	A3 & a3_;
1072	A4 & a4_;
1073	A5 & a5_;
1074	A6 & a6_;
1075	A7 & a7_;
1076
1077	public:
1078
1079	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 ) {}
1080
1081	A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
1082	A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
1083	A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
1084	A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
1085	A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
1086	A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
1087	A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
1088
1089	A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1090	A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1091	A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1092	A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1093	A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1094	A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
1095	A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
1096
1097	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1098
1099	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1100
1101	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1102
1103	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); }
1104
1105	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); }
1106	};
1107
1108	template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class rrlist8
1109	{
1110	private:
1111
1112	A1 & a1_;
1113	A2 & a2_;
1114	A3 & a3_;
1115	A4 & a4_;
1116	A5 & a5_;
1117	A6 & a6_;
1118	A7 & a7_;
1119	A8 & a8_;
1120
1121	public:
1122
1123	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 ) {}
1124
1125	A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
1126	A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
1127	A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
1128	A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
1129	A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
1130	A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
1131	A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
1132	A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }
1133
1134	A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1135	A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1136	A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1137	A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1138	A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1139	A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
1140	A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
1141	A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }
1142
1143	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1144
1145	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1146
1147	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1148
1149	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); }
1150
1151	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); }
1152	};
1153
1154	template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 > class rrlist9
1155	{
1156	private:
1157
1158	A1 & a1_;
1159	A2 & a2_;
1160	A3 & a3_;
1161	A4 & a4_;
1162	A5 & a5_;
1163	A6 & a6_;
1164	A7 & a7_;
1165	A8 & a8_;
1166	A9 & a9_;
1167
1168	public:
1169
1170	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 ) {}
1171
1172	A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
1173	A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
1174	A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
1175	A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
1176	A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
1177	A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
1178	A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
1179	A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }
1180	A9 && operator[] (boost::arg<9>) const { return std::forward<A9>( a9_ ); }
1181
1182	A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
1183	A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
1184	A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
1185	A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
1186	A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
1187	A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
1188	A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
1189	A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }
1190	A9 && operator[] (boost::arg<9> (*) ()) const { return std::forward<A9>( a9_ ); }
1191
1192	template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
1193
1194	template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
1195
1196	template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
1197
1198	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); }
1199
1200	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); }
1201	};
1202
1203	template<class R, class F, class L> class bind_t
1204	{
1205	private:
1206
1207	F f_;
1208	L l_;
1209
1210	public:
1211
1212	typedef typename result_traits<R, F>::type result_type;
1213	typedef bind_t this_type;
1214
1215	bind_t( F f, L const & l ): f_( f ), l_( l ) {}
1216
1217	//
1218
1219	result_type operator()()
1220	{
1221	list0 a;
1222	return l_( type<result_type>(), f_, a, 0 );
1223	}
1224
1225	result_type operator()() const
1226	{
1227	list0 a;
1228	return l_( type<result_type>(), f_, a, 0 );
1229	}
1230
1231	template<class A1> result_type operator()( A1 && a1 )
1232	{
1233	rrlist1< A1 > a( a1 );
1234	return l_( type<result_type>(), f_, a, 0 );
1235	}
1236
1237	template<class A1> result_type operator()( A1 && a1 ) const
1238	{
1239	rrlist1< A1 > a( a1 );
1240	return l_(type<result_type>(), f_, a, 0);
1241	}
1242
1243	template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 )
1244	{
1245	rrlist2< A1, A2 > a( a1, a2 );
1246	return l_( type<result_type>(), f_, a, 0 );
1247	}
1248
1249	template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 ) const
1250	{
1251	rrlist2< A1, A2 > a( a1, a2 );
1252	return l_( type<result_type>(), f_, a, 0 );
1253	}
1254
1255	template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 )
1256	{
1257	rrlist3< A1, A2, A3 > a( a1, a2, a3 );
1258	return l_( type<result_type>(), f_, a, 0 );
1259	}
1260
1261	template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) const
1262	{
1263	rrlist3< A1, A2, A3 > a( a1, a2, a3 );
1264	return l_( type<result_type>(), f_, a, 0 );
1265	}
1266
1267	template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
1268	{
1269	rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
1270	return l_( type<result_type>(), f_, a, 0 );
1271	}
1272
1273	template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) const
1274	{
1275	rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
1276	return l_( type<result_type>(), f_, a, 0 );
1277	}
1278
1279	template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
1280	{
1281	rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
1282	return l_( type<result_type>(), f_, a, 0 );
1283	}
1284
1285	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
1286	{
1287	rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
1288	return l_( type<result_type>(), f_, a, 0 );
1289	}
1290
1291	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 )
1292	{
1293	rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
1294	return l_( type<result_type>(), f_, a, 0 );
1295	}
1296
1297	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
1298	{
1299	rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
1300	return l_( type<result_type>(), f_, a, 0 );
1301	}
1302
1303	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 )
1304	{
1305	rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
1306	return l_( type<result_type>(), f_, a, 0 );
1307	}
1308
1309	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
1310	{
1311	rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
1312	return l_( type<result_type>(), f_, a, 0 );
1313	}
1314
1315	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 )
1316	{
1317	rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
1318	return l_( type<result_type>(), f_, a, 0 );
1319	}
1320
1321	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
1322	{
1323	rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
1324	return l_( type<result_type>(), f_, a, 0 );
1325	}
1326
1327	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 )
1328	{
1329	rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
1330	return l_( type<result_type>(), f_, a, 0 );
1331	}
1332
1333	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
1334	{
1335	rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
1336	return l_( type<result_type>(), f_, a, 0 );
1337	}
1338
1339	//
1340
1341	template<class A> result_type eval( A & a )
1342	{
1343	return l_( type<result_type>(), f_, a, 0 );
1344	}
1345
1346	template<class A> result_type eval( A & a ) const
1347	{
1348	return l_( type<result_type>(), f_, a, 0 );
1349	}
1350
1351	template<class V> void accept( V & v ) const
1352	{
1353	#if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ )
1354	using boost::visit_each;
1355	#endif
1356
1357	BOOST_BIND_VISIT_EACH( v, f_, 0 );
1358	l_.accept( v );
1359	}
1360
1361	bool compare( this_type const & rhs ) const
1362	{
1363	return ref_compare( f_, rhs.f_, 0 ) && l_ == rhs.l_;
1364	}
1365	};
1366
1367	#elif !defined( BOOST_NO_VOID_RETURNS )
1368
1369	template<class R, class F, class L> class bind_t
1370	{
1371	public:
1372
1373	typedef bind_t this_type;
1374
1375	bind_t(F f, L const & l): f_(f), l_(l) {}
1376
1377	#define BOOST_BIND_RETURN return
1378	#include <boost/bind/bind_template.hpp>
1379	#undef BOOST_BIND_RETURN
1380
1381	};
1382
1383	#else // no void returns
1384
1385	template<class R> struct bind_t_generator
1386	{
1387
1388	template<class F, class L> class implementation
1389	{
1390	public:
1391
1392	typedef implementation this_type;
1393
1394	implementation(F f, L const & l): f_(f), l_(l) {}
1395
1396	#define BOOST_BIND_RETURN return
1397	#include <boost/bind/bind_template.hpp>
1398	#undef BOOST_BIND_RETURN
1399
1400	};
1401
1402	};
1403
1404	template<> struct bind_t_generator<void>
1405	{
1406
1407	template<class F, class L> class implementation
1408	{
1409	private:
1410
1411	typedef void R;
1412
1413	public:
1414
1415	typedef implementation this_type;
1416
1417	implementation(F f, L const & l): f_(f), l_(l) {}
1418
1419	#define BOOST_BIND_RETURN
1420	#include <boost/bind/bind_template.hpp>
1421	#undef BOOST_BIND_RETURN
1422
1423	};
1424
1425	};
1426
1427	template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>
1428	{
1429	public:
1430
1431	bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}
1432
1433	};
1434
1435	#endif
1436
1437	// function_equal
1438
1439	#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
1440
1441	// put overloads in _bi, rely on ADL
1442
1443	# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
1444
1445	template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
1446	{
1447	return a.compare(b);
1448	}
1449
1450	# else
1451
1452	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 )
1453	{
1454	return a.compare(b);
1455	}
1456
1457	# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
1458
1459	#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
1460
1461	// put overloads in boost
1462
1463	} // namespace _bi
1464
1465	# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
1466
1467	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 )
1468	{
1469	return a.compare(b);
1470	}
1471
1472	# else
1473
1474	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 )
1475	{
1476	return a.compare(b);
1477	}
1478
1479	# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
1480
1481	namespace _bi
1482	{
1483
1484	#endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
1485
1486	// add_value
1487
1488	#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
1489
1490	#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x582) )
1491
1492	template<class T> struct add_value
1493	{
1494	typedef _bi::value<T> type;
1495	};
1496
1497	#else
1498
1499	template< class T, int I > struct add_value_2
1500	{
1501	typedef boost::arg<I> type;
1502	};
1503
1504	template< class T > struct add_value_2< T, 0 >
1505	{
1506	typedef _bi::value< T > type;
1507	};
1508
1509	template<class T> struct add_value
1510	{
1511	typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
1512	};
1513
1514	#endif
1515
1516	template<class T> struct add_value< value<T> >
1517	{
1518	typedef _bi::value<T> type;
1519	};
1520
1521	template<class T> struct add_value< reference_wrapper<T> >
1522	{
1523	typedef reference_wrapper<T> type;
1524	};
1525
1526	template<int I> struct add_value< arg<I> >
1527	{
1528	typedef boost::arg<I> type;
1529	};
1530
1531	template<int I> struct add_value< arg<I> (*) () >
1532	{
1533	typedef boost::arg<I> (*type) ();
1534	};
1535
1536	template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
1537	{
1538	typedef bind_t<R, F, L> type;
1539	};
1540
1541	#else
1542
1543	template<int I> struct _avt_0;
1544
1545	template<> struct _avt_0<1>
1546	{
1547	template<class T> struct inner
1548	{
1549	typedef T type;
1550	};
1551	};
1552
1553	template<> struct _avt_0<2>
1554	{
1555	template<class T> struct inner
1556	{
1557	typedef value<T> type;
1558	};
1559	};
1560
1561	typedef char (&_avt_r1) [1];
1562	typedef char (&_avt_r2) [2];
1563
1564	template<class T> _avt_r1 _avt_f(value<T>);
1565	template<class T> _avt_r1 _avt_f(reference_wrapper<T>);
1566	template<int I> _avt_r1 _avt_f(arg<I>);
1567	template<int I> _avt_r1 _avt_f(arg<I> (*) ());
1568	template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>);
1569
1570	_avt_r2 _avt_f(...);
1571
1572	template<class T> struct add_value
1573	{
1574	static T t();
1575	typedef typename _avt_0<sizeof(_avt_f(t()))>::template inner<T>::type type;
1576	};
1577
1578	#endif
1579
1580	// list_av_N
1581
1582	template<class A1> struct list_av_1
1583	{
1584	typedef typename add_value<A1>::type B1;
1585	typedef list1<B1> type;
1586	};
1587
1588	template<class A1, class A2> struct list_av_2
1589	{
1590	typedef typename add_value<A1>::type B1;
1591	typedef typename add_value<A2>::type B2;
1592	typedef list2<B1, B2> type;
1593	};
1594
1595	template<class A1, class A2, class A3> struct list_av_3
1596	{
1597	typedef typename add_value<A1>::type B1;
1598	typedef typename add_value<A2>::type B2;
1599	typedef typename add_value<A3>::type B3;
1600	typedef list3<B1, B2, B3> type;
1601	};
1602
1603	template<class A1, class A2, class A3, class A4> struct list_av_4
1604	{
1605	typedef typename add_value<A1>::type B1;
1606	typedef typename add_value<A2>::type B2;
1607	typedef typename add_value<A3>::type B3;
1608	typedef typename add_value<A4>::type B4;
1609	typedef list4<B1, B2, B3, B4> type;
1610	};
1611
1612	template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
1613	{
1614	typedef typename add_value<A1>::type B1;
1615	typedef typename add_value<A2>::type B2;
1616	typedef typename add_value<A3>::type B3;
1617	typedef typename add_value<A4>::type B4;
1618	typedef typename add_value<A5>::type B5;
1619	typedef list5<B1, B2, B3, B4, B5> type;
1620	};
1621
1622	template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
1623	{
1624	typedef typename add_value<A1>::type B1;
1625	typedef typename add_value<A2>::type B2;
1626	typedef typename add_value<A3>::type B3;
1627	typedef typename add_value<A4>::type B4;
1628	typedef typename add_value<A5>::type B5;
1629	typedef typename add_value<A6>::type B6;
1630	typedef list6<B1, B2, B3, B4, B5, B6> type;
1631	};
1632
1633	template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
1634	{
1635	typedef typename add_value<A1>::type B1;
1636	typedef typename add_value<A2>::type B2;
1637	typedef typename add_value<A3>::type B3;
1638	typedef typename add_value<A4>::type B4;
1639	typedef typename add_value<A5>::type B5;
1640	typedef typename add_value<A6>::type B6;
1641	typedef typename add_value<A7>::type B7;
1642	typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
1643	};
1644
1645	template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
1646	{
1647	typedef typename add_value<A1>::type B1;
1648	typedef typename add_value<A2>::type B2;
1649	typedef typename add_value<A3>::type B3;
1650	typedef typename add_value<A4>::type B4;
1651	typedef typename add_value<A5>::type B5;
1652	typedef typename add_value<A6>::type B6;
1653	typedef typename add_value<A7>::type B7;
1654	typedef typename add_value<A8>::type B8;
1655	typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
1656	};
1657
1658	template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
1659	{
1660	typedef typename add_value<A1>::type B1;
1661	typedef typename add_value<A2>::type B2;
1662	typedef typename add_value<A3>::type B3;
1663	typedef typename add_value<A4>::type B4;
1664	typedef typename add_value<A5>::type B5;
1665	typedef typename add_value<A6>::type B6;
1666	typedef typename add_value<A7>::type B7;
1667	typedef typename add_value<A8>::type B8;
1668	typedef typename add_value<A9>::type B9;
1669	typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
1670	};
1671
1672	// operator!
1673
1674	struct logical_not
1675	{
1676	template<class V> bool operator()(V const & v) const { return !v; }
1677	};
1678
1679	template<class R, class F, class L>
1680	bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
1681	operator! (bind_t<R, F, L> const & f)
1682	{
1683	typedef list1< bind_t<R, F, L> > list_type;
1684	return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
1685	}
1686
1687	// relational operators
1688
1689	#define BOOST_BIND_OPERATOR( op, name ) \
1690	\
1691	struct name \
1692	{ \
1693	template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } \
1694	}; \
1695	\
1696	template<class R, class F, class L, class A2> \
1697	bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > \
1698	operator op (bind_t<R, F, L> const & f, A2 a2) \
1699	{ \
1700	typedef typename add_value<A2>::type B2; \
1701	typedef list2< bind_t<R, F, L>, B2> list_type; \
1702	return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); \
1703	}
1704
1705	BOOST_BIND_OPERATOR( ==, equal )
1706	BOOST_BIND_OPERATOR( !=, not_equal )
1707
1708	BOOST_BIND_OPERATOR( <, less )
1709	BOOST_BIND_OPERATOR( <=, less_equal )
1710
1711	BOOST_BIND_OPERATOR( >, greater )
1712	BOOST_BIND_OPERATOR( >=, greater_equal )
1713
1714	BOOST_BIND_OPERATOR( &&, logical_and )
1715	BOOST_BIND_OPERATOR( ||, logical_or )
1716
1717	#undef BOOST_BIND_OPERATOR
1718
1719	#if defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3)
1720
1721	// resolve ambiguity with rel_ops
1722
1723	#define BOOST_BIND_OPERATOR( op, name ) \
1724	\
1725	template<class R, class F, class L> \
1726	bind_t< bool, name, list2< bind_t<R, F, L>, bind_t<R, F, L> > > \
1727	operator op (bind_t<R, F, L> const & f, bind_t<R, F, L> const & g) \
1728	{ \
1729	typedef list2< bind_t<R, F, L>, bind_t<R, F, L> > list_type; \
1730	return bind_t<bool, name, list_type> ( name(), list_type(f, g) ); \
1731	}
1732
1733	BOOST_BIND_OPERATOR( !=, not_equal )
1734	BOOST_BIND_OPERATOR( <=, less_equal )
1735	BOOST_BIND_OPERATOR( >, greater )
1736	BOOST_BIND_OPERATOR( >=, greater_equal )
1737
1738	#endif
1739
1740	// visit_each, ADL
1741
1742	#if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \
1743	&& !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
1744
1745	template<class V, class T> void visit_each( V & v, value<T> const & t, int )
1746	{
1747	using boost::visit_each;
1748	BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
1749	}
1750
1751	template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
1752	{
1753	t.accept( v );
1754	}
1755
1756	#endif
1757
1758	} // namespace _bi
1759
1760	// visit_each, no ADL
1761
1762	#if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \
1763	|| (defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
1764
1765	template<class V, class T> void visit_each( V & v, _bi::value<T> const & t, int )
1766	{
1767	BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
1768	}
1769
1770	template<class V, class R, class F, class L> void visit_each( V & v, _bi::bind_t<R, F, L> const & t, int )
1771	{
1772	t.accept( v );
1773	}
1774
1775	#endif
1776
1777	// is_bind_expression
1778
1779	template< class T > struct is_bind_expression
1780	{
1781	enum _vt { value = 0 };
1782	};
1783
1784	#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
1785
1786	template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
1787	{
1788	enum _vt { value = 1 };
1789	};
1790
1791	#endif
1792
1793	// bind
1794
1795	#ifndef BOOST_BIND
1796	#define BOOST_BIND bind
1797	#endif
1798
1799	// generic function objects
1800
1801	template<class R, class F>
1802	_bi::bind_t<R, F, _bi::list0>
1803	BOOST_BIND(F f)
1804	{
1805	typedef _bi::list0 list_type;
1806	return _bi::bind_t<R, F, list_type> (f, list_type());
1807	}
1808
1809	template<class R, class F, class A1>
1810	_bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
1811	BOOST_BIND(F f, A1 a1)
1812	{
1813	typedef typename _bi::list_av_1<A1>::type list_type;
1814	return _bi::bind_t<R, F, list_type> (f, list_type(a1));
1815	}
1816
1817	template<class R, class F, class A1, class A2>
1818	_bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
1819	BOOST_BIND(F f, A1 a1, A2 a2)
1820	{
1821	typedef typename _bi::list_av_2<A1, A2>::type list_type;
1822	return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
1823	}
1824
1825	template<class R, class F, class A1, class A2, class A3>
1826	_bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
1827	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
1828	{
1829	typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
1830	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
1831	}
1832
1833	template<class R, class F, class A1, class A2, class A3, class A4>
1834	_bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
1835	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
1836	{
1837	typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
1838	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
1839	}
1840
1841	template<class R, class F, class A1, class A2, class A3, class A4, class A5>
1842	_bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
1843	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
1844	{
1845	typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
1846	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
1847	}
1848
1849	template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
1850	_bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
1851	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
1852	{
1853	typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
1854	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
1855	}
1856
1857	template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1858	_bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
1859	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
1860	{
1861	typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
1862	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
1863	}
1864
1865	template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
1866	_bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
1867	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
1868	{
1869	typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
1870	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
1871	}
1872
1873	template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
1874	_bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
1875	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
1876	{
1877	typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
1878	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
1879	}
1880
1881	// generic function objects, alternative syntax
1882
1883	template<class R, class F>
1884	_bi::bind_t<R, F, _bi::list0>
1885	BOOST_BIND(boost::type<R>, F f)
1886	{
1887	typedef _bi::list0 list_type;
1888	return _bi::bind_t<R, F, list_type> (f, list_type());
1889	}
1890
1891	template<class R, class F, class A1>
1892	_bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
1893	BOOST_BIND(boost::type<R>, F f, A1 a1)
1894	{
1895	typedef typename _bi::list_av_1<A1>::type list_type;
1896	return _bi::bind_t<R, F, list_type> (f, list_type(a1));
1897	}
1898
1899	template<class R, class F, class A1, class A2>
1900	_bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
1901	BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2)
1902	{
1903	typedef typename _bi::list_av_2<A1, A2>::type list_type;
1904	return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
1905	}
1906
1907	template<class R, class F, class A1, class A2, class A3>
1908	_bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
1909	BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
1910	{
1911	typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
1912	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
1913	}
1914
1915	template<class R, class F, class A1, class A2, class A3, class A4>
1916	_bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
1917	BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
1918	{
1919	typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
1920	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
1921	}
1922
1923	template<class R, class F, class A1, class A2, class A3, class A4, class A5>
1924	_bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
1925	BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
1926	{
1927	typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
1928	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
1929	}
1930
1931	template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
1932	_bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
1933	BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
1934	{
1935	typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
1936	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
1937	}
1938
1939	template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1940	_bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
1941	BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
1942	{
1943	typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
1944	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
1945	}
1946
1947	template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
1948	_bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
1949	BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
1950	{
1951	typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
1952	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
1953	}
1954
1955	template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
1956	_bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
1957	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)
1958	{
1959	typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
1960	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
1961	}
1962
1963	#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
1964
1965	// adaptable function objects
1966
1967	template<class F>
1968	_bi::bind_t<_bi::unspecified, F, _bi::list0>
1969	BOOST_BIND(F f)
1970	{
1971	typedef _bi::list0 list_type;
1972	return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
1973	}
1974
1975	template<class F, class A1>
1976	_bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
1977	BOOST_BIND(F f, A1 a1)
1978	{
1979	typedef typename _bi::list_av_1<A1>::type list_type;
1980	return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
1981	}
1982
1983	template<class F, class A1, class A2>
1984	_bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
1985	BOOST_BIND(F f, A1 a1, A2 a2)
1986	{
1987	typedef typename _bi::list_av_2<A1, A2>::type list_type;
1988	return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
1989	}
1990
1991	template<class F, class A1, class A2, class A3>
1992	_bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
1993	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
1994	{
1995	typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
1996	return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
1997	}
1998
1999	template<class F, class A1, class A2, class A3, class A4>
2000	_bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
2001	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
2002	{
2003	typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
2004	return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
2005	}
2006
2007	template<class F, class A1, class A2, class A3, class A4, class A5>
2008	_bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
2009	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
2010	{
2011	typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
2012	return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
2013	}
2014
2015	template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
2016	_bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
2017	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
2018	{
2019	typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
2020	return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
2021	}
2022
2023	template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
2024	_bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
2025	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
2026	{
2027	typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
2028	return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
2029	}
2030
2031	template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
2032	_bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
2033	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
2034	{
2035	typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
2036	return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
2037	}
2038
2039	template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
2040	_bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
2041	BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
2042	{
2043	typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
2044	return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
2045	}
2046
2047	#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
2048
2049	// function pointers
2050
2051	#define BOOST_BIND_CC
2052	#define BOOST_BIND_ST
2053
2054	#include <boost/bind/bind_cc.hpp>
2055
2056	#undef BOOST_BIND_CC
2057	#undef BOOST_BIND_ST
2058
2059	#ifdef BOOST_BIND_ENABLE_STDCALL
2060
2061	#define BOOST_BIND_CC __stdcall
2062	#define BOOST_BIND_ST
2063
2064	#include <boost/bind/bind_cc.hpp>
2065
2066	#undef BOOST_BIND_CC
2067	#undef BOOST_BIND_ST
2068
2069	#endif
2070
2071	#ifdef BOOST_BIND_ENABLE_FASTCALL
2072
2073	#define BOOST_BIND_CC __fastcall
2074	#define BOOST_BIND_ST
2075
2076	#include <boost/bind/bind_cc.hpp>
2077
2078	#undef BOOST_BIND_CC
2079	#undef BOOST_BIND_ST
2080
2081	#endif
2082
2083	#ifdef BOOST_BIND_ENABLE_PASCAL
2084
2085	#define BOOST_BIND_ST pascal
2086	#define BOOST_BIND_CC
2087
2088	#include <boost/bind/bind_cc.hpp>
2089
2090	#undef BOOST_BIND_ST
2091	#undef BOOST_BIND_CC
2092
2093	#endif
2094
2095	// member function pointers
2096
2097	#define BOOST_BIND_MF_NAME(X) X
2098	#define BOOST_BIND_MF_CC
2099
2100	#include <boost/bind/bind_mf_cc.hpp>
2101	#include <boost/bind/bind_mf2_cc.hpp>
2102
2103	#undef BOOST_BIND_MF_NAME
2104	#undef BOOST_BIND_MF_CC
2105
2106	#ifdef BOOST_MEM_FN_ENABLE_CDECL
2107
2108	#define BOOST_BIND_MF_NAME(X) X##_cdecl
2109	#define BOOST_BIND_MF_CC __cdecl
2110
2111	#include <boost/bind/bind_mf_cc.hpp>
2112	#include <boost/bind/bind_mf2_cc.hpp>
2113
2114	#undef BOOST_BIND_MF_NAME
2115	#undef BOOST_BIND_MF_CC
2116
2117	#endif
2118
2119	#ifdef BOOST_MEM_FN_ENABLE_STDCALL
2120
2121	#define BOOST_BIND_MF_NAME(X) X##_stdcall
2122	#define BOOST_BIND_MF_CC __stdcall
2123
2124	#include <boost/bind/bind_mf_cc.hpp>
2125	#include <boost/bind/bind_mf2_cc.hpp>
2126
2127	#undef BOOST_BIND_MF_NAME
2128	#undef BOOST_BIND_MF_CC
2129
2130	#endif
2131
2132	#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
2133
2134	#define BOOST_BIND_MF_NAME(X) X##_fastcall
2135	#define BOOST_BIND_MF_CC __fastcall
2136
2137	#include <boost/bind/bind_mf_cc.hpp>
2138	#include <boost/bind/bind_mf2_cc.hpp>
2139
2140	#undef BOOST_BIND_MF_NAME
2141	#undef BOOST_BIND_MF_CC
2142
2143	#endif
2144
2145	// data member pointers
2146
2147	#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
2148	|| ( defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x620 ) ) )
2149
2150	template<class R, class T, class A1>
2151	_bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
2152	BOOST_BIND(R T::*f, A1 a1)
2153	{
2154	typedef _mfi::dm<R, T> F;
2155	typedef typename _bi::list_av_1<A1>::type list_type;
2156	return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) );
2157	}
2158
2159	#else
2160
2161	namespace _bi
2162	{
2163
2164	template< class Pm, int I > struct add_cref;
2165
2166	template< class M, class T > struct add_cref< M T::*, 0 >
2167	{
2168	typedef M type;
2169	};
2170
2171	template< class M, class T > struct add_cref< M T::*, 1 >
2172	{
2173	#ifdef BOOST_MSVC
2174	#pragma warning(push)
2175	#pragma warning(disable:4180)
2176	#endif
2177	typedef M const & type;
2178	#ifdef BOOST_MSVC
2179	#pragma warning(pop)
2180	#endif
2181	};
2182
2183	template< class R, class T > struct add_cref< R (T::*) (), 1 >
2184	{
2185	typedef void type;
2186	};
2187
2188	#if !defined(__IBMCPP__) || __IBMCPP_FUNC_CV_TMPL_ARG_DEDUCTION
2189
2190	template< class R, class T > struct add_cref< R (T::*) () const, 1 >
2191	{
2192	typedef void type;
2193	};
2194
2195	#endif // __IBMCPP__
2196
2197	template<class R> struct isref
2198	{
2199	enum value_type { value = 0 };
2200	};
2201
2202	template<class R> struct isref< R& >
2203	{
2204	enum value_type { value = 1 };
2205	};
2206
2207	template<class R> struct isref< R* >
2208	{
2209	enum value_type { value = 1 };
2210	};
2211
2212	template<class Pm, class A1> struct dm_result
2213	{
2214	typedef typename add_cref< Pm, 1 >::type type;
2215	};
2216
2217	template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
2218	{
2219	typedef typename bind_t<R, F, L>::result_type result_type;
2220	typedef typename add_cref< Pm, isref< result_type >::value >::type type;
2221	};
2222
2223	} // namespace _bi
2224
2225	template< class A1, class M, class T >
2226
2227	_bi::bind_t<
2228	typename _bi::dm_result< M T::*, A1 >::type,
2229	_mfi::dm<M, T>,
2230	typename _bi::list_av_1<A1>::type
2231	>
2232
2233	BOOST_BIND( M T::*f, A1 a1 )
2234	{
2235	typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
2236	typedef _mfi::dm<M, T> F;
2237	typedef typename _bi::list_av_1<A1>::type list_type;
2238	return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
2239	}
2240
2241	#endif
2242
2243	} // namespace boost
2244
2245	#ifndef BOOST_BIND_NO_PLACEHOLDERS
2246
2247	# include <boost/bind/placeholders.hpp>
2248
2249	#endif
2250
2251	#ifdef BOOST_MSVC
2252	# pragma warning(default: 4512) // assignment operator could not be generated
2253	# pragma warning(pop)
2254	#endif
2255
2256	#endif // #ifndef BOOST_BIND_BIND_HPP_INCLUDED
2257