mirror of
https://github.com/boostorg/bind.git
synced 2026-04-13 13:15:50 +02:00
Compare commits
3 Commits
boost-1.33
...
boost-1.30
| Author | SHA1 | Date | |
|---|---|---|---|
|
66e5c37ae8 | ||
|
b32ebea99c | ||
|
|
5454a5aac6 |
500
bind.html
500
bind.html
@@ -7,9 +7,9 @@
|
||||
<body style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%" bgColor="white">
|
||||
<table width="100%" border="0">
|
||||
<tr>
|
||||
<td width="277"><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277">
|
||||
<td width="277"><IMG height="86" alt="c++boost.gif (8819 bytes)" src="../../c++boost.gif" width="277">
|
||||
</td>
|
||||
<td align="center">
|
||||
<td align="middle">
|
||||
<h1>bind.hpp</h1>
|
||||
</td>
|
||||
</tr>
|
||||
@@ -19,53 +19,52 @@
|
||||
</table>
|
||||
<h2>Contents</h2>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><A href="#Purpose">Purpose</A></h3>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_functions">Using bind with functions and
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_functions">Using bind with functions and
|
||||
function pointers</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_function_objects">Using bind with function
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_function_objects">Using bind with function
|
||||
objects</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_member_pointers">Using bind with pointers
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_member_pointers">Using bind with pointers
|
||||
to members</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#nested_binds">Using nested binds for function
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#nested_binds">Using nested binds for function
|
||||
composition</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#operators">Overloaded operators</A></h4>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><A href="#Examples">Examples</A></h3>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_algorithms">Using bind with standard
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_algorithms">Using bind with standard
|
||||
algorithms</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_boost_function">Using bind with
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#with_boost_function">Using bind with
|
||||
Boost.Function</A></h4>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><A href="#Limitations">Limitations</A></h3>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><A href="#FAQ">Frequently Asked Questions</A></h3>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_doesnt_compile">Why doesn't this compile?</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_does_compile">Why does this compile? It
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_does_compile">Why does this compile? It
|
||||
should not.</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_forms">What is the difference between bind(f,
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_forms">What is the difference between bind(f,
|
||||
...) and bind<R>(f, ...)?</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_win32_api">Does <b>bind</b> work with Windows
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_win32_api">Does <b>bind</b> work with Windows
|
||||
API functions?</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_com">Does <b>bind</b> work with COM methods?</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_mac">Does <b>bind</b> work with Mac toolbox
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_mac">Does <b>bind</b> work with Mac toolbox
|
||||
functions?</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_extern_C">Does <b>bind</b> work with extern
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_extern_C">Does <b>bind</b> work with extern
|
||||
"C" functions?</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_auto_stdcall">Why doesn't <b>bind</b> automatically
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Q_auto_stdcall">Why doesn't <b>bind</b> automatically
|
||||
recognize nonstandard functions?</A></h4>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><A href="#Troubleshooting">Troubleshooting</A></h3>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_num_args">Incorrect number of arguments</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_signature">The function object cannot be
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_signature">The function object cannot be
|
||||
called with the specified arguments</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_arg_access">Accessing an argument that does
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_arg_access">Accessing an argument that does
|
||||
not exist</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_short_form">Inappropriate use of bind(f,
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_short_form">Inappropriate use of bind(f,
|
||||
...)</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_long_form">Inappropriate use of
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_long_form">Inappropriate use of
|
||||
bind<R>(f, ...)</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_nonstd">Binding a nonstandard function</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_const_arg"><b>const</b> in signatures</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_msvc_using">MSVC specific: using
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_msvc_using">MSVC specific: using
|
||||
boost::bind;</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_msvc_class_template">MSVC specific: class
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_msvc_class_template">MSVC specific: class
|
||||
templates shadow function templates</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_msvc_ellipsis">MSVC specific: ... in
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#err_msvc_ellipsis">MSVC specific: ... in
|
||||
signatures treated as type</A></h4>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><A href="#Interface">Interface</A></h3>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Synopsis">Synopsis</A></h4>
|
||||
@@ -77,16 +76,16 @@
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Files">Files</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#Dependencies">Dependencies</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#NumberOfArguments">Number of Arguments</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#stdcall">"__stdcall", "__cdecl", "__fastcall",
|
||||
and "pascal" Support</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#stdcall">"__stdcall", "__fastcall", and
|
||||
"pascal" Support</A></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><A href="#visit_each"><b>visit_each</b> support</A></h4>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><A href="#Acknowledgements">Acknowledgements</A></h3>
|
||||
<h2><a name="Purpose">Purpose</a></h2>
|
||||
<p><b>boost::bind</b> is a generalization of the standard functions <b>std::bind1st</b>
|
||||
and <b>std::bind2nd</b>. It supports arbitrary function objects, functions,
|
||||
function pointers, and member function pointers, and is able to bind any
|
||||
and <b>std::bind2nd</b>. It supports arbitrary function objects, functions,
|
||||
function pointers, and member function pointers, and is able to bind any
|
||||
argument to a specific value or route input arguments into arbitrary positions. <b>bind</b>
|
||||
does not place any requirements on the function object; in particular, it does
|
||||
does not place any requirements on the function object; in particular, it does
|
||||
not need the <b>result_type</b>, <b>first_argument_type</b> and <b>second_argument_type</b>
|
||||
standard typedefs.
|
||||
</p>
|
||||
@@ -103,15 +102,15 @@ int g(int a, int b, int c)
|
||||
return a + b + c;
|
||||
}
|
||||
</pre>
|
||||
<p><tt>bind(f, 1, 2)</tt> will produce a "nullary" function object that takes no
|
||||
arguments and returns <tt>f(1, 2)</tt>. Similarly, <tt>bind(g, 1, 2, 3)()</tt> is
|
||||
<p><tt>bind(f, 1, 2)</tt> will produce a "nullary" function object that takes no
|
||||
arguments and returns <tt>f(1, 2)</tt>. Similarly, <tt>bind(g, 1, 2, 3)()</tt> is
|
||||
equivalent to <tt>g(1, 2, 3)</tt>.
|
||||
</p>
|
||||
<p>It is possible to selectively bind only some of the arguments. <tt>bind(f, _1, 5)(x)</tt>
|
||||
is equivalent to <tt>f(x, 5)</tt>; here <b>_1</b>
|
||||
is a placeholder argument that means "substitute with the first input
|
||||
is a placeholder argument that means "substitute with the first input
|
||||
argument."
|
||||
<p>For comparison, here is the same operation expressed with the standard library
|
||||
<p>For comparison, here is the same operation expressed with the standard library
|
||||
primitives:
|
||||
</p>
|
||||
<pre>std::bind2nd(std::ptr_fun(f), 5)(x);
|
||||
@@ -121,7 +120,7 @@ int g(int a, int b, int c)
|
||||
<pre>std::bind1st(std::ptr_fun(f), 5)(x); // f(5, x)
|
||||
bind(f, 5, _1)(x); // f(5, x)
|
||||
</pre>
|
||||
<p><b>bind</b> can handle functions with more than two arguments, and its argument
|
||||
<p><b>bind</b> can handle functions with more than two arguments, and its argument
|
||||
substitution mechanism is more general:
|
||||
</p>
|
||||
<pre>bind(f, _2, _1)(x, y); // f(y, x)
|
||||
@@ -132,13 +131,13 @@ bind(g, _3, _3, _3)(x, y, z); // g(z, z, z)
|
||||
|
||||
bind(g, _1, _1, _1)(x, y, z); // g(x, x, x)
|
||||
</pre>
|
||||
<p>Note that, in the last example, the function object produced by <tt>bind(g, _1, _1,
|
||||
_1)</tt> does not contain references to any arguments beyond the first, but
|
||||
it can still be used with more than one argument. Any extra arguments are
|
||||
silently ignored, just like the first and the second argument are ignored in
|
||||
<p>Note that, in the last example, the function object produced by <tt>bind(g, _1, _1,
|
||||
_1)</tt> does not contain references to any arguments beyond the first, but
|
||||
it can still be used with more than one argument. Any extra arguments are
|
||||
silently ignored, just like the first and the second argument are ignored in
|
||||
the third example.
|
||||
</p>
|
||||
<p>The arguments that <b>bind</b> takes are copied and held internally by the
|
||||
<p>The arguments that <b>bind</b> takes are copied and held internally by the
|
||||
returned function object. For example, in the following code:
|
||||
</p>
|
||||
<pre>int i = 5;
|
||||
@@ -146,19 +145,17 @@ bind(g, _1, _1, _1)(x, y, z); // g(x, x, x)
|
||||
bind(f, i, _1);
|
||||
</pre>
|
||||
<p>a copy of the value of <b>i</b> is stored into the function object. <A href="ref.html">
|
||||
boost::ref</A> and <A href="ref.html">boost::cref</A> can be used to make
|
||||
boost::ref</A> and <A href="ref.html">boost::cref</A> can be used to make
|
||||
the function object store a reference to an object, rather than a copy:
|
||||
</p>
|
||||
<pre>int i = 5;
|
||||
|
||||
bind(f, ref(i), _1);
|
||||
|
||||
bind(f, cref(42), _1);
|
||||
</pre>
|
||||
<h3><a name="with_function_objects">Using bind with function objects</a></h3>
|
||||
<p><b>bind</b> is not limited to functions; it accepts arbitrary function objects.
|
||||
<p><b>bind</b> is not limited to functions; it accepts arbitrary function objects.
|
||||
In the general case, the return type of the generated function object's <b>operator()</b>
|
||||
has to be specified explicitly (without a <b>typeof</b> operator the return
|
||||
has to be specified explicitly (without a <b>typeof</b> operator the return
|
||||
type cannot be inferred):
|
||||
</p>
|
||||
<pre>struct F
|
||||
@@ -173,13 +170,13 @@ int x = 104;
|
||||
|
||||
bind<int>(f, _1, _1)(x); // f(x, x), i.e. zero
|
||||
</pre>
|
||||
<p>Some compilers have trouble with the <tt>bind<R>(f, ...)</tt> syntax. For
|
||||
<p>Some compilers have trouble with the <tt>bind<R>(f, ...)</tt> syntax. For
|
||||
portability reasons, an alternative way to express the above is supported:</p>
|
||||
<pre>boost::bind(boost::type<int>(), f, _1, _1)(x);
|
||||
</pre>
|
||||
<P>Note, however, that the alternative syntax is provided only as a workaround. It
|
||||
<P>Note, however, that the alternative syntax is provided only as a workaround. It
|
||||
is not part of the interface.</P>
|
||||
<P>When the function object exposes a nested type named <b>result_type</b>, the
|
||||
<P>When the function object exposes a nested type named <b>result_type</b>, the
|
||||
explicit return type can be omitted:
|
||||
</P>
|
||||
<pre>int x = 8;
|
||||
@@ -189,23 +186,23 @@ bind(std::less<int>(), _1, 9)(x); // x < 9
|
||||
<p>[Note: the ability to omit the return type is not available on all compilers.]
|
||||
</p>
|
||||
<h3><a name="with_member_pointers">Using bind with pointers to members</a></h3>
|
||||
<p>Pointers to member functions and pointers to data members are not function
|
||||
<p>Pointers to member functions and pointers to data members are not function
|
||||
objects, because they do not support <tt>operator()</tt>. For convenience, <b>bind</b>
|
||||
accepts member pointers as its first argument, and the behavior is as if <A href="mem_fn.html">
|
||||
boost::mem_fn</A> has been used to convert the member pointer into a
|
||||
boost::mem_fn</A> has been used to convert the member pointer into a
|
||||
function object. In other words, the expression
|
||||
</p>
|
||||
<pre>bind(&X::f, <i>args</i>)
|
||||
<pre>bind(&X::f, <i>args</I>)
|
||||
</pre>
|
||||
<p>is equivalent to
|
||||
</p>
|
||||
<pre>bind<R>(<A href="mem_fn.html" >mem_fn</A>(&X::f), <i>args</i>)
|
||||
<pre>bind<R>(<A href="mem_fn.html" >mem_fn</A>(&X::f), <i>args</I>)
|
||||
</pre>
|
||||
<p>where <b>R</b> is the return type of <b>X::f</b> (for member functions) or the
|
||||
type of the member (for data members.)
|
||||
<p>where <b>R</b> is the return type of <b>X::f</b> (for member functions) or a
|
||||
const reference to the type of the member (for data members.)
|
||||
</p>
|
||||
<p>[Note: <b>mem_fn</b> creates function objects that are able to accept a pointer,
|
||||
a reference, or a smart pointer to an object as its first argument; for
|
||||
<p>[Note: <b>mem_fn</b> creates function objects that are able to accept a pointer,
|
||||
a reference, or a smart pointer to an object as its first argument; for
|
||||
additional information, see the <b>mem_fn</b> <A href="mem_fn.html">documentation</A>.]
|
||||
</p>
|
||||
<p>Example:
|
||||
@@ -223,36 +220,36 @@ int i = 5;
|
||||
|
||||
bind(&X::f, ref(x), _1)(i); // x.f(i)
|
||||
bind(&X::f, &x, _1)(i); //(&x)->f(i)
|
||||
bind(&X::f, x, _1)(i); // (<i>internal copy of x</i>).f(i)
|
||||
bind(&X::f, p, _1)(i); // (<i>internal copy of p</i>)->f(i)
|
||||
bind(&X::f, x, _1)(i); // (<i>internal copy of x</I>).f(i)
|
||||
bind(&X::f, p, _1)(i); // (<i>internal copy of p</I>)->f(i)
|
||||
</pre>
|
||||
<p>The last two examples are interesting in that they produce "self-contained"
|
||||
function objects. <tt>bind(&X::f, x, _1)</tt> stores a copy of <b>x</b>. <tt>bind(&X::f,
|
||||
<p>The last two examples are interesting in that they produce "self-contained"
|
||||
function objects. <tt>bind(&X::f, x, _1)</tt> stores a copy of <b>x</b>. <tt>bind(&X::f,
|
||||
p, _1)</tt> stores a copy of <b>p</b>, and since <b>p</b> is a <A href="../smart_ptr/shared_ptr.htm">
|
||||
boost::shared_ptr</A>, the function object retains a reference to its
|
||||
instance of <b>X</b> and will remain valid even when <b>p</b> goes out of scope
|
||||
boost::shared_ptr</A>, the function object retains a reference to its
|
||||
instance of <b>X</b> and will remain valid even when <b>p</b> goes out of scope
|
||||
or is <b>reset()</b>.
|
||||
</p>
|
||||
<h3><a name="nested_binds">Using nested binds for function composition</a></h3>
|
||||
<p>Some of the arguments passed to <b>bind</b> may be nested <b>bind</b> expressions
|
||||
<p>Some of the arguments passed to <b>bind</b> may be nested <b>bind</b> expressions
|
||||
themselves:
|
||||
</p>
|
||||
<pre>bind(f, bind(g, _1))(x); // f(g(x))
|
||||
</pre>
|
||||
<p>The inner <STRONG>bind</STRONG> expressions are evaluated, in unspecified order,
|
||||
before the outer <STRONG>bind</STRONG> when the function object is called; the
|
||||
<p>The inner <STRONG>bind</STRONG> expressions are evaluated, in unspecified order,
|
||||
before the outer <STRONG>bind</STRONG> when the function object is called; the
|
||||
results of the evaluation are then substituted in their place when the outer <STRONG>
|
||||
bind</STRONG> is evaluated. In the example above, when the function object
|
||||
is called with the argument list <tt>(x)</tt>, <tt>bind(g, _1)(x)</tt> is
|
||||
evaluated first, yielding <tt>g(x)</tt>, and then <tt>bind(f, g(x))(x)</tt> is
|
||||
bind</STRONG> is evaluated. In the example above, when the function object
|
||||
is called with the argument list <tt>(x)</tt>, <tt>bind(g, _1)(x)</tt> is
|
||||
evaluated first, yielding <tt>g(x)</tt>, and then <tt>bind(f, g(x))(x)</tt> is
|
||||
evaluated, yielding the final result <tt>f(g(x))</tt>.
|
||||
</p>
|
||||
<P>This feature of <b>bind</b> can be used to perform function composition. See <A href="bind_as_compose.cpp">
|
||||
bind_as_compose.cpp</A> for an example that demonstrates how to use <b>bind</b>
|
||||
to achieve similar functionality to <A href="../compose/index.htm">Boost.Compose</A>.
|
||||
</P>
|
||||
<p>Note that the first argument - the bound function object - is not evaluated,
|
||||
even when it's a function object that is produced by <STRONG>bind</STRONG> or a
|
||||
<p>Note that the first argument - the bound function object - is not evaluated,
|
||||
even when it's a function object that is produced by <STRONG>bind</STRONG> or a
|
||||
placeholder argument, so the example below does not work as expected:
|
||||
</p>
|
||||
<pre>typedef void (*pf)(int);
|
||||
@@ -262,9 +259,9 @@ std::vector<pf> v;
|
||||
std::for_each(v.begin(), v.end(), bind(_1, 5));
|
||||
</pre>
|
||||
<p>The desired effect can be achieved via a helper function object <STRONG>apply</STRONG>
|
||||
that applies its first argument, as a function object, to the rest of its
|
||||
argument list. For convenience, an implementation of <STRONG>apply</STRONG> is
|
||||
provided in the <STRONG>boost/bind/apply.hpp</STRONG> header file. Here is how
|
||||
that applies its first argument, as a function object, to the rest of its
|
||||
argument list. For convenience, an implementation of <STRONG>apply</STRONG> is
|
||||
provided in the <STRONG>boost/bind/apply.hpp</STRONG> header file. Here is how
|
||||
the modified version of the previous example looks like:
|
||||
</p>
|
||||
<pre>typedef void (*pf)(int);
|
||||
@@ -273,39 +270,15 @@ std::vector<pf> v;
|
||||
|
||||
std::for_each(v.begin(), v.end(), bind(apply<void>(), _1, 5));
|
||||
</pre>
|
||||
<P>Although the first argument is, by default, not evaluated, all other arguments
|
||||
are. Sometimes it is necessary not to evaluate arguments subsequent to the
|
||||
first, even when they are nested <STRONG>bind</STRONG> subexpressions. This can
|
||||
be achieved with the help of another function object, <STRONG>protect</STRONG>,
|
||||
that masks the type so that <STRONG>bind</STRONG> does not recognize and
|
||||
evaluate it. When called, <STRONG>protect</STRONG> simply forwards the argument
|
||||
list to the other function object unmodified.</P>
|
||||
<P>Sometimes it is necessary not to evaluate the first argument, but <STRONG>not</STRONG>
|
||||
to evaluate some of the other arguments, even when they are nested <STRONG>bind</STRONG>
|
||||
subexpressions. This can be achieved with the help of another function object, <STRONG>
|
||||
protect</STRONG>, that masks the type so that <STRONG>bind</STRONG> does
|
||||
not recognize and evaluate it. When called, <STRONG>protect</STRONG> simply
|
||||
forwards the argument list to the other function object unmodified.</P>
|
||||
<P>The header <STRONG>boost/bind/protect.hpp</STRONG> contains an implementation of <STRONG>
|
||||
protect</STRONG>. To protect a <STRONG>bind</STRONG> function object from
|
||||
protect</STRONG>. To protect a <STRONG>bind</STRONG> function object from
|
||||
evaluation, use <tt>protect(bind(f, ...))</tt>.</P>
|
||||
<h3><a name="operators">Overloaded operators</a> (new in Boost 1.33)</h3>
|
||||
<p>For convenience, the function objects produced by <tt>bind</tt> overload
|
||||
the logical not operator <STRONG>!</STRONG> and the relational operators <STRONG>==</STRONG>,
|
||||
<STRONG>!=</STRONG>, <STRONG><</STRONG>, <STRONG><=</STRONG>, <STRONG>></STRONG>,
|
||||
<STRONG>>=</STRONG>.</p>
|
||||
<P><tt>!bind(f, ...)</tt> is equivalent to <tt>bind( <EM>logical_not</EM>(), bind(f,
|
||||
...) )</tt>, where <tt><EM>logical_not</EM></tt> is a function object that
|
||||
takes one argument <tt>x</tt> and returns <tt>!x</tt>.</P>
|
||||
<P><tt>bind(f, ...) <EM>op</EM> x</tt>, where <EM>op</EM> is a relational operator,
|
||||
is equivalent to <tt>bind( <EM>relation</EM>(), bind(f, ...), x )</tt>, where <em>relation</em>
|
||||
is a function object that takes two arguments <tt>a</tt> and <tt>b</tt> and
|
||||
returns <tt>a <EM>op</EM> b</tt>.</P>
|
||||
<P>What this means in practice is that you can conveniently negate the result of
|
||||
<tt>bind</tt>:</P>
|
||||
<P><tt>std::remove_if( first, last, !bind( &X::visible, _1 ) ); // remove invisible
|
||||
objects</tt></P>
|
||||
<P>and compare the result of <tt>bind</tt> against a value:</P>
|
||||
<P><tt>std::find_if( first, last, bind( &X::name, _1 ) == "peter" );</tt></P>
|
||||
<P>against a placeholder:</P>
|
||||
<P><tt>bind( &X::name, _1 ) == _2</tt></P>
|
||||
<P>or against another <tt>bind</tt> expression:</P>
|
||||
<P><tt>std::sort( first, last, bind( &X::name, _1 ) < bind( &X::name, _2 )
|
||||
); // sort by name</tt></P>
|
||||
<h2><a name="Examples">Examples</a></h2>
|
||||
<h3><a name="with_algorithms">Using bind with standard algorithms</a></h3>
|
||||
<pre>class image;
|
||||
@@ -363,15 +336,15 @@ void connect()
|
||||
}
|
||||
</pre>
|
||||
<h2><a name="Limitations">Limitations</a></h2>
|
||||
<p>The function objects generated by <b>bind</b> take their arguments by reference
|
||||
and cannot, therefore, accept non-const temporaries or literal constants. This
|
||||
<p>The function objects generated by <b>bind</b> take their arguments by reference
|
||||
and cannot, therefore, accept non-const temporaries or literal constants. This
|
||||
is an inherent limitation of the C++ language, known as <A href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">
|
||||
the forwarding problem</A>.</p>
|
||||
<p>The library uses signatures of the form
|
||||
</p>
|
||||
<pre>template<class T> void f(T & t);
|
||||
</pre>
|
||||
<p>to accept arguments of arbitrary types and pass them on unmodified. As noted,
|
||||
<p>to accept arguments of arbitrary types and pass them on unmodified. As noted,
|
||||
this does not work with non-const r-values.
|
||||
</p>
|
||||
<p>An oft-proposed "solution" to this problem is to add an overload:
|
||||
@@ -379,71 +352,71 @@ void connect()
|
||||
<pre>template<class T> void f(T & t);
|
||||
template<class T> void f(T const & t);
|
||||
</pre>
|
||||
<p>Unfortunately, this (a) requires providing 512 overloads for nine arguments and
|
||||
(b) does not actually work for const arguments, both l- and r-values, since the
|
||||
<p>Unfortunately, this (a) requires providing 512 overloads for nine arguments and
|
||||
(b) does not actually work for const arguments, both l- and r-values, since the
|
||||
two templates produce the exact same signature and cannot be partially ordered.
|
||||
</p>
|
||||
<p>[Note: this is a dark corner of the language, and the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#214">
|
||||
corresponding issue</a> has only recently been resolved.]
|
||||
<p>[Note: this is a dark corner of the language, and the <a href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_active.html#214">
|
||||
corresponding issue</a> has not been resolved yet.]
|
||||
</p>
|
||||
<h2><a name="FAQ">Frequently Asked Questions</a></h2>
|
||||
<h3><a name="Q_doesnt_compile">Why doesn't this compile?</a></h3>
|
||||
<p>See the <A href="#Troubleshooting">dedicated Troubleshooting section</A>.</p>
|
||||
<h3><a name="Q_does_compile">Why does this compile? It should not.</a></h3>
|
||||
<p>Probably because you used the general <tt>bind<R>(f, ...)</tt> syntax,
|
||||
thereby instructing <b>bind</b> to not "inspect" <b>f</b> to detect arity and
|
||||
<p>Probably because you used the general <tt>bind<R>(f, ...)</tt> syntax,
|
||||
thereby instructing <b>bind</b> to not "inspect" <b>f</b> to detect arity and
|
||||
return type errors.</p>
|
||||
<h3><a name="Q_forms">What is the difference between bind(f, ...) and bind<R>(f,
|
||||
<h3><a name="Q_forms">What is the difference between bind(f, ...) and bind<R>(f,
|
||||
...)?</a></h3>
|
||||
<p>The first form instructs <b>bind</b> to inspect the type of <b>f</b> in order to
|
||||
determine its arity (number of arguments) and return type. Arity errors will be
|
||||
detected at "bind time". This syntax, of course, places some requirements on <b>f</b>.
|
||||
It must be a function, function pointer, member function pointer, or a function
|
||||
object that defines a nested type named <b>result_type</b>; in short, it must
|
||||
<p>The first form instructs <b>bind</b> to inspect the type of <b>f</b> in order to
|
||||
determine its arity (number of arguments) and return type. Arity errors will be
|
||||
detected at "bind time". This syntax, of course, places some requirements on <b>f</b>.
|
||||
It must be a function, function pointer, member function pointer, or a function
|
||||
object that defines a nested type named <b>result_type</b>; in short, it must
|
||||
be something that <b>bind</b> can recognize.</p>
|
||||
<p>The second form instructs <b>bind</b> to <b>not</b> attempt to recognize the
|
||||
type of <b>f</b>. It is generally used with function objects that do not, or
|
||||
cannot, expose <b>result_type</b>, but it can also be used with nonstandard
|
||||
functions. For example, the current implementation does not automatically
|
||||
recognize variable-argument functions like <b>printf</b>, so you will have to
|
||||
use <tt>bind<int>(printf, ...)</tt>. Note that an alternative <tt>bind(type<R>(),
|
||||
<p>The second form instructs <b>bind</b> to <b>not</b> attempt to recognize the
|
||||
type of <b>f</b>. It is generally used with function objects that do not, or
|
||||
cannot, expose <b>result_type</b>, but it can also be used with nonstandard
|
||||
functions. For example, the current implementation does not automatically
|
||||
recognize variable-argument functions like <b>printf</b>, so you will have to
|
||||
use <tt>bind<int>(printf, ...)</tt>. Note that an alternative <tt>bind(type<R>(),
|
||||
f, ...)</tt> syntax is supported for portability reasons.</p>
|
||||
<p>Another important factor to consider is that compilers without partial template
|
||||
specialization or function template partial ordering support cannot handle the
|
||||
first form when <b>f</b> is a function object, and in most cases will not
|
||||
handle the second form when <b>f</b> is a function (pointer) or a member
|
||||
<p>Another important factor to consider is that compilers without partial template
|
||||
specialization or function template partial ordering support cannot handle the
|
||||
first form when <b>f</b> is a function object, and in most cases will not
|
||||
handle the second form when <b>f</b> is a function (pointer) or a member
|
||||
function pointer.</p>
|
||||
<h3><a name="Q_win32_api">Does <b>bind</b> work with Windows API functions?</a></h3>
|
||||
<p>Yes, if you <A href="#stdcall">#define BOOST_BIND_ENABLE_STDCALL</A>. An
|
||||
alternative is to treat the function as a <A href="#with_function_objects">generic
|
||||
<p>Yes, if you <A href="#stdcall">#define BOOST_BIND_ENABLE_STDCALL</A>. An
|
||||
alternative is to treat the function as a <A href="#with_function_objects">generic
|
||||
function object</A> and use the <tt>bind<R>(f, ...)</tt> syntax.</p>
|
||||
<h3><a name="Q_com">Does <b>bind</b> work with COM methods?</a></h3>
|
||||
<p>Yes, if you <A href="#stdcall">#define BOOST_MEM_FN_ENABLE_STDCALL</A>.</p>
|
||||
<h3><a name="Q_mac">Does <b>bind</b> work with Mac toolbox functions?</a></h3>
|
||||
<p>Yes, if you <A href="#stdcall">#define BOOST_BIND_ENABLE_PASCAL</A>. An
|
||||
alternative is to treat the function as a <A href="#with_function_objects">generic
|
||||
<p>Yes, if you <A href="#stdcall">#define BOOST_BIND_ENABLE_PASCAL</A>. An
|
||||
alternative is to treat the function as a <A href="#with_function_objects">generic
|
||||
function object</A> and use the <tt>bind<R>(f, ...)</tt> syntax.</p>
|
||||
<h3><a name="Q_extern_C">Does <b>bind</b> work with extern "C" functions?</a></h3>
|
||||
<p>Sometimes. On some platforms, pointers to extern "C" functions are equivalent to
|
||||
"ordinary" function pointers, so they work fine. Other platforms treat them as
|
||||
different types. A platform-specific implementation of <b>bind</b> is expected
|
||||
to handle the problem transparently; this implementation does not. As usual,
|
||||
the workaround is to treat the function as a <A href="#with_function_objects">generic
|
||||
<p>Sometimes. On some platforms, pointers to extern "C" functions are equivalent to
|
||||
"ordinary" function pointers, so they work fine. Other platforms treat them as
|
||||
different types. A platform-specific implementation of <b>bind</b> is expected
|
||||
to handle the problem transparently; this implementation does not. As usual,
|
||||
the workaround is to treat the function as a <A href="#with_function_objects">generic
|
||||
function object</A> and use the <tt>bind<R>(f, ...)</tt> syntax.</p>
|
||||
<h3><a name="Q_auto_stdcall">Why doesn't <b>bind</b> automatically recognize
|
||||
<h3><a name="Q_auto_stdcall">Why doesn't <b>bind</b> automatically recognize
|
||||
nonstandard functions?</a></h3>
|
||||
<p>Non-portable extensions, in general, should default to off to prevent vendor
|
||||
lock-in. Had the <A href="#stdcall">appropriate macros</A> been defined
|
||||
automatically, you could have accidentally taken advantage of them without
|
||||
realizing that your code is, perhaps, no longer portable. In addition, some
|
||||
compilers have the option to make <b>__stdcall</b> (<STRONG>__fastcall</STRONG>)
|
||||
their default calling convention, in which case no separate support would be
|
||||
<p>Non-portable extensions, in general, should default to off to prevent vendor
|
||||
lock-in. Had the <A href="#stdcall">appropriate macros</A> been defined
|
||||
automatically, you could have accidentally taken advantage of them without
|
||||
realizing that your code is, perhaps, no longer portable. In addition, some
|
||||
compilers have the option to make <b>__stdcall</b> (<STRONG>__fastcall</STRONG>)
|
||||
their default calling convention, in which case no separate support would be
|
||||
necessary.</p>
|
||||
<h2><a name="Troubleshooting">Troubleshooting</a></h2>
|
||||
<h3><a name="err_num_args">Incorrect number of arguments</a></h3>
|
||||
<p>In a <tt>bind(f, a1, a2, ..., aN)</tt> expression, the function object <b>f</b> must
|
||||
be able to take exactly <b>N</b> arguments. This error is normally detected at
|
||||
"bind time"; in other words, the compilation error is reported on the line
|
||||
<p>In a <tt>bind(f, a1, a2, ..., aN)</tt> expression, the function object <b>f</b> must
|
||||
be able to take exactly <b>N</b> arguments. This error is normally detected at
|
||||
"bind time"; in other words, the compilation error is reported on the line
|
||||
where bind() is invoked:</p>
|
||||
<pre>int f(int, int);
|
||||
|
||||
@@ -453,7 +426,7 @@ int main()
|
||||
boost::bind(f, 1, 2); // OK
|
||||
}
|
||||
</pre>
|
||||
<p>A common variation of this error is to forget that member functions have an
|
||||
<p>A common variation of this error is to forget that member functions have an
|
||||
implicit "this" argument:</p>
|
||||
<pre>struct X
|
||||
{
|
||||
@@ -463,13 +436,13 @@ int main()
|
||||
int main()
|
||||
{
|
||||
boost::bind(&X::f, 1); // error, X::f takes two arguments
|
||||
boost::bind(&X::f, <b>_1</b>, 1); // OK
|
||||
boost::bind(&X::f, <b>_1</B>, 1); // OK
|
||||
}
|
||||
</pre>
|
||||
<h3><a name="err_signature">The function object cannot be called with the specified
|
||||
<h3><a name="err_signature">The function object cannot be called with the specified
|
||||
arguments</a></h3>
|
||||
<p>As in normal function calls, the function object that is bound must be
|
||||
compatible with the argument list. The incompatibility will usually be detected
|
||||
<p>As in normal function calls, the function object that is bound must be
|
||||
compatible with the argument list. The incompatibility will usually be detected
|
||||
by the compiler at "call time" and the result is typically an error in <b>bind.hpp</b>
|
||||
on a line that looks like:</p>
|
||||
<pre> return f(a[a1_], a[a2_]);
|
||||
@@ -486,8 +459,8 @@ int main()
|
||||
}
|
||||
</pre>
|
||||
<h3><a name="err_arg_access">Accessing an argument that does not exist</a></h3>
|
||||
<p>The placeholder <b>_N</b> selects the argument at position <b>N</b> from the
|
||||
argument list passed at "call time." Naturally, it is an error to attempt to
|
||||
<p>The placeholder <b>_N</b> selects the argument at position <b>N</b> from the
|
||||
argument list passed at "call time." Naturally, it is an error to attempt to
|
||||
access beyond the end of this list:</p>
|
||||
<pre>int f(int);
|
||||
|
||||
@@ -500,37 +473,37 @@ int main()
|
||||
<p>The error is usually reported in <b>bind.hpp</b>, at a line similar to:</p>
|
||||
<pre> return f(a[a1_]);
|
||||
</pre>
|
||||
<p>When emulating <tt>std::bind1st(f, a)</tt>, a common mistake of this category is
|
||||
<p>When emulating <tt>std::bind1st(f, a)</tt>, a common mistake of this category is
|
||||
to type <tt>bind(f, a, _2)</tt> instead of the correct <tt>bind(f, a, _1)</tt>.</p>
|
||||
<h3><a name="err_short_form">Inappropriate use of bind(f, ...)</a></h3>
|
||||
<p>The <tt>bind(f, a1, a2, ..., aN)</tt> <A href="#Q_forms">form</A> causes
|
||||
automatic recognition of the type of <b>f</b>. It will not work with arbitrary
|
||||
<p>The <tt>bind(f, a1, a2, ..., aN)</tt> <A href="#Q_forms">form</A> causes
|
||||
automatic recognition of the type of <b>f</b>. It will not work with arbitrary
|
||||
function objects; <b>f</b> must be a function or a member function pointer.</p>
|
||||
<p>It is possible to use this form with function objects that define <b>result_type</b>,
|
||||
but <b>only on compilers</b> that support partial specialization and partial
|
||||
ordering. In particular, MSVC up to version 7.0 does not support this syntax
|
||||
<p>It is possible to use this form with function objects that define <b>result_type</b>,
|
||||
but <b>only on compilers</b> that support partial specialization and partial
|
||||
ordering. In particular, MSVC up to version 7.0 does not support this syntax
|
||||
for function objects.</p>
|
||||
<h3><a name="err_long_form">Inappropriate use of bind<R>(f, ...)</a></h3>
|
||||
<p>The <tt>bind<R>(f, a1, a2, ..., aN)</tt> <A href="#Q_forms">form</A> supports
|
||||
<p>The <tt>bind<R>(f, a1, a2, ..., aN)</tt> <A href="#Q_forms">form</A> supports
|
||||
arbitrary function objects.</p>
|
||||
<p>It is possible (but not recommended) to use this form with functions or member
|
||||
function pointers, but <b>only on compilers</b> that support partial ordering.
|
||||
In particular, MSVC up to version 7.0 does not fully support this syntax for
|
||||
<p>It is possible (but not recommended) to use this form with functions or member
|
||||
function pointers, but <b>only on compilers</b> that support partial ordering.
|
||||
In particular, MSVC up to version 7.0 does not fully support this syntax for
|
||||
functions and member function pointers.</p>
|
||||
<h3><a name="err_nonstd">Binding a nonstandard function</a></h3>
|
||||
<p>By default, the <tt>bind(f, a1, a2, ..., aN)</tt> <A href="#Q_forms">form</A> recognizes
|
||||
"ordinary" C++ functions and function pointers. <A href="#stdcall">Functions that
|
||||
use a different calling convention</A>, or variable-argument functions such
|
||||
as <STRONG>std::printf</STRONG>, do not work. The general <tt>bind<R>(f, a1,
|
||||
a2, ..., aN)</tt> <A href="#Q_forms">form</A> works with nonstandard
|
||||
<p>By default, the <tt>bind(f, a1, a2, ..., aN)</tt> <A href="#Q_forms">form</A> recognizes
|
||||
"ordinary" C++ functions and function pointers. <A href="#stdcall">Functions that
|
||||
use a different calling convention</A>, or variable-argument functions such
|
||||
as <STRONG>std::printf</STRONG>, do not work. The general <tt>bind<R>(f, a1,
|
||||
a2, ..., aN)</tt> <A href="#Q_forms">form</A> works with nonstandard
|
||||
functions.
|
||||
</p>
|
||||
<p>On some platforms, extern "C" functions, like <b>std::strcmp</b>, are not
|
||||
<p>On some platforms, extern "C" functions, like <b>std::strcmp</b>, are not
|
||||
recognized by the short form of bind.
|
||||
</p>
|
||||
<P>See also <A href="#stdcall">"__stdcall" and "pascal" Support</A>.</P>
|
||||
<h3><a name="err_const_arg"><b>const</b> in signatures</a></h3>
|
||||
<p>Some compilers, including MSVC 6.0 and Borland C++ 5.5.1, have problems with the
|
||||
<p>Some compilers, including MSVC 6.0 and Borland C++ 5.5.1, have problems with the
|
||||
top-level <b>const</b> in function signatures:
|
||||
</p>
|
||||
<pre>int f(int const);
|
||||
@@ -543,27 +516,27 @@ int main()
|
||||
<p>Workaround: remove the <b>const</b> qualifier from the argument.
|
||||
</p>
|
||||
<h3><a name="err_msvc_using">MSVC specific: using boost::bind;</a></h3>
|
||||
<p>On MSVC (up to version 7.0), when <b>boost::bind</b> is brought into scope with
|
||||
<p>On MSVC (up to version 7.0), when <b>boost::bind</b> is brought into scope with
|
||||
an using declaration:
|
||||
</p>
|
||||
<pre>using boost::bind;
|
||||
</pre>
|
||||
<p>the syntax <tt>bind<R>(f, ...)</tt> does not work. Workaround: either use
|
||||
<p>the syntax <tt>bind<R>(f, ...)</tt> does not work. Workaround: either use
|
||||
the qualified name, <b>boost::bind</b>, or use an using directive instead:
|
||||
</p>
|
||||
<pre>using namespace boost;
|
||||
</pre>
|
||||
<h3><a name="err_msvc_class_template">MSVC specific: class templates shadow function
|
||||
<h3><a name="err_msvc_class_template">MSVC specific: class templates shadow function
|
||||
templates</a></h3>
|
||||
<p>On MSVC (up to version 7.0), a nested class template named <b>bind</b> will
|
||||
shadow the function template <b>boost::bind</b>, breaking the <tt>bind<R>(f,
|
||||
...)</tt> syntax. Unfortunately, some libraries contain nested class
|
||||
templates named <b>bind</b> (ironically, such code is often an MSVC specific
|
||||
<p>On MSVC (up to version 7.0), a nested class template named <b>bind</b> will
|
||||
shadow the function template <b>boost::bind</b>, breaking the <tt>bind<R>(f,
|
||||
...)</tt> syntax. Unfortunately, some libraries contain nested class
|
||||
templates named <b>bind</b> (ironically, such code is often an MSVC specific
|
||||
workaround.)</p>
|
||||
<P>The workaround is to use the alternative <tt>bind(type<R>(), f, ...)</tt> syntax.</P>
|
||||
<h3><a name="err_msvc_ellipsis">MSVC specific: ... in signatures treated as type</a></h3>
|
||||
<p>MSVC (up to version 7.0) treats the ellipsis in a variable argument function
|
||||
(such as <b>std::printf</b>) as a type. Therefore, it will accept the
|
||||
<p>MSVC (up to version 7.0) treats the ellipsis in a variable argument function
|
||||
(such as <b>std::printf</b>) as a type. Therefore, it will accept the
|
||||
(incorrect in the current implementation) form:
|
||||
</p>
|
||||
<pre> bind(printf, "%s\n", _1);
|
||||
@@ -579,37 +552,37 @@ int main()
|
||||
|
||||
// no arguments
|
||||
|
||||
template<class R, class F> <i>unspecified-1</i> <A href="#bind_1" >bind</A>(F f);
|
||||
template<class R, class F> <i>unspecified-1</I> <A href="#bind_1" >bind</A>(F f);
|
||||
|
||||
template<class F> <i>unspecified-1-1</i> <A href="#bind_1_1" >bind</A>(F f);
|
||||
template<class F> <i>unspecified-1-1</I> <A href="#bind_1_1" >bind</A>(F f);
|
||||
|
||||
template<class R> <i>unspecified-2</i> <A href="#bind_2" >bind</A>(R (*f) ());
|
||||
template<class R> <i>unspecified-2</I> <A href="#bind_2" >bind</A>(R (*f) ());
|
||||
|
||||
// one argument
|
||||
|
||||
template<class R, class F, class A1> <i>unspecified-3</i> <A href="#bind_3" >bind</A>(F f, A1 a1);
|
||||
template<class R, class F, class A1> <i>unspecified-3</I> <A href="#bind_3" >bind</A>(F f, A1 a1);
|
||||
|
||||
template<class F, class A1> <i>unspecified-3-1</i> <A href="#bind_3_1" >bind</A>(F f, A1 a1);
|
||||
template<class F, class A1> <i>unspecified-3-1</I> <A href="#bind_3_1" >bind</A>(F f, A1 a1);
|
||||
|
||||
template<class R, class B1, class A1> <i>unspecified-4</i> <A href="#bind_4" >bind</A>(R (*f) (B1), A1 a1);
|
||||
template<class R, class B1, class A1> <i>unspecified-4</I> <A href="#bind_4" >bind</A>(R (*f) (B1), A1 a1);
|
||||
|
||||
template<class R, class T, class A1> <i>unspecified-5</i> <A href="#bind_5" >bind</A>(R (T::*f) (), A1 a1);
|
||||
template<class R, class T, class A1> <i>unspecified-5</I> <A href="#bind_5" >bind</A>(R (T::*f) (), A1 a1);
|
||||
|
||||
template<class R, class T, class A1> <i>unspecified-6</i> <A href="#bind_6" >bind</A>(R (T::*f) () const, A1 a1);
|
||||
template<class R, class T, class A1> <i>unspecified-6</I> <A href="#bind_6" >bind</A>(R (T::*f) () const, A1 a1);
|
||||
|
||||
template<class R, class T, class A1> <i>unspecified-6-1</i> <A href="#bind_6_1" >bind</A>(R T::*f, A1 a1);
|
||||
template<class R, class T, class A1> <i>unspecified-6-1</I> <A href="#bind_6_1" >bind</A>(R T::*f, A1 a1);
|
||||
|
||||
// two arguments
|
||||
|
||||
template<class R, class F, class A1, class A2> <i>unspecified-7</i> <A href="#bind_7" >bind</A>(F f, A1 a1, A2 a2);
|
||||
template<class R, class F, class A1, class A2> <i>unspecified-7</I> <A href="#bind_7" >bind</A>(F f, A1 a1, A2 a2);
|
||||
|
||||
template<class F, class A1, class A2> <i>unspecified-7-1</i> <A href="#bind_7_1" >bind</A>(F f, A1 a1, A2 a2);
|
||||
template<class F, class A1, class A2> <i>unspecified-7-1</I> <A href="#bind_7_1" >bind</A>(F f, A1 a1, A2 a2);
|
||||
|
||||
template<class R, class B1, class B2, class A1, class A2> <i>unspecified-8</i> <A href="#bind_8" >bind</A>(R (*f) (B1, B2), A1 a1, A2 a2);
|
||||
template<class R, class B1, class B2, class A1, class A2> <i>unspecified-8</I> <A href="#bind_8" >bind</A>(R (*f) (B1, B2), A1 a1, A2 a2);
|
||||
|
||||
template<class R, class T, class B1, class A1, class A2> <i>unspecified-9</i> <A href="#bind_9" >bind</A>(R (T::*f) (B1), A1 a1, A2 a2);
|
||||
template<class R, class T, class B1, class A1, class A2> <i>unspecified-9</I> <A href="#bind_9" >bind</A>(R (T::*f) (B1), A1 a1, A2 a2);
|
||||
|
||||
template<class R, class T, class B1, class A1, class A2> <i>unspecified-10</i> <A href="#bind_10" >bind</A>(R (T::*f) (B1) const, A1 a1, A2 a2);
|
||||
template<class R, class T, class B1, class A1, class A2> <i>unspecified-10</I> <A href="#bind_10" >bind</A>(R (T::*f) (B1) const, A1 a1, A2 a2);
|
||||
|
||||
// implementation defined number of additional overloads for more arguments
|
||||
|
||||
@@ -618,11 +591,11 @@ template<class R, class T, class B1, class A1, class A2> <i>unspecified-10
|
||||
namespace
|
||||
{
|
||||
|
||||
<i>unspecified-placeholder-type-1</i> _1;
|
||||
<i>unspecified-placeholder-type-1</I> _1;
|
||||
|
||||
<i>unspecified-placeholder-type-2</i> _2;
|
||||
<i>unspecified-placeholder-type-2</I> _2;
|
||||
|
||||
<i>unspecified-placeholder-type-3</i> _3;
|
||||
<i>unspecified-placeholder-type-3</I> _3;
|
||||
|
||||
// implementation defined number of additional placeholder definitions
|
||||
|
||||
@@ -631,10 +604,10 @@ namespace
|
||||
<h3><a name="CommonRequirements">Common requirements</a></h3>
|
||||
<p>All <tt><i>unspecified-N</i></tt> types returned by <b>bind</b> are <b>CopyConstructible</b>.
|
||||
<tt><i>unspecified-N</i>::result_type</tt> is defined as the return type of <tt><i>unspecified-N</i>::operator()</tt>.</p>
|
||||
<p>All <tt><i>unspecified-placeholder-N</i></tt> types are <b>CopyConstructible</b>.
|
||||
<p>All <tt><i>unspecified-placeholder-N</i></tt> types are <b>CopyConstructible</b>.
|
||||
Their copy constructors do not throw exceptions.</p>
|
||||
<h3><a name="CommonDefinitions">Common definitions</a></h3>
|
||||
<p>The function µ(x, v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>), where m is
|
||||
<p>The function µ(x, v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>), where m is
|
||||
a nonnegative integer, is defined as:</p>
|
||||
<ul>
|
||||
<li>
|
||||
@@ -644,81 +617,81 @@ namespace
|
||||
v<sub>k</sub>, when <tt>x</tt>
|
||||
is (a copy of) the placeholder _k for some positive integer k;
|
||||
<li>
|
||||
<tt>x(v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>)</tt> when <tt>x</tt> is
|
||||
<tt>x(v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>)</tt> when <tt>x</tt> is
|
||||
(a copy of) a function object returned by <b>bind</b>;
|
||||
<li>
|
||||
<tt>x</tt> otherwise.</li></ul>
|
||||
<h3><a name="bind">bind</a></h3>
|
||||
<h4><a name="bind_1">template<class R, class F> <i>unspecified-1</i> bind(F f)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>()</tt>,
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>()</tt>,
|
||||
implicitly converted to <b>R</b>.</p>
|
||||
<p><b>Throws:</b> Nothing unless the copy constructor of <b>F</b> throws an
|
||||
<p><b>Throws:</b> Nothing unless the copy constructor of <b>F</b> throws an
|
||||
exception.</p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_1_1">template<class F> <i>unspecified-1-1</i> bind(F f)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<typename F::result_type, F>(f);</tt></p>
|
||||
<p><b>Notes:</b> Implementations are allowed to infer the return type of <b>f</b> via
|
||||
<p><b>Notes:</b> Implementations are allowed to infer the return type of <b>f</b> via
|
||||
other means as an extension, without relying on the <tt>result_type</tt> member.</p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_2">template<class R> <i>unspecified-2</i> bind(R (*f) ())</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>()</tt>.</p>
|
||||
<p><b>Throws:</b> Nothing.</p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_3">template<class R, class F, class A1> <i>unspecified-3</i> bind(F
|
||||
<h4><a name="bind_3">template<class R, class F, class A1> <i>unspecified-3</i> bind(F
|
||||
f, A1 a1)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>(µ(<b>a1</b>,
|
||||
v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>))</tt>, implicitly
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>(µ(<b>a1</b>,
|
||||
v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>))</tt>, implicitly
|
||||
converted to <b>R</b>.</p>
|
||||
<p><b>Throws:</b> Nothing unless the copy constructors of <b>F</b> or <b>A1</b> throw
|
||||
<p><b>Throws:</b> Nothing unless the copy constructors of <b>F</b> or <b>A1</b> throw
|
||||
an exception.</p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_3_1">template<class F, class A1> <i>unspecified-3-1</i> bind(F
|
||||
<h4><a name="bind_3_1">template<class F, class A1> <i>unspecified-3-1</i> bind(F
|
||||
f, A1 a1)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<typename F::result_type, F, A1>(f, a1);</tt></p>
|
||||
<p><b>Notes:</b> Implementations are allowed to infer the return type of <b>f</b> via
|
||||
<p><b>Notes:</b> Implementations are allowed to infer the return type of <b>f</b> via
|
||||
other means as an extension, without relying on the <tt>result_type</tt> member.</p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_4">template<class R, class B1, class A1> <i>unspecified-4</i> bind(R
|
||||
<h4><a name="bind_4">template<class R, class B1, class A1> <i>unspecified-4</i> bind(R
|
||||
(*f) (B1), A1 a1)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>(µ(<b>a1</b>,
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>(µ(<b>a1</b>,
|
||||
v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>))</tt>.</p>
|
||||
<p><b>Throws:</b> Nothing unless the copy constructor of <b>A1</b> throws an
|
||||
<p><b>Throws:</b> Nothing unless the copy constructor of <b>A1</b> throws an
|
||||
exception.</p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_5">template<class R, class T, class A1> <i>unspecified-5</i> bind(R
|
||||
<h4><a name="bind_5">template<class R, class T, class A1> <i>unspecified-5</i> bind(R
|
||||
(T::*f) (), A1 a1)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
a1);</tt></p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_6">template<class R, class T, class A1> <i>unspecified-6</i> bind(R
|
||||
<h4><a name="bind_6">template<class R, class T, class A1> <i>unspecified-6</i> bind(R
|
||||
(T::*f) () const, A1 a1)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
a1);</tt></p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_6_1">template<class R, class T, class A1> <i>unspecified-6-1</i>
|
||||
bind(R T::*f, A1 a1)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R const &>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
a1);</tt></p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_7">template<class R, class F, class A1, class A2> <i>unspecified-7</i>
|
||||
bind(F f, A1 a1, A2 a2)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>(µ(<b>a1</b>,
|
||||
v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>), µ(<b>a2</b>, v<sub>1</sub>,
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>(µ(<b>a1</b>,
|
||||
v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>), µ(<b>a2</b>, v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>))</tt>, implicitly converted to <b>R</b>.</p>
|
||||
<p><b>Throws:</b> Nothing unless the copy constructors of <b>F</b>, <b>A1</b> or <b>A2</b>
|
||||
throw an exception.</p>
|
||||
@@ -726,35 +699,35 @@ namespace
|
||||
<h4><a name="bind_7_1">template<class F, class A1, class A2> <i>unspecified-7-1</i>
|
||||
bind(F f, A1 a1, A2 a2)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<typename F::result_type, F, A1, A2>(f,
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<typename F::result_type, F, A1, A2>(f,
|
||||
a1, a2);</tt></p>
|
||||
<p><b>Notes:</b> Implementations are allowed to infer the return type of <b>f</b> via
|
||||
<p><b>Notes:</b> Implementations are allowed to infer the return type of <b>f</b> via
|
||||
other means as an extension, without relying on the <tt>result_type</tt> member.</p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_8">template<class R, class B1, class B2, class A1, class A2> <i>unspecified-8</i>
|
||||
bind(R (*f) (B1, B2), A1 a1, A2 a2)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>(µ(<b>a1</b>,
|
||||
v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>), µ(<b>a2</b>, v<sub>1</sub>,
|
||||
<p><b>Returns:</b> A function object <i>λ</i> such that the expression <tt>λ(v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>)</tt> is equivalent to <tt><b>f</b>(µ(<b>a1</b>,
|
||||
v<sub>1</sub>, v<sub>2</sub>, ..., v<sub>m</sub>), µ(<b>a2</b>, v<sub>1</sub>,
|
||||
v<sub>2</sub>, ..., v<sub>m</sub>))</tt>.</p>
|
||||
<p><b>Throws:</b> Nothing unless the copy constructors of <b>A1</b> or <b>A2</b> throw
|
||||
<p><b>Throws:</b> Nothing unless the copy constructors of <b>A1</b> or <b>A2</b> throw
|
||||
an exception.</p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_9">template<class R, class T, class B1, class A1, class A2> <i>unspecified-9</i>
|
||||
bind(R (T::*f) (B1), A1 a1, A2 a2)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
a1, a2);</tt></p>
|
||||
</blockquote>
|
||||
<h4><a name="bind_10">template<class R, class T, class B1, class A1, class A2> <i>unspecified-10</i>
|
||||
bind(R (T::*f) (B1) const, A1 a1, A2 a2)</a></h4>
|
||||
<blockquote>
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
<p><b>Effects:</b> Equivalent to <tt>bind<R>(<A href="mem_fn.html">boost::mem_fn</A>(f),
|
||||
a1, a2);</tt></p>
|
||||
</blockquote>
|
||||
<h3><a name="AdditionalOverloads">Additional overloads</a></h3>
|
||||
<p>Implementations are allowed to provide additional <b>bind</b> overloads in order
|
||||
<p>Implementations are allowed to provide additional <b>bind</b> overloads in order
|
||||
to support more arguments or different function pointer variations.</p>
|
||||
<h2><a name="Implementation">Implementation</a></h2>
|
||||
<h3><a name="Files">Files</a></h3>
|
||||
@@ -784,7 +757,7 @@ namespace
|
||||
<A href="../../boost/bind/protect.hpp">boost/bind/protect.hpp</A> (<STRONG>protect</STRONG>
|
||||
helper function)
|
||||
<LI>
|
||||
<A href="../../boost/bind/make_adaptable.hpp">boost/bind/make_adaptable.hpp</A>
|
||||
<A href="../../boost/bind/make_adaptable.hpp">boost/bind/make_adaptable.hpp</A>
|
||||
(<STRONG>make_adaptable</STRONG>
|
||||
helper function)
|
||||
<li>
|
||||
@@ -811,28 +784,28 @@ namespace
|
||||
<h3><a name="Dependencies">Dependencies</a></h3>
|
||||
<ul>
|
||||
<li>
|
||||
<A href="../config/config.htm">Boost.Config</A>
|
||||
<A href="../config/config.htm">Boost.Config</A></li>
|
||||
<li>
|
||||
<A href="ref.html">boost/ref.hpp</A>
|
||||
<A href="ref.html">boost/ref.hpp</A></li>
|
||||
<li>
|
||||
<A href="mem_fn.html">boost/mem_fn.hpp</A>
|
||||
<A href="mem_fn.html">boost/mem_fn.hpp</A></li>
|
||||
<li>
|
||||
<A href="../../boost/type.hpp">boost/type.hpp</A></li>
|
||||
</ul>
|
||||
<h3><a name="NumberOfArguments">Number of Arguments</a></h3>
|
||||
<p>This implementation supports function objects with up to nine arguments. This is
|
||||
<p>This implementation supports function objects with up to nine arguments. This is
|
||||
an implementation detail, not an inherent limitation of the design.</p>
|
||||
<h3><a name="stdcall">"__stdcall", "__cdecl", "__fastcall", and "pascal" Support</a></h3>
|
||||
<p>Some platforms allow several types of (member) functions that differ by their <b>calling
|
||||
convention</b> (the rules by which the function is invoked: how are
|
||||
arguments passed, how is the return value handled, and who cleans up the stack
|
||||
<h3><a name="stdcall">"__stdcall", "__fastcall", and "pascal" Support</a></h3>
|
||||
<p>Some platforms allow several types of (member) functions that differ by their <b>calling
|
||||
convention</b> (the rules by which the function is invoked: how are
|
||||
arguments passed, how is the return value handled, and who cleans up the stack
|
||||
- if any.)</p>
|
||||
<p>For example, Windows API functions and COM interface member functions use a
|
||||
calling convention known as <b>__stdcall</b>.Borland VCL components use <STRONG>__fastcall</STRONG>.
|
||||
<p>For example, Windows API functions and COM interface member functions use a
|
||||
calling convention known as <b>__stdcall</b>.Borland VCL components use <STRONG>__fastcall</STRONG>.
|
||||
Mac toolbox functions use a <b>pascal</b> calling convention.</p>
|
||||
<p>To use <b>bind</b> with <b>__stdcall</b> functions, <b>#define</b> the macro <b>BOOST_BIND_ENABLE_STDCALL</b>
|
||||
before including <b><boost/bind.hpp></b>.</p>
|
||||
<p>To use <b>bind</b> with <b>__stdcall</b> <b>member</b> functions, <b>#define</b>
|
||||
<p>To use <b>bind</b> with <b>__stdcall</b> <b>member</b> functions, <b>#define</b>
|
||||
the macro <b>BOOST_MEM_FN_ENABLE_STDCALL</b> before including <b><boost/bind.hpp></b>.</p>
|
||||
<P>To use <B>bind</B> with <B>__fastcall</B> functions, <B>#define</B> the macro <B>BOOST_BIND_ENABLE_FASTCALL</B>
|
||||
before including <B><boost/bind.hpp></B>.</P>
|
||||
@@ -840,16 +813,10 @@ namespace
|
||||
the macro <B>BOOST_MEM_FN_ENABLE_FASTCALL</B> before including <B><boost/bind.hpp></B>.</P>
|
||||
<P>To use <b>bind</b> with <b>pascal</b> functions, <b>#define</b> the macro <b>BOOST_BIND_ENABLE_PASCAL</b>
|
||||
before including <b><boost/bind.hpp></b>.</P>
|
||||
<P>To use <B>bind</B> with <B>__cdecl</B> <B>member</B> functions, <B>#define</B> the
|
||||
macro <B>BOOST_MEM_FN_ENABLE_CDECL</B> before including <B><boost/bind.hpp></B>.</P>
|
||||
<P><STRONG>It is best to define these macros in the project options, via -D on the
|
||||
command line, or as the first line in the translation unit (.cpp file) where
|
||||
bind is used.</STRONG> Not following this rule can lead to obscure errors
|
||||
when a header includes bind.hpp before the macro has been defined.</P>
|
||||
<p>[Note: this is a non-portable extension. It is not part of the interface.]</p>
|
||||
<p>[Note: Some compilers provide only minimal support for the <b>__stdcall</b> keyword.]</p>
|
||||
<h3><a name="visit_each"><b>visit_each</b> support</a></h3>
|
||||
<p>Function objects returned by <b>bind</b> support the experimental and
|
||||
<p>Function objects returned by <b>bind</b> support the experimental and
|
||||
undocumented, as of yet, <b>visit_each</b> enumeration interface.</p>
|
||||
<p>See <A href="bind_visitor.cpp">bind_visitor.cpp</A> for an example.</p>
|
||||
<h2><a name="Acknowledgements">Acknowledgements</a></h2>
|
||||
@@ -859,41 +826,40 @@ namespace
|
||||
The <a href="http://staff.cs.utu.fi/BL/">Binder Library</a>
|
||||
by Jaakko Järvi;
|
||||
<li>
|
||||
The <a href="../lambda/">Lambda Library</a>
|
||||
(now part of Boost) by Jaakko Järvi and Gary Powell (the successor to the
|
||||
Binder Library);
|
||||
The <a href="../lambda/">Lambda Library</a> (now part of Boost)
|
||||
by Jaakko Järvi and Gary Powell (the successor to the Binder Library);
|
||||
<li>
|
||||
<a href="http://more.sourceforge.net/">Extensions to the
|
||||
<a href="http://matfys.lth.se/~petter/src/more/stlext/index.html">Extensions to the
|
||||
STL</a> by Petter Urkedal.</li></ul>
|
||||
<p>Doug Gregor suggested that a visitor mechanism would allow <b>bind</b> to
|
||||
<p>Doug Gregor suggested that a visitor mechanism would allow <b>bind</b> to
|
||||
interoperate with a signal/slot library.</p>
|
||||
<p>John Maddock fixed a MSVC-specific conflict between <b>bind</b> and the <A href="../type_traits/index.html">
|
||||
<p>John Maddock fixed a MSVC-specific conflict between <b>bind</b> and the <A href="../type_traits/index.htm">
|
||||
type traits library</A>.</p>
|
||||
<p>Numerous improvements were suggested during the formal review period by Ross
|
||||
Smith, Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager was
|
||||
<p>Numerous improvements were suggested during the formal review period by Ross
|
||||
Smith, Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager was
|
||||
Darin Adler.
|
||||
</p>
|
||||
<p>The precise semantics of <b>bind</b> were refined in discussions with Jaakko
|
||||
<p>The precise semantics of <b>bind</b> were refined in discussions with Jaakko
|
||||
Järvi.
|
||||
</p>
|
||||
<p>Dave Abrahams fixed a MSVC-specific conflict between <b>bind</b> and the <A href="../utility/iterator_adaptors.htm">
|
||||
iterator adaptors library</A>.
|
||||
</p>
|
||||
<p>Dave Abrahams modified <b>bind</b> and <b>mem_fn</b> to support void returns on
|
||||
<p>Dave Abrahams modified <b>bind</b> and <b>mem_fn</b> to support void returns on
|
||||
deficient compilers.
|
||||
</p>
|
||||
<p>Mac Murrett contributed the "pascal" support enabled by
|
||||
<p>Mac Murrett contributed the "pascal" support enabled by
|
||||
BOOST_BIND_ENABLE_PASCAL.
|
||||
</p>
|
||||
<p>The alternative <tt>bind(type<R>(), f, ...)</tt> syntax was inspired by a
|
||||
<p>The alternative <tt>bind(type<R>(), f, ...)</tt> syntax was inspired by a
|
||||
discussion with Dave Abrahams and Joel de Guzman.</p>
|
||||
<p><br>
|
||||
<br>
|
||||
<br>
|
||||
<small>Copyright © 2001, 2002 by Peter Dimov and Multi Media Ltd. Copyright
|
||||
2003-2005 Peter Dimov. Permission to copy, use, modify, sell and distribute
|
||||
this document is granted provided this copyright notice appears in all copies.
|
||||
This document is provided "as is" without express or implied warranty, and with
|
||||
no claim as to its suitability for any purpose.</small></p>
|
||||
<small>Copyright © 2001, 2002 by Peter Dimov and Multi Media Ltd. Permission to
|
||||
copy, use, modify, sell and distribute this document is granted provided this
|
||||
copyright notice appears in all copies. This document is provided "as is"
|
||||
without express or implied warranty, and with no claim as to its suitability
|
||||
for any purpose.</small></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -14,9 +12,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
242
doc/ref.xml
242
doc/ref.xml
@@ -1,242 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<library name="Ref" dirname="ref" id="ref" last-revision="$Date$">
|
||||
<libraryinfo>
|
||||
<author>
|
||||
<firstname>Jaakko</firstname>
|
||||
<surname>Järvi</surname>
|
||||
</author>
|
||||
<author>
|
||||
<firstname>Peter</firstname>
|
||||
<surname>Dimov</surname>
|
||||
</author>
|
||||
<author>
|
||||
<firstname>Douglas</firstname>
|
||||
<surname>Gregor</surname>
|
||||
</author>
|
||||
<author>
|
||||
<firstname>Dave</firstname>
|
||||
<surname>Abrahams</surname>
|
||||
</author>
|
||||
|
||||
<copyright>
|
||||
<year>1999</year>
|
||||
<year>2000</year>
|
||||
<holder>Jaakko Järvi</holder>
|
||||
</copyright>
|
||||
|
||||
<copyright>
|
||||
<year>2001</year>
|
||||
<year>2002</year>
|
||||
<holder>Peter Dimov</holder>
|
||||
</copyright>
|
||||
|
||||
<copyright>
|
||||
<year>2002</year>
|
||||
<holder>David Abrahams</holder>
|
||||
</copyright>
|
||||
|
||||
<legalnotice>
|
||||
<para>Permission to copy, use, modify, sell and distribute this
|
||||
software is granted provided this copyright notice appears in
|
||||
all copies. This software is provided "as is" without express
|
||||
or implied warranty, and with no claim as to its suitability for
|
||||
any purpose.
|
||||
</para>
|
||||
</legalnotice>
|
||||
|
||||
<librarypurpose>A utility library for passing references to generic functions</librarypurpose>
|
||||
<librarycategory name="category:higher-order"/>
|
||||
</libraryinfo>
|
||||
|
||||
<title>Boost.Ref</title>
|
||||
|
||||
<section id="ref.intro">
|
||||
<title>Introduction</title>
|
||||
|
||||
<using-namespace name="boost"/>
|
||||
|
||||
<para>The Ref library is a small library that is useful for passing
|
||||
references to function templates (algorithms) that would usually
|
||||
take copies of their arguments. It defines the class template
|
||||
<code><classname>boost::reference_wrapper<T></classname></code>,
|
||||
the two functions
|
||||
<code><functionname>boost::ref</functionname></code> and
|
||||
<code><functionname>boost::cref</functionname></code> that return
|
||||
instances of <code>boost::reference_wrapper<T></code>, and the
|
||||
two traits classes
|
||||
<code><classname>boost::is_reference_wrapper<T></classname></code>
|
||||
and
|
||||
<code><classname>boost::unwrap_reference<T></classname></code>.</para>
|
||||
|
||||
<para>The purpose of
|
||||
<code>boost::reference_wrapper<T></code> is to
|
||||
contain a reference to an object of type T. It is primarily used to
|
||||
"feed" references to function templates (algorithms) that take their
|
||||
parameter by value.</para>
|
||||
|
||||
<para>To support this usage,
|
||||
<code>boost::reference_wrapper<T></code> provides an implicit
|
||||
conversion to <code>T&</code>. This usually allows the function
|
||||
templates to work on references unmodified.</para>
|
||||
|
||||
<para><code>boost::reference_wrapper<T></code> is
|
||||
both CopyConstructible and Assignable (ordinary references are not
|
||||
Assignable).</para>
|
||||
|
||||
<para>The expression <code>boost::ref(x)</code>
|
||||
returns a
|
||||
<code>boost::reference_wrapper<X>(x)</code> where X
|
||||
is the type of x. Similarly,
|
||||
<code>boost::cref(x)</code> returns a
|
||||
<code>boost::reference_wrapper<X const>(x)</code>.</para>
|
||||
|
||||
<para>The expression
|
||||
<code>boost::is_reference_wrapper<T>::value</code>
|
||||
is true if T is a <code>reference_wrapper</code>, and
|
||||
false otherwise.</para>
|
||||
|
||||
<para>The type-expression
|
||||
<code>boost::unwrap_reference<T>::type</code> is T::type if T
|
||||
is a <code>reference_wrapper</code>, T otherwise.</para>
|
||||
</section>
|
||||
|
||||
<library-reference>
|
||||
<header name="boost/ref.hpp">
|
||||
<namespace name="boost">
|
||||
<class name="reference_wrapper">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
</template>
|
||||
<purpose>
|
||||
Contains a reference to an object of type
|
||||
<computeroutput>T</computeroutput>.
|
||||
</purpose>
|
||||
|
||||
<description>
|
||||
<para><computeroutput><classname>reference_wrapper</classname></computeroutput>
|
||||
is primarily used to "feed" references to function templates
|
||||
(algorithms) that take their parameter by value. It provides
|
||||
an implicit conversion to
|
||||
<computeroutput>T&</computeroutput>, which usually allows
|
||||
the function templates to work on references
|
||||
unmodified.</para>
|
||||
</description>
|
||||
|
||||
<typedef name="type"><type>T</type></typedef>
|
||||
|
||||
<constructor specifiers="explicit">
|
||||
<parameter name="t">
|
||||
<paramtype>T&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<effects><simpara>Constructs a
|
||||
<computeroutput><classname>reference_wrapper</classname></computeroutput>
|
||||
object that stores a reference to
|
||||
<computeroutput>t</computeroutput>.</simpara></effects>
|
||||
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<method-group name="access">
|
||||
<method name="conversion-operator" cv="const">
|
||||
<type>T&</type>
|
||||
<returns><simpara>The stored reference.</simpara></returns>
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="get" cv="const">
|
||||
<type>T&</type>
|
||||
<returns><simpara>The stored reference.</simpara></returns>
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="get_pointer" cv="const">
|
||||
<type>T*</type>
|
||||
<returns><simpara>A pointer to the object referenced by the stored reference.</simpara></returns>
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<free-function-group name="constructors">
|
||||
<function name="ref">
|
||||
<type>reference_wrapper<T></type>
|
||||
<parameter name="t">
|
||||
<paramtype>T&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><computeroutput><classname>reference_wrapper</classname><T>(t)</computeroutput></simpara></returns>
|
||||
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</function>
|
||||
|
||||
<function name="cref">
|
||||
<type>reference_wrapper<T const></type>
|
||||
<parameter name="t">
|
||||
<paramtype>T const&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><computeroutput><classname>reference_wrapper</classname><T const>(t)</computeroutput></simpara></returns>
|
||||
|
||||
<throws><simpara>Does not throw.</simpara></throws>
|
||||
</function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
|
||||
<class name="is_reference_wrapper">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
</template>
|
||||
|
||||
<purpose>Determine if a type <computeroutput>T</computeroutput> is an instantiation of <computeroutput><classname>reference_wrapper</classname></computeroutput>.</purpose>
|
||||
|
||||
<description>
|
||||
<para>The <computeroutput>value</computeroutput> static
|
||||
constant will be <computeroutput>true</computeroutput> iff the
|
||||
type <computeroutput>T</computeroutput> is a specialization of
|
||||
<computeroutput><classname>reference_wrapper</classname></computeroutput>.</para>
|
||||
</description>
|
||||
|
||||
<static-constant name="value">
|
||||
<type>bool</type>
|
||||
<default><emphasis>unspecified</emphasis></default>
|
||||
</static-constant>
|
||||
</class>
|
||||
|
||||
<class name="unwrap_reference">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
</template>
|
||||
|
||||
<purpose>Find the type in a <computeroutput><classname>reference_wrapper</classname></computeroutput>.</purpose>
|
||||
|
||||
<description>
|
||||
<para>The typedef <computeroutput>type</computeroutput> is
|
||||
<computeroutput>T::type</computeroutput> if
|
||||
<computeroutput>T</computeroutput> is a
|
||||
<computeroutput><classname>reference_wrapper</classname></computeroutput>,
|
||||
<computeroutput>T</computeroutput> otherwise.</para>
|
||||
</description>
|
||||
|
||||
<typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef>
|
||||
</class>
|
||||
</namespace>
|
||||
</header>
|
||||
</library-reference>
|
||||
|
||||
<section id="ref.ack">
|
||||
<title>Acknowledgements</title>
|
||||
|
||||
<using-namespace name="boost"/>
|
||||
|
||||
<para><functionname>ref</functionname> and <functionname>cref</functionname>
|
||||
were originally part of the <libraryname>Tuple</libraryname> library
|
||||
by Jaakko Järvi. They were "promoted to boost:: status" by
|
||||
Peter Dimov because they are generally useful. Douglas Gregor and
|
||||
Dave Abrahams contributed
|
||||
<classname>is_reference_wrapper</classname> and
|
||||
<classname>unwrap_reference</classname>.</para>
|
||||
</section>
|
||||
|
||||
</library>
|
||||
File diff suppressed because it is too large
Load Diff
@@ -4,11 +4,12 @@
|
||||
//
|
||||
// apply.hpp
|
||||
//
|
||||
// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
namespace boost
|
||||
@@ -18,52 +19,52 @@ template<class R> struct apply
|
||||
{
|
||||
typedef R result_type;
|
||||
|
||||
template<class F> result_type operator()(F & f) const
|
||||
template<class F> result_type operator()(F f) const
|
||||
{
|
||||
return f();
|
||||
}
|
||||
|
||||
template<class F, class A1> result_type operator()(F & f, A1 & a1) const
|
||||
template<class F, class A1> result_type operator()(F f, A1 & a1) const
|
||||
{
|
||||
return f(a1);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2> result_type operator()(F & f, A1 & a1, A2 & a2) const
|
||||
template<class F, class A1, class A2> result_type operator()(F f, A1 & a1, A2 & a2) const
|
||||
{
|
||||
return f(a1, a2);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3) const
|
||||
template<class F, class A1, class A2, class A3> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3) const
|
||||
{
|
||||
return f(a1, a2, a3);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
|
||||
template<class F, class A1, class A2, class A3, class A4> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
|
||||
{
|
||||
return f(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
|
||||
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
|
||||
{
|
||||
return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
#ifndef BOOST_BIND_ARG_HPP_INCLUDED
|
||||
#define BOOST_BIND_ARG_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#if _MSC_VER >= 1020
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
//
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
@@ -26,11 +25,6 @@ template<int I> class arg
|
||||
{
|
||||
};
|
||||
|
||||
template<int I> bool operator==(arg<I> const &, arg<I> const &)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // #ifndef BOOST_BIND_ARG_HPP_INCLUDED
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
|
||||
@@ -3,11 +3,12 @@
|
||||
//
|
||||
// Do not include this header directly.
|
||||
//
|
||||
// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
@@ -17,131 +18,131 @@
|
||||
result_type operator()()
|
||||
{
|
||||
list0 a;
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
result_type operator()() const
|
||||
{
|
||||
list0 a;
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1> result_type operator()(A1 & a1)
|
||||
{
|
||||
list1<A1 &> a(a1);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1> result_type operator()(A1 & a1) const
|
||||
{
|
||||
list1<A1 &> a(a1);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
|
||||
{
|
||||
list2<A1 &, A2 &> a(a1, a2);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
|
||||
{
|
||||
list2<A1 &, A2 &> a(a1, a2);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
|
||||
{
|
||||
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
|
||||
{
|
||||
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
|
||||
{
|
||||
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
|
||||
{
|
||||
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
|
||||
{
|
||||
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
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
|
||||
{
|
||||
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
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
|
||||
{
|
||||
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
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
|
||||
{
|
||||
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
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
|
||||
{
|
||||
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
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
|
||||
{
|
||||
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A> result_type eval(A & a)
|
||||
{
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class A> result_type eval(A & a) const
|
||||
{
|
||||
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
|
||||
BOOST_BIND_EVALUATE;
|
||||
}
|
||||
|
||||
template<class V> void accept(V & v) const
|
||||
@@ -150,11 +151,6 @@
|
||||
l_.accept(v);
|
||||
}
|
||||
|
||||
bool compare(this_type const & rhs) const
|
||||
{
|
||||
return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
|
||||
@@ -6,9 +6,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
namespace boost
|
||||
@@ -17,6 +18,10 @@ namespace boost
|
||||
namespace _bi
|
||||
{
|
||||
|
||||
template<class F> void instantiate(F)
|
||||
{
|
||||
}
|
||||
|
||||
template<class R, class F> class af0
|
||||
{
|
||||
public:
|
||||
@@ -32,11 +37,6 @@ public:
|
||||
return f_();
|
||||
}
|
||||
|
||||
result_type operator()() const
|
||||
{
|
||||
return f_();
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -59,11 +59,6 @@ public:
|
||||
return f_(a1);
|
||||
}
|
||||
|
||||
result_type operator()(A1 a1) const
|
||||
{
|
||||
return f_(a1);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -88,11 +83,6 @@ public:
|
||||
return f_(a1, a2);
|
||||
}
|
||||
|
||||
result_type operator()(A1 a1, A2 a2) const
|
||||
{
|
||||
return f_(a1, a2);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -116,11 +106,6 @@ public:
|
||||
return f_(a1, a2, a3);
|
||||
}
|
||||
|
||||
result_type operator()(A1 a1, A2 a2, A3 a3) const
|
||||
{
|
||||
return f_(a1, a2, a3);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -145,11 +130,6 @@ public:
|
||||
return f_(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) const
|
||||
{
|
||||
return f_(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
F f_;
|
||||
@@ -159,26 +139,31 @@ private:
|
||||
|
||||
template<class R, class F> _bi::af0<R, F> make_adaptable(F f)
|
||||
{
|
||||
_bi::instantiate( &_bi::af0<R, F>::operator() ); // for early error detection
|
||||
return _bi::af0<R, F>(f);
|
||||
}
|
||||
|
||||
template<class R, class A1, class F> _bi::af1<R, A1, F> make_adaptable(F f)
|
||||
{
|
||||
instantiate( &_bi::af1<R, A1, F>::operator() );
|
||||
return _bi::af1<R, A1, F>(f);
|
||||
}
|
||||
|
||||
template<class R, class A1, class A2, class F> _bi::af2<R, A1, A2, F> make_adaptable(F f)
|
||||
{
|
||||
instantiate( &_bi::af2<R, A1, A2, F>::operator() );
|
||||
return _bi::af2<R, A1, A2, F>(f);
|
||||
}
|
||||
|
||||
template<class R, class A1, class A2, class A3, class F> _bi::af3<R, A1, A2, A3, F> make_adaptable(F f)
|
||||
{
|
||||
instantiate( &_bi::af3<R, A1, A2, A3, F>::operator() );
|
||||
return _bi::af3<R, A1, A2, A3, F>(f);
|
||||
}
|
||||
|
||||
template<class R, class A1, class A2, class A3, class A4, class F> _bi::af4<R, A1, A2, A3, A4, F> make_adaptable(F f)
|
||||
{
|
||||
instantiate( &_bi::af4<R, A1, A2, A3, A4, F>::operator() );
|
||||
return _bi::af4<R, A1, A2, A3, A4, F>(f);
|
||||
}
|
||||
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
|
||||
//
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
|
||||
//
|
||||
@@ -54,16 +55,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)();
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf0) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf0
|
||||
@@ -103,16 +94,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)();
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf1
|
||||
@@ -158,16 +139,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf1) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf1
|
||||
@@ -208,16 +179,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf2
|
||||
@@ -261,16 +222,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf2) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf2
|
||||
@@ -309,16 +260,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf3
|
||||
@@ -362,16 +303,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf3) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf3
|
||||
@@ -410,16 +341,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf4
|
||||
@@ -463,16 +384,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf4) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf4
|
||||
@@ -511,16 +422,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf5
|
||||
@@ -564,16 +465,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf5) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf5
|
||||
@@ -612,16 +503,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf6
|
||||
@@ -665,16 +546,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf6) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf6
|
||||
@@ -713,16 +584,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf7
|
||||
@@ -766,16 +627,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf7) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf7
|
||||
@@ -814,16 +665,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// mf8
|
||||
@@ -867,16 +708,6 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(mf8) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
// cmf8
|
||||
@@ -920,15 +751,5 @@ public:
|
||||
{
|
||||
BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -5,9 +5,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
|
||||
//
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
#ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
|
||||
#define BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#if _MSC_VER >= 1020
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
//
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/bind.html for documentation.
|
||||
//
|
||||
@@ -37,7 +36,7 @@ static inline boost::arg<7> _7() { return boost::arg<7>(); }
|
||||
static inline boost::arg<8> _8() { return boost::arg<8>(); }
|
||||
static inline boost::arg<9> _9() { return boost::arg<9>(); }
|
||||
|
||||
#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__)
|
||||
#elif (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__)
|
||||
|
||||
static boost::arg<1> _1;
|
||||
static boost::arg<2> _2;
|
||||
|
||||
@@ -6,9 +6,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
namespace boost
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
#ifndef BOOST_MEM_FN_HPP_INCLUDED
|
||||
#define BOOST_MEM_FN_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#if _MSC_VER+0 >= 1020
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
//
|
||||
@@ -12,18 +10,17 @@
|
||||
//
|
||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001 David Abrahams
|
||||
// Copyright (c) 2003-2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
|
||||
//
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/get_pointer.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
@@ -49,18 +46,6 @@ template<class V> struct mf
|
||||
#undef BOOST_MEM_FN_CC
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_CDECL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
|
||||
#define BOOST_MEM_FN_CC __cdecl
|
||||
|
||||
#include <boost/bind/mem_fn_template.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_CC
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_STDCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
|
||||
@@ -102,18 +87,6 @@ template<> struct mf<void>
|
||||
#undef BOOST_MEM_FN_CC
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_CDECL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
|
||||
#define BOOST_MEM_FN_CC __cdecl
|
||||
|
||||
#include <boost/bind/mem_fn_template.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_CC
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_STDCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
|
||||
@@ -155,20 +128,6 @@ template<> struct mf<void>
|
||||
#undef BOOST_MEM_FN_NAME2
|
||||
#undef BOOST_MEM_FN_CC
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_CDECL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) X##_cdecl
|
||||
#define BOOST_MEM_FN_NAME2(X) inner_##X##_cdecl
|
||||
#define BOOST_MEM_FN_CC __cdecl
|
||||
|
||||
#include <boost/bind/mem_fn_vw.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
#undef BOOST_MEM_FN_NAME2
|
||||
#undef BOOST_MEM_FN_CC
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_STDCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) X##_stdcall
|
||||
@@ -217,18 +176,6 @@ namespace _mfi
|
||||
#undef BOOST_MEM_FN_CC
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_CDECL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) X##_cdecl
|
||||
#define BOOST_MEM_FN_CC __cdecl
|
||||
|
||||
#include <boost/bind/mem_fn_template.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_CC
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_STDCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) X##_stdcall
|
||||
@@ -270,18 +217,6 @@ namespace _mfi
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
#undef BOOST_MEM_FN_CC
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_CDECL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) X##_cdecl
|
||||
#define BOOST_MEM_FN_CC __cdecl
|
||||
|
||||
#include <boost/bind/mem_fn_cc.hpp>
|
||||
|
||||
#undef BOOST_MEM_FN_NAME
|
||||
#undef BOOST_MEM_FN_CC
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MEM_FN_ENABLE_STDCALL
|
||||
|
||||
#define BOOST_MEM_FN_NAME(X) X##_stdcall
|
||||
@@ -357,7 +292,7 @@ public:
|
||||
return call(u, &u);
|
||||
}
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__MWERKS__, < 0x3200)
|
||||
#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
|
||||
|
||||
R & operator()(T & t) const
|
||||
{
|
||||
@@ -370,16 +305,6 @@ public:
|
||||
{
|
||||
return (t.*f_);
|
||||
}
|
||||
|
||||
bool operator==(dm const & rhs) const
|
||||
{
|
||||
return f_ == rhs.f_;
|
||||
}
|
||||
|
||||
bool operator!=(dm const & rhs) const
|
||||
{
|
||||
return f_ != rhs.f_;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace _mfi
|
||||
|
||||
17
test/Jamfile
17
test/Jamfile
@@ -1,6 +1,6 @@
|
||||
# Boost.Bind Library test Jamfile
|
||||
#
|
||||
# Copyright (c) 2003-2005 Peter Dimov
|
||||
# Copyright (c) 2003 Peter Dimov
|
||||
#
|
||||
# Permission to copy, use, modify, sell and distribute this software
|
||||
# is granted provided this copyright notice appears in all copies.
|
||||
@@ -10,7 +10,8 @@
|
||||
subproject libs/bind/test ;
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
|
||||
include testing.jam ;
|
||||
|
||||
# Make tests run by default.
|
||||
DEPENDS all : bind ;
|
||||
@@ -18,20 +19,8 @@ DEPENDS all : bind ;
|
||||
{
|
||||
test-suite "bind"
|
||||
: [ run bind_test.cpp ]
|
||||
[ run bind_dm_test.cpp ]
|
||||
[ run bind_eq_test.cpp ]
|
||||
[ run bind_const_test.cpp ]
|
||||
[ run bind_cv_test.cpp ]
|
||||
[ run bind_stateful_test.cpp ]
|
||||
[ run bind_dm2_test.cpp ]
|
||||
[ run bind_not_test.cpp ]
|
||||
[ run bind_rel_test.cpp ]
|
||||
[ run bind_function_test.cpp ]
|
||||
[ run bind_lookup_problem_test.cpp ]
|
||||
[ run mem_fn_test.cpp ]
|
||||
[ run mem_fn_void_test.cpp ]
|
||||
[ run mem_fn_derived_test.cpp ]
|
||||
[ run mem_fn_eq_test.cpp ]
|
||||
[ run mem_fn_dm_test.cpp ]
|
||||
;
|
||||
}
|
||||
|
||||
@@ -1,30 +0,0 @@
|
||||
# Boost.Bind Library test Jamfile
|
||||
#
|
||||
# Copyright (c) 2003-2005 Peter Dimov
|
||||
#
|
||||
# Permission to copy, use, modify, sell and distribute this software
|
||||
# is granted provided this copyright notice appears in all copies.
|
||||
# This software is provided "as is" without express or implied
|
||||
# warranty, and with no claim as to its suitability for any purpose.
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
|
||||
test-suite "bind"
|
||||
: [ run bind_test.cpp ]
|
||||
[ run bind_dm_test.cpp ]
|
||||
[ run bind_eq_test.cpp ]
|
||||
[ run bind_const_test.cpp ]
|
||||
[ run bind_cv_test.cpp ]
|
||||
[ run bind_stateful_test.cpp ]
|
||||
[ run bind_dm2_test.cpp ]
|
||||
[ run bind_not_test.cpp ]
|
||||
[ run bind_rel_test.cpp ]
|
||||
[ run bind_function_test.cpp ]
|
||||
[ run bind_lookup_problem_test.cpp ]
|
||||
[ run mem_fn_test.cpp ]
|
||||
[ run mem_fn_void_test.cpp ]
|
||||
[ run mem_fn_derived_test.cpp ]
|
||||
[ run mem_fn_eq_test.cpp ]
|
||||
[ run mem_fn_dm_test.cpp ]
|
||||
;
|
||||
@@ -1,164 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_cdecl_mf_test.cpp - test for bind.hpp + __cdecl (member functions)
|
||||
//
|
||||
// Copyright (c) 2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#define BOOST_MEM_FN_ENABLE_CDECL
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
mutable unsigned int hash;
|
||||
|
||||
X(): hash(0) {}
|
||||
|
||||
int __cdecl f0() { f1(17); return 0; }
|
||||
int __cdecl g0() const { g1(17); return 0; }
|
||||
|
||||
int __cdecl f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; }
|
||||
int __cdecl g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; }
|
||||
|
||||
int __cdecl f2(int a1, int a2) { f1(a1); f1(a2); return 0; }
|
||||
int __cdecl g2(int a1, int a2) const { g1(a1); g1(a2); return 0; }
|
||||
|
||||
int __cdecl f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; }
|
||||
int __cdecl g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; }
|
||||
|
||||
int __cdecl f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; }
|
||||
int __cdecl g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; }
|
||||
|
||||
int __cdecl f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; }
|
||||
int __cdecl g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; }
|
||||
|
||||
int __cdecl f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; }
|
||||
int __cdecl g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; }
|
||||
|
||||
int __cdecl f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; }
|
||||
int __cdecl g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; }
|
||||
|
||||
int __cdecl f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; }
|
||||
int __cdecl g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; }
|
||||
};
|
||||
|
||||
void member_function_test()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
X x;
|
||||
|
||||
// 0
|
||||
|
||||
bind(&X::f0, &x)();
|
||||
bind(&X::f0, ref(x))();
|
||||
|
||||
bind(&X::g0, &x)();
|
||||
bind(&X::g0, x)();
|
||||
bind(&X::g0, ref(x))();
|
||||
|
||||
// 1
|
||||
|
||||
bind(&X::f1, &x, 1)();
|
||||
bind(&X::f1, ref(x), 1)();
|
||||
|
||||
bind(&X::g1, &x, 1)();
|
||||
bind(&X::g1, x, 1)();
|
||||
bind(&X::g1, ref(x), 1)();
|
||||
|
||||
// 2
|
||||
|
||||
bind(&X::f2, &x, 1, 2)();
|
||||
bind(&X::f2, ref(x), 1, 2)();
|
||||
|
||||
bind(&X::g2, &x, 1, 2)();
|
||||
bind(&X::g2, x, 1, 2)();
|
||||
bind(&X::g2, ref(x), 1, 2)();
|
||||
|
||||
// 3
|
||||
|
||||
bind(&X::f3, &x, 1, 2, 3)();
|
||||
bind(&X::f3, ref(x), 1, 2, 3)();
|
||||
|
||||
bind(&X::g3, &x, 1, 2, 3)();
|
||||
bind(&X::g3, x, 1, 2, 3)();
|
||||
bind(&X::g3, ref(x), 1, 2, 3)();
|
||||
|
||||
// 4
|
||||
|
||||
bind(&X::f4, &x, 1, 2, 3, 4)();
|
||||
bind(&X::f4, ref(x), 1, 2, 3, 4)();
|
||||
|
||||
bind(&X::g4, &x, 1, 2, 3, 4)();
|
||||
bind(&X::g4, x, 1, 2, 3, 4)();
|
||||
bind(&X::g4, ref(x), 1, 2, 3, 4)();
|
||||
|
||||
// 5
|
||||
|
||||
bind(&X::f5, &x, 1, 2, 3, 4, 5)();
|
||||
bind(&X::f5, ref(x), 1, 2, 3, 4, 5)();
|
||||
|
||||
bind(&X::g5, &x, 1, 2, 3, 4, 5)();
|
||||
bind(&X::g5, x, 1, 2, 3, 4, 5)();
|
||||
bind(&X::g5, ref(x), 1, 2, 3, 4, 5)();
|
||||
|
||||
// 6
|
||||
|
||||
bind(&X::f6, &x, 1, 2, 3, 4, 5, 6)();
|
||||
bind(&X::f6, ref(x), 1, 2, 3, 4, 5, 6)();
|
||||
|
||||
bind(&X::g6, &x, 1, 2, 3, 4, 5, 6)();
|
||||
bind(&X::g6, x, 1, 2, 3, 4, 5, 6)();
|
||||
bind(&X::g6, ref(x), 1, 2, 3, 4, 5, 6)();
|
||||
|
||||
// 7
|
||||
|
||||
bind(&X::f7, &x, 1, 2, 3, 4, 5, 6, 7)();
|
||||
bind(&X::f7, ref(x), 1, 2, 3, 4, 5, 6, 7)();
|
||||
|
||||
bind(&X::g7, &x, 1, 2, 3, 4, 5, 6, 7)();
|
||||
bind(&X::g7, x, 1, 2, 3, 4, 5, 6, 7)();
|
||||
bind(&X::g7, ref(x), 1, 2, 3, 4, 5, 6, 7)();
|
||||
|
||||
// 8
|
||||
|
||||
bind(&X::f8, &x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind(&X::f8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
|
||||
bind(&X::g8, &x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind(&X::g8, x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind(&X::g8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
|
||||
BOOST_TEST( x.hash == 23558 );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
member_function_test();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,184 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_const_test.cpp - test const bind objects
|
||||
//
|
||||
// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001 David Abrahams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
//
|
||||
|
||||
long f_0()
|
||||
{
|
||||
return 17041L;
|
||||
}
|
||||
|
||||
long f_1(long a)
|
||||
{
|
||||
return a;
|
||||
}
|
||||
|
||||
long f_2(long a, long b)
|
||||
{
|
||||
return a + 10 * b;
|
||||
}
|
||||
|
||||
long f_3(long a, long b, long c)
|
||||
{
|
||||
return a + 10 * b + 100 * c;
|
||||
}
|
||||
|
||||
long f_4(long a, long b, long c, long d)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d;
|
||||
}
|
||||
|
||||
long f_5(long a, long b, long c, long d, long e)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e;
|
||||
}
|
||||
|
||||
long f_6(long a, long b, long c, long d, long e, long f)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f;
|
||||
}
|
||||
|
||||
long f_7(long a, long b, long c, long d, long e, long f, long g)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g;
|
||||
}
|
||||
|
||||
long f_8(long a, long b, long c, long d, long e, long f, long g, long h)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h;
|
||||
}
|
||||
|
||||
long f_9(long a, long b, long c, long d, long e, long f, long g, long h, long i)
|
||||
{
|
||||
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h + 100000000 * i;
|
||||
}
|
||||
|
||||
long global_result;
|
||||
|
||||
void fv_0()
|
||||
{
|
||||
global_result = 17041L;
|
||||
}
|
||||
|
||||
void fv_1(long a)
|
||||
{
|
||||
global_result = a;
|
||||
}
|
||||
|
||||
void fv_2(long a, long b)
|
||||
{
|
||||
global_result = a + 10 * b;
|
||||
}
|
||||
|
||||
void fv_3(long a, long b, long c)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c;
|
||||
}
|
||||
|
||||
void fv_4(long a, long b, long c, long d)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d;
|
||||
}
|
||||
|
||||
void fv_5(long a, long b, long c, long d, long e)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e;
|
||||
}
|
||||
|
||||
void fv_6(long a, long b, long c, long d, long e, long f)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f;
|
||||
}
|
||||
|
||||
void fv_7(long a, long b, long c, long d, long e, long f, long g)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g;
|
||||
}
|
||||
|
||||
void fv_8(long a, long b, long c, long d, long e, long f, long g, long h)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h;
|
||||
}
|
||||
|
||||
void fv_9(long a, long b, long c, long d, long e, long f, long g, long h, long i)
|
||||
{
|
||||
global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h + 100000000 * i;
|
||||
}
|
||||
|
||||
template<class F, class A> long test(F const & f, A const & a)
|
||||
{
|
||||
return f(a);
|
||||
}
|
||||
|
||||
template<class F, class A> long testv(F const & f, A const & a)
|
||||
{
|
||||
f(a);
|
||||
return global_result;
|
||||
}
|
||||
|
||||
void function_test()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
int const i = 1;
|
||||
|
||||
BOOST_TEST( test( bind(f_0), i ) == 17041L );
|
||||
BOOST_TEST( test( bind(f_1, _1), i ) == 1L );
|
||||
BOOST_TEST( test( bind(f_2, _1, 2), i ) == 21L );
|
||||
BOOST_TEST( test( bind(f_3, _1, 2, 3), i ) == 321L );
|
||||
BOOST_TEST( test( bind(f_4, _1, 2, 3, 4), i ) == 4321L );
|
||||
BOOST_TEST( test( bind(f_5, _1, 2, 3, 4, 5), i ) == 54321L );
|
||||
BOOST_TEST( test( bind(f_6, _1, 2, 3, 4, 5, 6), i ) == 654321L );
|
||||
BOOST_TEST( test( bind(f_7, _1, 2, 3, 4, 5, 6, 7), i ) == 7654321L );
|
||||
BOOST_TEST( test( bind(f_8, _1, 2, 3, 4, 5, 6, 7, 8), i ) == 87654321L );
|
||||
BOOST_TEST( test( bind(f_9, _1, 2, 3, 4, 5, 6, 7, 8, 9), i ) == 987654321L );
|
||||
|
||||
BOOST_TEST( testv( bind(fv_0), i ) == 17041L );
|
||||
BOOST_TEST( testv( bind(fv_1, _1), i ) == 1L );
|
||||
BOOST_TEST( testv( bind(fv_2, _1, 2), i ) == 21L );
|
||||
BOOST_TEST( testv( bind(fv_3, _1, 2, 3), i ) == 321L );
|
||||
BOOST_TEST( testv( bind(fv_4, _1, 2, 3, 4), i ) == 4321L );
|
||||
BOOST_TEST( testv( bind(fv_5, _1, 2, 3, 4, 5), i ) == 54321L );
|
||||
BOOST_TEST( testv( bind(fv_6, _1, 2, 3, 4, 5, 6), i ) == 654321L );
|
||||
BOOST_TEST( testv( bind(fv_7, _1, 2, 3, 4, 5, 6, 7), i ) == 7654321L );
|
||||
BOOST_TEST( testv( bind(fv_8, _1, 2, 3, 4, 5, 6, 7, 8), i ) == 87654321L );
|
||||
BOOST_TEST( testv( bind(fv_9, _1, 2, 3, 4, 5, 6, 7, 8, 9), i ) == 987654321L );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
function_test();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,158 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_cv_test.cpp
|
||||
//
|
||||
// Copyright (c) 2004 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
int operator()()
|
||||
{
|
||||
return 17041;
|
||||
}
|
||||
|
||||
int operator()() const
|
||||
{
|
||||
return -17041;
|
||||
}
|
||||
|
||||
int operator()(int x1)
|
||||
{
|
||||
return x1;
|
||||
}
|
||||
|
||||
int operator()(int x1) const
|
||||
{
|
||||
return -x1;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2)
|
||||
{
|
||||
return x1+x2;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2) const
|
||||
{
|
||||
return -(x1+x2);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3)
|
||||
{
|
||||
return x1+x2+x3;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3) const
|
||||
{
|
||||
return -(x1+x2+x3);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4)
|
||||
{
|
||||
return x1+x2+x3+x4;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4) const
|
||||
{
|
||||
return -(x1+x2+x3+x4);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5)
|
||||
{
|
||||
return x1+x2+x3+x4+x5;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6)
|
||||
{
|
||||
return x1+x2+x3+x4+x5+x6;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5+x6);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7)
|
||||
{
|
||||
return x1+x2+x3+x4+x5+x6+x7;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5+x6+x7);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8)
|
||||
{
|
||||
return x1+x2+x3+x4+x5+x6+x7+x8;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5+x6+x7+x8);
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9)
|
||||
{
|
||||
return x1+x2+x3+x4+x5+x6+x7+x8+x9;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9) const
|
||||
{
|
||||
return -(x1+x2+x3+x4+x5+x6+x7+x8+x9);
|
||||
}
|
||||
};
|
||||
|
||||
template<class F> void test(F f, int r)
|
||||
{
|
||||
F const & cf = f;
|
||||
BOOST_TEST( cf() == -r );
|
||||
BOOST_TEST( f() == r );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test( boost::bind<int>( X() ), 17041 );
|
||||
test( boost::bind<int>( X(), 1 ), 1 );
|
||||
test( boost::bind<int>( X(), 1, 2 ), 1+2 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3 ), 1+2+3 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4 ), 1+2+3+4 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5 ), 1+2+3+4+5 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6 ), 1+2+3+4+5+6 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7 ), 1+2+3+4+5+6+7 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8 ), 1+2+3+4+5+6+7+8 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), 1+2+3+4+5+6+7+8+9 );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_dm2_test.cpp - data members, advanced uses
|
||||
//
|
||||
// Copyright (c) 2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
int m;
|
||||
};
|
||||
|
||||
struct Y
|
||||
{
|
||||
char m[ 64 ];
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
X x = { 0 };
|
||||
X * px = &x;
|
||||
|
||||
boost::bind< int& >( &X::m, _1 )( px ) = 42;
|
||||
|
||||
BOOST_TEST( x.m == 42 );
|
||||
|
||||
boost::bind< int& >( &X::m, boost::ref(x) )() = 17041;
|
||||
|
||||
BOOST_TEST( x.m == 17041 );
|
||||
|
||||
X const * pcx = &x;
|
||||
|
||||
BOOST_TEST( boost::bind< long >( &X::m, _1 )( pcx ) == 17041L );
|
||||
BOOST_TEST( boost::bind< long >( &X::m, pcx )() == 17041L );
|
||||
|
||||
Y y = { "test" };
|
||||
std::string v( "test" );
|
||||
|
||||
BOOST_TEST( boost::bind< char const* >( &Y::m, &y )() == v );
|
||||
BOOST_TEST( boost::bind< std::string >( &Y::m, &y )() == v );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_dm_test.cpp - data members
|
||||
//
|
||||
// Copyright (c) 2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
int m;
|
||||
};
|
||||
|
||||
X f( int v )
|
||||
{
|
||||
X r = { v };
|
||||
return r;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
X x = { 17041 };
|
||||
X * px = &x;
|
||||
|
||||
BOOST_TEST( boost::bind( &X::m, _1 )( x ) == 17041 );
|
||||
BOOST_TEST( boost::bind( &X::m, _1 )( px ) == 17041 );
|
||||
|
||||
BOOST_TEST( boost::bind( &X::m, x )() == 17041 );
|
||||
BOOST_TEST( boost::bind( &X::m, px )() == 17041 );
|
||||
BOOST_TEST( boost::bind( &X::m, boost::ref(x) )() == 17041 );
|
||||
|
||||
|
||||
X const cx = x;
|
||||
X const * pcx = &cx;
|
||||
|
||||
BOOST_TEST( boost::bind( &X::m, _1 )( cx ) == 17041 );
|
||||
BOOST_TEST( boost::bind( &X::m, _1 )( pcx ) == 17041 );
|
||||
|
||||
BOOST_TEST( boost::bind( &X::m, cx )() == 17041 );
|
||||
BOOST_TEST( boost::bind( &X::m, pcx )() == 17041 );
|
||||
BOOST_TEST( boost::bind( &X::m, boost::ref(cx) )() == 17041 );
|
||||
|
||||
int const v = 42;
|
||||
|
||||
BOOST_TEST( boost::bind( &X::m, boost::bind( f, _1 ) )( v ) == v );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,427 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_eq_test.cpp - boost::bind equality operator
|
||||
//
|
||||
// Copyright (c) 2004, 2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
# include <boost/function_equal.hpp>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
int i_;
|
||||
|
||||
explicit X(int i): i_(i)
|
||||
{
|
||||
}
|
||||
|
||||
bool operator==(X const & rhs) const
|
||||
{
|
||||
return i_ == rhs.i_;
|
||||
}
|
||||
};
|
||||
|
||||
// f_*
|
||||
|
||||
int f_0()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_1(X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_2(X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_3(X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_4(X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_5(X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_6(X, X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_7(X, X, X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_8(X, X, X, X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int f_9(X, X, X, X, X, X, X, X, X)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// fv_*
|
||||
|
||||
void fv_0()
|
||||
{
|
||||
}
|
||||
|
||||
void fv_1(X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_2(X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_3(X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_4(X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_5(X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_6(X, X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_7(X, X, X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_8(X, X, X, X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
void fv_9(X, X, X, X, X, X, X, X, X)
|
||||
{
|
||||
}
|
||||
|
||||
template<class F> void test_eq(F f1, F f2)
|
||||
{
|
||||
#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
|
||||
using boost::function_equal;
|
||||
|
||||
#endif
|
||||
|
||||
BOOST_TEST( function_equal( f1, f2 ) );
|
||||
}
|
||||
|
||||
template<class F> void test_ne(F f1, F f2)
|
||||
{
|
||||
#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
|
||||
using boost::function_equal;
|
||||
|
||||
#endif
|
||||
|
||||
BOOST_TEST( !function_equal( f1, f2 ) );
|
||||
}
|
||||
|
||||
// 0
|
||||
|
||||
template<class F> void test_0(F f)
|
||||
{
|
||||
test_eq( boost::bind(f), boost::bind(f) );
|
||||
}
|
||||
|
||||
// 1
|
||||
|
||||
template<class F, class V> void test_1_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1), boost::bind(f, v1) );
|
||||
test_ne( boost::bind(f, v1), boost::bind(f, v2) );
|
||||
}
|
||||
|
||||
template<class F> void test_1(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1), boost::bind(f, _1) );
|
||||
|
||||
test_1_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_1_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 2
|
||||
|
||||
template<class F, class V> void test_2_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1), boost::bind(f, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1), boost::bind(f, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1), boost::bind(f, v2, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_2(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2), boost::bind(f, _1, _2) );
|
||||
|
||||
test_2_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_2_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 3
|
||||
|
||||
template<class F, class V> void test_3_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1), boost::bind(f, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1), boost::bind(f, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1), boost::bind(f, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1), boost::bind(f, v2, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_3(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3), boost::bind(f, _1, _2, _3) );
|
||||
|
||||
test_3_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_3_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 4
|
||||
|
||||
template<class F, class V> void test_4_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_4(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4), boost::bind(f, _1, _2, _3, _4) );
|
||||
|
||||
test_4_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_4_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 5
|
||||
|
||||
template<class F, class V> void test_5_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_5(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5), boost::bind(f, _1, _2, _3, _4, _5) );
|
||||
|
||||
test_5_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_5_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 6
|
||||
|
||||
template<class F, class V> void test_6_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_6(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6), boost::bind(f, _1, _2, _3, _4, _5, _6) );
|
||||
|
||||
test_6_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_6_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 7
|
||||
|
||||
template<class F, class V> void test_7_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_7(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6, _7), boost::bind(f, _1, _2, _3, _4, _5, _6, _7) );
|
||||
|
||||
test_7_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_7_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 8
|
||||
|
||||
template<class F, class V> void test_8_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_8(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8), boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8) );
|
||||
|
||||
test_8_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_8_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
// 9
|
||||
|
||||
template<class F, class V> void test_9_(F f, V v1, V v2)
|
||||
{
|
||||
test_eq( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v2) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v2, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v1, v2, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v1, v2, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v1, v2, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v1, v2, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v1, v2, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v1, v2, v1, v1, v1, v1, v1, v1, v1) );
|
||||
test_ne( boost::bind(f, v1, v1, v1, v1, v1, v1, v1, v1, v1), boost::bind(f, v2, v1, v1, v1, v1, v1, v1, v1, v1) );
|
||||
}
|
||||
|
||||
template<class F> void test_9(F f)
|
||||
{
|
||||
test_eq( boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8, _9), boost::bind(f, _1, _2, _3, _4, _5, _6, _7, _8, _9) );
|
||||
|
||||
test_9_( f, X(1), X(2) );
|
||||
|
||||
X a(0), b(0);
|
||||
test_9_( f, boost::ref(a), boost::ref(b) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// 0
|
||||
|
||||
test_0( f_0 );
|
||||
test_0( fv_0 );
|
||||
|
||||
// 1
|
||||
|
||||
test_1( f_1 );
|
||||
test_1( fv_1 );
|
||||
|
||||
// 2
|
||||
|
||||
test_2( f_2 );
|
||||
test_2( fv_2 );
|
||||
|
||||
// 3
|
||||
|
||||
test_3( f_3 );
|
||||
test_3( fv_3 );
|
||||
|
||||
// 4
|
||||
|
||||
test_4( f_4 );
|
||||
test_4( fv_4 );
|
||||
|
||||
// 5
|
||||
|
||||
test_5( f_5 );
|
||||
test_5( fv_5 );
|
||||
|
||||
// 6
|
||||
|
||||
test_6( f_6 );
|
||||
test_6( fv_6 );
|
||||
|
||||
// 7
|
||||
|
||||
test_7( f_7 );
|
||||
test_7( fv_7 );
|
||||
|
||||
// 8
|
||||
|
||||
test_8( f_8 );
|
||||
test_8( fv_8 );
|
||||
|
||||
// 9
|
||||
|
||||
test_9( f_9 );
|
||||
test_9( fv_9 );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#define BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#define BOOST_BIND_ENABLE_FASTCALL
|
||||
|
||||
@@ -1,77 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_function_test.cpp - function<>
|
||||
//
|
||||
// Copyright (c) 2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
int f( int x )
|
||||
{
|
||||
return x;
|
||||
}
|
||||
|
||||
int g( int x )
|
||||
{
|
||||
return x + 1;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function0<int> fn;
|
||||
|
||||
BOOST_TEST( !fn.contains( boost::bind( f, 1 ) ) );
|
||||
BOOST_TEST( !fn.contains( boost::bind( f, 2 ) ) );
|
||||
BOOST_TEST( !fn.contains( boost::bind( g, 1 ) ) );
|
||||
|
||||
fn = boost::bind( f, 1 );
|
||||
|
||||
BOOST_TEST( fn() == 1 );
|
||||
|
||||
BOOST_TEST( fn.contains( boost::bind( f, 1 ) ) );
|
||||
BOOST_TEST( !fn.contains( boost::bind( f, 2 ) ) );
|
||||
BOOST_TEST( !fn.contains( boost::bind( g, 1 ) ) );
|
||||
|
||||
fn = boost::bind( f, 2 );
|
||||
|
||||
BOOST_TEST( fn() == 2 );
|
||||
|
||||
BOOST_TEST( !fn.contains( boost::bind( f, 1 ) ) );
|
||||
BOOST_TEST( fn.contains( boost::bind( f, 2 ) ) );
|
||||
BOOST_TEST( !fn.contains( boost::bind( g, 1 ) ) );
|
||||
|
||||
fn = boost::bind( g, 1 );
|
||||
|
||||
BOOST_TEST( fn() == 2 );
|
||||
|
||||
BOOST_TEST( !fn.contains( boost::bind( f, 1 ) ) );
|
||||
BOOST_TEST( !fn.contains( boost::bind( f, 2 ) ) );
|
||||
BOOST_TEST( fn.contains( boost::bind( g, 1 ) ) );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
//
|
||||
// bind_lookup_problem_test.cpp
|
||||
//
|
||||
// Copyright (C) Markus Schöpflin 2005.
|
||||
//
|
||||
// Use, modification, and distribution are subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
template<class T> void value();
|
||||
|
||||
void f0() { }
|
||||
void f1(int) { }
|
||||
void f2(int, int) { }
|
||||
void f3(int, int, int) { }
|
||||
void f4(int, int, int, int) { }
|
||||
void f5(int, int, int, int, int) { }
|
||||
void f6(int, int, int, int, int, int) { }
|
||||
void f7(int, int, int, int, int, int, int) { }
|
||||
void f8(int, int, int, int, int, int, int, int) { }
|
||||
void f9(int, int, int, int, int, int, int, int, int) { }
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::bind(f0);
|
||||
boost::bind(f1, 0);
|
||||
boost::bind(f2, 0, 0);
|
||||
boost::bind(f3, 0, 0, 0);
|
||||
boost::bind(f4, 0, 0, 0, 0);
|
||||
boost::bind(f5, 0, 0, 0, 0, 0);
|
||||
boost::bind(f6, 0, 0, 0, 0, 0, 0);
|
||||
boost::bind(f7, 0, 0, 0, 0, 0, 0, 0);
|
||||
boost::bind(f8, 0, 0, 0, 0, 0, 0, 0, 0);
|
||||
boost::bind(f9, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_not_test.cpp - operator!
|
||||
//
|
||||
// Copyright (c) 2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
template<class F, class A1, class R> void test( F f, A1 a1, R r )
|
||||
{
|
||||
BOOST_TEST( f(a1) == r );
|
||||
}
|
||||
|
||||
bool f( bool v )
|
||||
{
|
||||
return v;
|
||||
}
|
||||
|
||||
int g( int v )
|
||||
{
|
||||
return v;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test( !boost::bind( f, true ), 0, !f( true ) );
|
||||
test( !boost::bind( g, _1 ), 5, !g( 5 ) );
|
||||
test( boost::bind( f, !boost::bind( f, true ) ), 0, f( !f( true ) ) );
|
||||
test( boost::bind( f, !boost::bind( f, _1 ) ), true, f( !f( true ) ) );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,97 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_rel_test.cpp - ==, !=, <, <=, >, >= operators
|
||||
//
|
||||
// Copyright (c) 2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
int f( int x )
|
||||
{
|
||||
return x + x;
|
||||
}
|
||||
|
||||
int g( int x )
|
||||
{
|
||||
return 2 * x;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int x = 4;
|
||||
int y = x + x;
|
||||
|
||||
// bind op value
|
||||
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) == y )( x ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) != y )( x ) ) );
|
||||
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) < y )( x ) ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) < y + 1 )( x ) );
|
||||
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) > y )( x ) ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) > y - 1 )( x ) );
|
||||
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) <= y - 1 )( x ) ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) <= y )( x ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) <= y + 1 )( x ) );
|
||||
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) >= y + 1 )( x ) ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) >= y )( x ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) >= y - 1 )( x ) );
|
||||
|
||||
// bind op ref
|
||||
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) == boost::ref( y ) )( x ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) != boost::ref( y ) )( x ) ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) < boost::ref( y ) )( x ) ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) > boost::ref( y ) )( x ) ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) <= boost::ref( y ) )( x ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) >= boost::ref( y ) )( x ) );
|
||||
|
||||
// bind op placeholder
|
||||
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) == _2 )( x, y ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) != _2 )( x, y ) ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) < _2 )( x, y ) ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) > _2 )( x, y ) ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) <= _2 )( x, y ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) >= _2 )( x, y ) );
|
||||
|
||||
// bind op bind
|
||||
|
||||
// important: bind( f, _1 ) and bind( g, _1 ) have the same type
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) == boost::bind( g, _1 ) )( x ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) != boost::bind( g, _1 ) )( x ) ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) < boost::bind( g, _1 ) )( x ) ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) <= boost::bind( g, _1 ) )( x ) );
|
||||
BOOST_TEST( !( ( boost::bind( f, _1 ) > boost::bind( g, _1 ) )( x ) ) );
|
||||
BOOST_TEST( ( boost::bind( f, _1 ) >= boost::bind( g, _1 ) )( x ) );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,222 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_stateful_test.cpp
|
||||
//
|
||||
// Copyright (c) 2004 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
class X
|
||||
{
|
||||
private:
|
||||
|
||||
int state_;
|
||||
|
||||
public:
|
||||
|
||||
X(): state_(0)
|
||||
{
|
||||
}
|
||||
|
||||
int state() const
|
||||
{
|
||||
return state_;
|
||||
}
|
||||
|
||||
int operator()()
|
||||
{
|
||||
return state_ += 17041;
|
||||
}
|
||||
|
||||
int operator()(int x1)
|
||||
{
|
||||
return state_ += x1;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2)
|
||||
{
|
||||
return state_ += x1+x2;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3)
|
||||
{
|
||||
return state_ += x1+x2+x3;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7+x8;
|
||||
}
|
||||
|
||||
int operator()(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7+x8+x9;
|
||||
}
|
||||
};
|
||||
|
||||
int f0(int & state_)
|
||||
{
|
||||
return state_ += 17041;
|
||||
}
|
||||
|
||||
int f1(int & state_, int x1)
|
||||
{
|
||||
return state_ += x1;
|
||||
}
|
||||
|
||||
int f2(int & state_, int x1, int x2)
|
||||
{
|
||||
return state_ += x1+x2;
|
||||
}
|
||||
|
||||
int f3(int & state_, int x1, int x2, int x3)
|
||||
{
|
||||
return state_ += x1+x2+x3;
|
||||
}
|
||||
|
||||
int f4(int & state_, int x1, int x2, int x3, int x4)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4;
|
||||
}
|
||||
|
||||
int f5(int & state_, int x1, int x2, int x3, int x4, int x5)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5;
|
||||
}
|
||||
|
||||
int f6(int & state_, int x1, int x2, int x3, int x4, int x5, int x6)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6;
|
||||
}
|
||||
|
||||
int f7(int & state_, int x1, int x2, int x3, int x4, int x5, int x6, int x7)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7;
|
||||
}
|
||||
|
||||
int f8(int & state_, int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8)
|
||||
{
|
||||
return state_ += x1+x2+x3+x4+x5+x6+x7+x8;
|
||||
}
|
||||
|
||||
template<class F> void test(F f, int a, int b)
|
||||
{
|
||||
BOOST_TEST( f() == a + b );
|
||||
BOOST_TEST( f() == a + 2*b );
|
||||
BOOST_TEST( f() == a + 3*b );
|
||||
}
|
||||
|
||||
void stateful_function_object_test()
|
||||
{
|
||||
test( boost::bind<int>( X() ), 0, 17041 );
|
||||
test( boost::bind<int>( X(), 1 ), 0, 1 );
|
||||
test( boost::bind<int>( X(), 1, 2 ), 0, 1+2 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3 ), 0, 1+2+3 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4 ), 0, 1+2+3+4 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5 ), 0, 1+2+3+4+5 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6 ), 0, 1+2+3+4+5+6 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7 ), 0, 1+2+3+4+5+6+7 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8 ), 0, 1+2+3+4+5+6+7+8 );
|
||||
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), 0, 1+2+3+4+5+6+7+8+9 );
|
||||
|
||||
X x;
|
||||
|
||||
int n = x.state();
|
||||
|
||||
test( boost::bind<int>( boost::ref(x) ), n, 17041 );
|
||||
n += 3*17041;
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1 ), n, 1 );
|
||||
n += 3*1;
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2 ), n, 1+2 );
|
||||
n += 3*(1+2);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3 ), n, 1+2+3 );
|
||||
n += 3*(1+2+3);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4 ), n, 1+2+3+4 );
|
||||
n += 3*(1+2+3+4);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5 ), n, 1+2+3+4+5 );
|
||||
n += 3*(1+2+3+4+5);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6 ), n, 1+2+3+4+5+6 );
|
||||
n += 3*(1+2+3+4+5+6);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7 ), n, 1+2+3+4+5+6+7 );
|
||||
n += 3*(1+2+3+4+5+6+7);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8 ), n, 1+2+3+4+5+6+7+8 );
|
||||
n += 3*(1+2+3+4+5+6+7+8);
|
||||
|
||||
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), n, 1+2+3+4+5+6+7+8+9 );
|
||||
n += 3*(1+2+3+4+5+6+7+8+9);
|
||||
|
||||
BOOST_TEST( x.state() == n );
|
||||
}
|
||||
|
||||
void stateful_function_test()
|
||||
{
|
||||
test( boost::bind( f0, 0 ), 0, 17041 );
|
||||
test( boost::bind( f1, 0, 1 ), 0, 1 );
|
||||
test( boost::bind( f2, 0, 1, 2 ), 0, 1+2 );
|
||||
test( boost::bind( f3, 0, 1, 2, 3 ), 0, 1+2+3 );
|
||||
test( boost::bind( f4, 0, 1, 2, 3, 4 ), 0, 1+2+3+4 );
|
||||
test( boost::bind( f5, 0, 1, 2, 3, 4, 5 ), 0, 1+2+3+4+5 );
|
||||
test( boost::bind( f6, 0, 1, 2, 3, 4, 5, 6 ), 0, 1+2+3+4+5+6 );
|
||||
test( boost::bind( f7, 0, 1, 2, 3, 4, 5, 6, 7 ), 0, 1+2+3+4+5+6+7 );
|
||||
test( boost::bind( f8, 0, 1, 2, 3, 4, 5, 6, 7, 8 ), 0, 1+2+3+4+5+6+7+8 );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
stateful_function_object_test();
|
||||
stateful_function_test();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#define BOOST_MEM_FN_ENABLE_STDCALL
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#define BOOST_BIND_ENABLE_STDCALL
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -13,9 +11,10 @@
|
||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
// Copyright (c) 2001 David Abrahams
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
@@ -189,7 +188,7 @@ void function_object_test()
|
||||
BOOST_TEST( bind<int>(Y(), i, _1)(k) == 38 );
|
||||
BOOST_TEST( bind<long>(Y(), i, _1, 9)(k) == 938 );
|
||||
|
||||
#if !defined(__MWERKS__) || (__MWERKS__ > 0x2407) // Fails for this version of the compiler.
|
||||
#if !defined(__MWERKS__) || (__MWERKS__ > 0x2406) // Fails for this version of the compiler.
|
||||
|
||||
global_result = 0;
|
||||
bind<void>(Y(), i, _1, 9, 4)(k);
|
||||
@@ -390,7 +389,7 @@ void member_function_test()
|
||||
bind(&X::g8, x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind(&X::g8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
|
||||
BOOST_TEST( x.hash == 23558 );
|
||||
BOOST_TEST( bind(&X::hash, _1)(x) == 23558 );
|
||||
}
|
||||
|
||||
void member_function_void_test()
|
||||
@@ -480,7 +479,7 @@ void member_function_void_test()
|
||||
bind(&V::g8, v, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind(&V::g8, ref(v), 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
|
||||
BOOST_TEST( v.hash == 23558 );
|
||||
BOOST_TEST( bind(&V::hash, _1)(v) == 23558 );
|
||||
}
|
||||
|
||||
void nested_bind_test()
|
||||
|
||||
@@ -1,186 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// mem_fn_cdecl_test.cpp - a test for mem_fn.hpp + __cdecl
|
||||
//
|
||||
// Copyright (c) 2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#define BOOST_MEM_FN_ENABLE_CDECL
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
|
||||
struct X
|
||||
{
|
||||
mutable unsigned int hash;
|
||||
|
||||
X(): hash(0) {}
|
||||
|
||||
int __cdecl f0() { f1(17); return 0; }
|
||||
int __cdecl g0() const { g1(17); return 0; }
|
||||
|
||||
int __cdecl f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; }
|
||||
int __cdecl g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; }
|
||||
|
||||
int __cdecl f2(int a1, int a2) { f1(a1); f1(a2); return 0; }
|
||||
int __cdecl g2(int a1, int a2) const { g1(a1); g1(a2); return 0; }
|
||||
|
||||
int __cdecl f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; }
|
||||
int __cdecl g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; }
|
||||
|
||||
int __cdecl f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; }
|
||||
int __cdecl g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; }
|
||||
|
||||
int __cdecl f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; }
|
||||
int __cdecl g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; }
|
||||
|
||||
int __cdecl f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; }
|
||||
int __cdecl g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; }
|
||||
|
||||
int __cdecl f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; }
|
||||
int __cdecl g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; }
|
||||
|
||||
int __cdecl f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; }
|
||||
int __cdecl g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; }
|
||||
};
|
||||
|
||||
int detect_errors(bool x)
|
||||
{
|
||||
if(x)
|
||||
{
|
||||
std::cerr << "no errors detected.\n";
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cerr << "test failed.\n";
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
using boost::mem_fn;
|
||||
|
||||
X x;
|
||||
|
||||
X const & rcx = x;
|
||||
X const * pcx = &x;
|
||||
|
||||
boost::shared_ptr<X> sp(new X);
|
||||
|
||||
mem_fn(&X::f0)(x);
|
||||
mem_fn(&X::f0)(&x);
|
||||
mem_fn(&X::f0)(sp);
|
||||
|
||||
mem_fn(&X::g0)(x);
|
||||
mem_fn(&X::g0)(rcx);
|
||||
mem_fn(&X::g0)(&x);
|
||||
mem_fn(&X::g0)(pcx);
|
||||
mem_fn(&X::g0)(sp);
|
||||
|
||||
mem_fn(&X::f1)(x, 1);
|
||||
mem_fn(&X::f1)(&x, 1);
|
||||
mem_fn(&X::f1)(sp, 1);
|
||||
|
||||
mem_fn(&X::g1)(x, 1);
|
||||
mem_fn(&X::g1)(rcx, 1);
|
||||
mem_fn(&X::g1)(&x, 1);
|
||||
mem_fn(&X::g1)(pcx, 1);
|
||||
mem_fn(&X::g1)(sp, 1);
|
||||
|
||||
mem_fn(&X::f2)(x, 1, 2);
|
||||
mem_fn(&X::f2)(&x, 1, 2);
|
||||
mem_fn(&X::f2)(sp, 1, 2);
|
||||
|
||||
mem_fn(&X::g2)(x, 1, 2);
|
||||
mem_fn(&X::g2)(rcx, 1, 2);
|
||||
mem_fn(&X::g2)(&x, 1, 2);
|
||||
mem_fn(&X::g2)(pcx, 1, 2);
|
||||
mem_fn(&X::g2)(sp, 1, 2);
|
||||
|
||||
mem_fn(&X::f3)(x, 1, 2, 3);
|
||||
mem_fn(&X::f3)(&x, 1, 2, 3);
|
||||
mem_fn(&X::f3)(sp, 1, 2, 3);
|
||||
|
||||
mem_fn(&X::g3)(x, 1, 2, 3);
|
||||
mem_fn(&X::g3)(rcx, 1, 2, 3);
|
||||
mem_fn(&X::g3)(&x, 1, 2, 3);
|
||||
mem_fn(&X::g3)(pcx, 1, 2, 3);
|
||||
mem_fn(&X::g3)(sp, 1, 2, 3);
|
||||
|
||||
mem_fn(&X::f4)(x, 1, 2, 3, 4);
|
||||
mem_fn(&X::f4)(&x, 1, 2, 3, 4);
|
||||
mem_fn(&X::f4)(sp, 1, 2, 3, 4);
|
||||
|
||||
mem_fn(&X::g4)(x, 1, 2, 3, 4);
|
||||
mem_fn(&X::g4)(rcx, 1, 2, 3, 4);
|
||||
mem_fn(&X::g4)(&x, 1, 2, 3, 4);
|
||||
mem_fn(&X::g4)(pcx, 1, 2, 3, 4);
|
||||
mem_fn(&X::g4)(sp, 1, 2, 3, 4);
|
||||
|
||||
mem_fn(&X::f5)(x, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::f5)(&x, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::f5)(sp, 1, 2, 3, 4, 5);
|
||||
|
||||
mem_fn(&X::g5)(x, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::g5)(rcx, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::g5)(&x, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::g5)(pcx, 1, 2, 3, 4, 5);
|
||||
mem_fn(&X::g5)(sp, 1, 2, 3, 4, 5);
|
||||
|
||||
mem_fn(&X::f6)(x, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::f6)(&x, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::f6)(sp, 1, 2, 3, 4, 5, 6);
|
||||
|
||||
mem_fn(&X::g6)(x, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::g6)(rcx, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::g6)(&x, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::g6)(pcx, 1, 2, 3, 4, 5, 6);
|
||||
mem_fn(&X::g6)(sp, 1, 2, 3, 4, 5, 6);
|
||||
|
||||
mem_fn(&X::f7)(x, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::f7)(&x, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::f7)(sp, 1, 2, 3, 4, 5, 6, 7);
|
||||
|
||||
mem_fn(&X::g7)(x, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::g7)(rcx, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::g7)(&x, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::g7)(pcx, 1, 2, 3, 4, 5, 6, 7);
|
||||
mem_fn(&X::g7)(sp, 1, 2, 3, 4, 5, 6, 7);
|
||||
|
||||
mem_fn(&X::f8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::f8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::f8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
|
||||
mem_fn(&X::g8)(x, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::g8)(rcx, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::g8)(&x, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::g8)(pcx, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
mem_fn(&X::g8)(sp, 1, 2, 3, 4, 5, 6, 7, 8);
|
||||
|
||||
return detect_errors(x.hash == 17610 && sp->hash == 2155);
|
||||
}
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
|
||||
@@ -1,67 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// mem_fn_dm_test.cpp - data members
|
||||
//
|
||||
// Copyright (c) 2005 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
int m;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
X x = { 0 };
|
||||
|
||||
boost::mem_fn( &X::m )( x ) = 401;
|
||||
|
||||
BOOST_TEST( x.m == 401 );
|
||||
BOOST_TEST( boost::mem_fn( &X::m )( x ) == 401 );
|
||||
|
||||
boost::mem_fn( &X::m )( &x ) = 502;
|
||||
|
||||
BOOST_TEST( x.m == 502 );
|
||||
BOOST_TEST( boost::mem_fn( &X::m )( &x ) == 502 );
|
||||
|
||||
X * px = &x;
|
||||
|
||||
boost::mem_fn( &X::m )( px ) = 603;
|
||||
|
||||
BOOST_TEST( x.m == 603 );
|
||||
BOOST_TEST( boost::mem_fn( &X::m )( px ) == 603 );
|
||||
|
||||
X const & cx = x;
|
||||
X const * pcx = &x;
|
||||
|
||||
BOOST_TEST( boost::mem_fn( &X::m )( cx ) == 603 );
|
||||
BOOST_TEST( boost::mem_fn( &X::m )( pcx ) == 603 );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,300 +0,0 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// mem_fn_eq_test.cpp - boost::mem_fn equality operator
|
||||
//
|
||||
// Copyright (c) 2004 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
int dm_1;
|
||||
int dm_2;
|
||||
|
||||
// 0
|
||||
|
||||
int mf0_1() { return 0; }
|
||||
int mf0_2() { return 0; }
|
||||
|
||||
int cmf0_1() const { return 0; }
|
||||
int cmf0_2() const { return 0; }
|
||||
|
||||
void mf0v_1() {}
|
||||
void mf0v_2() {}
|
||||
|
||||
void cmf0v_1() const {}
|
||||
void cmf0v_2() const {}
|
||||
|
||||
// 1
|
||||
|
||||
int mf1_1(int) { return 0; }
|
||||
int mf1_2(int) { return 0; }
|
||||
|
||||
int cmf1_1(int) const { return 0; }
|
||||
int cmf1_2(int) const { return 0; }
|
||||
|
||||
void mf1v_1(int) {}
|
||||
void mf1v_2(int) {}
|
||||
|
||||
void cmf1v_1(int) const {}
|
||||
void cmf1v_2(int) const {}
|
||||
|
||||
// 2
|
||||
|
||||
int mf2_1(int, int) { return 0; }
|
||||
int mf2_2(int, int) { return 0; }
|
||||
|
||||
int cmf2_1(int, int) const { return 0; }
|
||||
int cmf2_2(int, int) const { return 0; }
|
||||
|
||||
void mf2v_1(int, int) {}
|
||||
void mf2v_2(int, int) {}
|
||||
|
||||
void cmf2v_1(int, int) const {}
|
||||
void cmf2v_2(int, int) const {}
|
||||
|
||||
// 3
|
||||
|
||||
int mf3_1(int, int, int) { return 0; }
|
||||
int mf3_2(int, int, int) { return 0; }
|
||||
|
||||
int cmf3_1(int, int, int) const { return 0; }
|
||||
int cmf3_2(int, int, int) const { return 0; }
|
||||
|
||||
void mf3v_1(int, int, int) {}
|
||||
void mf3v_2(int, int, int) {}
|
||||
|
||||
void cmf3v_1(int, int, int) const {}
|
||||
void cmf3v_2(int, int, int) const {}
|
||||
|
||||
// 4
|
||||
|
||||
int mf4_1(int, int, int, int) { return 0; }
|
||||
int mf4_2(int, int, int, int) { return 0; }
|
||||
|
||||
int cmf4_1(int, int, int, int) const { return 0; }
|
||||
int cmf4_2(int, int, int, int) const { return 0; }
|
||||
|
||||
void mf4v_1(int, int, int, int) {}
|
||||
void mf4v_2(int, int, int, int) {}
|
||||
|
||||
void cmf4v_1(int, int, int, int) const {}
|
||||
void cmf4v_2(int, int, int, int) const {}
|
||||
|
||||
// 5
|
||||
|
||||
int mf5_1(int, int, int, int, int) { return 0; }
|
||||
int mf5_2(int, int, int, int, int) { return 0; }
|
||||
|
||||
int cmf5_1(int, int, int, int, int) const { return 0; }
|
||||
int cmf5_2(int, int, int, int, int) const { return 0; }
|
||||
|
||||
void mf5v_1(int, int, int, int, int) {}
|
||||
void mf5v_2(int, int, int, int, int) {}
|
||||
|
||||
void cmf5v_1(int, int, int, int, int) const {}
|
||||
void cmf5v_2(int, int, int, int, int) const {}
|
||||
|
||||
// 6
|
||||
|
||||
int mf6_1(int, int, int, int, int, int) { return 0; }
|
||||
int mf6_2(int, int, int, int, int, int) { return 0; }
|
||||
|
||||
int cmf6_1(int, int, int, int, int, int) const { return 0; }
|
||||
int cmf6_2(int, int, int, int, int, int) const { return 0; }
|
||||
|
||||
void mf6v_1(int, int, int, int, int, int) {}
|
||||
void mf6v_2(int, int, int, int, int, int) {}
|
||||
|
||||
void cmf6v_1(int, int, int, int, int, int) const {}
|
||||
void cmf6v_2(int, int, int, int, int, int) const {}
|
||||
|
||||
// 7
|
||||
|
||||
int mf7_1(int, int, int, int, int, int, int) { return 0; }
|
||||
int mf7_2(int, int, int, int, int, int, int) { return 0; }
|
||||
|
||||
int cmf7_1(int, int, int, int, int, int, int) const { return 0; }
|
||||
int cmf7_2(int, int, int, int, int, int, int) const { return 0; }
|
||||
|
||||
void mf7v_1(int, int, int, int, int, int, int) {}
|
||||
void mf7v_2(int, int, int, int, int, int, int) {}
|
||||
|
||||
void cmf7v_1(int, int, int, int, int, int, int) const {}
|
||||
void cmf7v_2(int, int, int, int, int, int, int) const {}
|
||||
|
||||
// 8
|
||||
|
||||
int mf8_1(int, int, int, int, int, int, int, int) { return 0; }
|
||||
int mf8_2(int, int, int, int, int, int, int, int) { return 0; }
|
||||
|
||||
int cmf8_1(int, int, int, int, int, int, int, int) const { return 0; }
|
||||
int cmf8_2(int, int, int, int, int, int, int, int) const { return 0; }
|
||||
|
||||
void mf8v_1(int, int, int, int, int, int, int, int) {}
|
||||
void mf8v_2(int, int, int, int, int, int, int, int) {}
|
||||
|
||||
void cmf8v_1(int, int, int, int, int, int, int, int) const {}
|
||||
void cmf8v_2(int, int, int, int, int, int, int, int) const {}
|
||||
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
BOOST_TEST( boost::mem_fn(&X::dm_1) == boost::mem_fn(&X::dm_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::dm_1) != boost::mem_fn(&X::dm_2) );
|
||||
|
||||
// 0
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf0_1) == boost::mem_fn(&X::mf0_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf0_1) != boost::mem_fn(&X::mf0_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf0_1) == boost::mem_fn(&X::cmf0_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf0_1) != boost::mem_fn(&X::cmf0_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf0v_1) == boost::mem_fn(&X::mf0v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf0v_1) != boost::mem_fn(&X::mf0v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf0v_1) == boost::mem_fn(&X::cmf0v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf0v_1) != boost::mem_fn(&X::cmf0v_2) );
|
||||
|
||||
// 1
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf1_1) == boost::mem_fn(&X::mf1_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf1_1) != boost::mem_fn(&X::mf1_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf1_1) == boost::mem_fn(&X::cmf1_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf1_1) != boost::mem_fn(&X::cmf1_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf1v_1) == boost::mem_fn(&X::mf1v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf1v_1) != boost::mem_fn(&X::mf1v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf1v_1) == boost::mem_fn(&X::cmf1v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf1v_1) != boost::mem_fn(&X::cmf1v_2) );
|
||||
|
||||
// 2
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf2_1) == boost::mem_fn(&X::mf2_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf2_1) != boost::mem_fn(&X::mf2_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf2_1) == boost::mem_fn(&X::cmf2_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf2_1) != boost::mem_fn(&X::cmf2_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf2v_1) == boost::mem_fn(&X::mf2v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf2v_1) != boost::mem_fn(&X::mf2v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf2v_1) == boost::mem_fn(&X::cmf2v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf2v_1) != boost::mem_fn(&X::cmf2v_2) );
|
||||
|
||||
// 3
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf3_1) == boost::mem_fn(&X::mf3_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf3_1) != boost::mem_fn(&X::mf3_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf3_1) == boost::mem_fn(&X::cmf3_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf3_1) != boost::mem_fn(&X::cmf3_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf3v_1) == boost::mem_fn(&X::mf3v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf3v_1) != boost::mem_fn(&X::mf3v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf3v_1) == boost::mem_fn(&X::cmf3v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf3v_1) != boost::mem_fn(&X::cmf3v_2) );
|
||||
|
||||
// 4
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf4_1) == boost::mem_fn(&X::mf4_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf4_1) != boost::mem_fn(&X::mf4_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf4_1) == boost::mem_fn(&X::cmf4_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf4_1) != boost::mem_fn(&X::cmf4_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf4v_1) == boost::mem_fn(&X::mf4v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf4v_1) != boost::mem_fn(&X::mf4v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf4v_1) == boost::mem_fn(&X::cmf4v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf4v_1) != boost::mem_fn(&X::cmf4v_2) );
|
||||
|
||||
// 5
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf5_1) == boost::mem_fn(&X::mf5_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf5_1) != boost::mem_fn(&X::mf5_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf5_1) == boost::mem_fn(&X::cmf5_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf5_1) != boost::mem_fn(&X::cmf5_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf5v_1) == boost::mem_fn(&X::mf5v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf5v_1) != boost::mem_fn(&X::mf5v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf5v_1) == boost::mem_fn(&X::cmf5v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf5v_1) != boost::mem_fn(&X::cmf5v_2) );
|
||||
|
||||
// 6
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf6_1) == boost::mem_fn(&X::mf6_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf6_1) != boost::mem_fn(&X::mf6_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf6_1) == boost::mem_fn(&X::cmf6_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf6_1) != boost::mem_fn(&X::cmf6_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf6v_1) == boost::mem_fn(&X::mf6v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf6v_1) != boost::mem_fn(&X::mf6v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf6v_1) == boost::mem_fn(&X::cmf6v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf6v_1) != boost::mem_fn(&X::cmf6v_2) );
|
||||
|
||||
// 7
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf7_1) == boost::mem_fn(&X::mf7_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf7_1) != boost::mem_fn(&X::mf7_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf7_1) == boost::mem_fn(&X::cmf7_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf7_1) != boost::mem_fn(&X::cmf7_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf7v_1) == boost::mem_fn(&X::mf7v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf7v_1) != boost::mem_fn(&X::mf7v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf7v_1) == boost::mem_fn(&X::cmf7v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf7v_1) != boost::mem_fn(&X::cmf7v_2) );
|
||||
|
||||
// 8
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf8_1) == boost::mem_fn(&X::mf8_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf8_1) != boost::mem_fn(&X::mf8_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf8_1) == boost::mem_fn(&X::cmf8_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf8_1) != boost::mem_fn(&X::cmf8_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::mf8v_1) == boost::mem_fn(&X::mf8v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::mf8v_1) != boost::mem_fn(&X::mf8v_2) );
|
||||
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf8v_1) == boost::mem_fn(&X::cmf8v_1) );
|
||||
BOOST_TEST( boost::mem_fn(&X::cmf8v_1) != boost::mem_fn(&X::cmf8v_2) );
|
||||
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#define BOOST_MEM_FN_ENABLE_FASTCALL
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#define BOOST_MEM_FN_ENABLE_STDCALL
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#if defined(_MSC_VER) && !defined(__ICL)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
@@ -12,9 +10,10 @@
|
||||
//
|
||||
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#include <boost/mem_fn.hpp>
|
||||
|
||||
Reference in New Issue
Block a user