mirror of
https://github.com/boostorg/function.git
synced 2026-01-28 19:22:09 +00:00
Compare commits
1 Commits
svn-branch
...
boost-1.26
| Author | SHA1 | Date | |
|---|---|---|---|
|
eda5c2bf48 |
@@ -32,7 +32,7 @@
|
||||
<b>typename</b> Allocator = std::allocator<function_base> >
|
||||
<b>class</b> <a href="#functionN">function<i>N</i></a> : <b>public</b> <a href="#function_base">function_base</a>, <b>public</b> Mixin
|
||||
{
|
||||
<b>typedef</b> ResultType result_type; <em>// <a href="#novoid">[1]</a></em>
|
||||
<b>typedef</b> ResultType result_type;
|
||||
<b>typedef</b> Policy policy_type;
|
||||
<b>typedef</b> Mixin mixin_type;
|
||||
<b>typedef</b> Allocator allocator_type;
|
||||
@@ -45,15 +45,13 @@
|
||||
<i>// Construction</i>
|
||||
<a href="#functionN_default"><b>explicit</b> function<i>N</i>(<b>const</b> Mixin<b>&</b> = Mixin())</a>;
|
||||
<a href="#functionN_copy">function<i>N</i>(<b>const</b> function<i>N</i><b>&</b>)</a>;
|
||||
<a href="#functionN_target"><b>template</b><<b>typename</b> F> function<i>N</i>(F, <b>const</b> Mixin<b>&</b> = Mixin())</a>;
|
||||
<a href="#functionN_target_ref"><b>template</b><<b>typename</b> F> function<i>N</i>(reference_wrapper<F>)</a>;
|
||||
<a href="#functionN_target"><b>template</b><<b>typename</b> F> function<i>N</i>(<b>const</b> F<b>&</b>, <b>const</b> Mixin<b>&</b> = Mixin())</a>;
|
||||
|
||||
<i>// Assignment</i>
|
||||
<a href="#functionN_copy_assn">function<i>N</i><b>&</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&</b>)</a>;
|
||||
<a href="#functionN_target_assn"><b>template</b><<b>typename</b> F> function<i>N</i><b>&</b> <b>operator</b>=(F)</a>;
|
||||
<a href="#functionN_target_ref_assn"><b>template</b><<b>typename</b> F> function<i>N</i><b>&</b> <b>operator</b>=(reference_wrapper<F>)</a>;
|
||||
<a href="#functionN_target_assn"><b>template</b><<b>typename</b> F> function<i>N</i><b>&</b> <b>operator</b>=(<b>const</b> F<b>&</b>)</a>;
|
||||
<a href="#functionN_copy_set"><b>void</b> set(<b>const</b> function<i>N</i><b>&</b>)</a>;
|
||||
<a href="#functionN_target_set"><b>template</b><<b>typename</b> F> <b>void</b> set(F)</a>;
|
||||
<a href="#functionN_target_set"><b>template</b><<b>typename</b> F> <b>void</b> set(<b>const</b> F<b>&</b>)</a>;
|
||||
<a href="#functionN_swap"><b>void</b> swap(function<i>N</i><b>&</b>)</a>;
|
||||
<a href="#functionN_clear"><b>void</b> clear()</a>;
|
||||
|
||||
@@ -69,8 +67,8 @@
|
||||
<b>typename</b> Policy,
|
||||
<b>typename</b> Mixin,
|
||||
<b>typename</b> Allocator>
|
||||
<b>void</b> <a href="#swap_functionN">swap</a>(function<em>N</em><ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator><b>&</b>,
|
||||
function<em>N</em><ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator><b>&</b>);
|
||||
<b>void</b> <a href="#swap_functionN">swap</a>(<b>const</b> function<em>N</em><Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator><b>&</b>,
|
||||
<b>const</b> function<em>N</em><Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator><b>&</b>);
|
||||
|
||||
// For any <i>N</i> in [0, <i>MAX_ARGS</i>]
|
||||
<b>template</b><<b>typename</b> ResultType,
|
||||
@@ -82,21 +80,21 @@
|
||||
<b>typename</b> Arg<i>N+2</i> = <i>implementation-defined</i>,
|
||||
<i>...</i>
|
||||
<b>typename</b> Arg<i>MAX_ARGS</i> = <i>implementation-defined</i>>
|
||||
<b>class</b> <a href="#function">function</a> : <b>public</b> <a href="#functionN">function<i>N</i></a><ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>>
|
||||
<b>class</b> <a href="#function">function</a> : <b>public</b> <a href="#functionN">function<i>N</i></a><Arg1, Arg2, <i>...</i>, Arg<i>N</i>>
|
||||
{
|
||||
<i>// Construction</i>
|
||||
function();
|
||||
function(<b>const</b> function<b>&</b>);
|
||||
function(<b>const</b> function<i>N</i><ResultType, Arg1, Arg2, ..., Arg<i>N</i>><b>&</b>);
|
||||
<b>template</b><<b>typename</b> F> function<i>N</i>(F);
|
||||
function<i>N</i>(<b>const</b> function<i>N</i><b>&</b>);
|
||||
<b>template</b><<b>typename</b> F> function<i>N</i>(<b>const</b> F<b>&</b>);
|
||||
|
||||
<i>// Assignment</i>
|
||||
function<b>&</b> <b>operator</b>=(<b>const</b> function<b>&</b>);
|
||||
function<b>&</b> <b>operator</b>=(<b>const</b> function<i>N</i><ResultType, Arg1, Arg2, ..., Arg<i>N</i>><b>&</b>);
|
||||
<b>template</b><<b>typename</b> F> function<b>&</b> <b>operator</b>=(F);
|
||||
function<i>N</i><b>&</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&</b>);
|
||||
<b>template</b><<b>typename</b> F> function<b>&</b> <b>operator</b>=(<b>const</b> F<b>&</b>);
|
||||
<b>void</b> set(<b>const</b> function<b>&</b>);
|
||||
<b>void</b> set(<b>const</b> function<i>N</i><ResultType, Arg1, Arg2, ..., Arg<i>N</i>><b>&</b>);
|
||||
<b>template</b><<b>typename</b> F> <b>void</b> set(F);
|
||||
<b>void</b> set(<b>const</b> function<i>N</i><b>&</b>);
|
||||
<b>template</b><<b>typename</b> F> <b>void</b> set(<b>const</b> F<b>&</b>);
|
||||
};
|
||||
|
||||
<b>template</b><<b>typename</b> ResultType,
|
||||
@@ -104,8 +102,8 @@
|
||||
<b>typename</b> Arg2,
|
||||
<i>...</i>
|
||||
<b>typename</b> Arg<i>MAX_ARGS</i>>
|
||||
<b>void</b> <a href="#swap_function">swap</a>(function<ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>><b>&</b>,
|
||||
function<ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>><b>&</b>);
|
||||
<b>void</b> <a href="#swap_function">swap</a>(<b>const</b> function<Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>><b>&</b>,
|
||||
<b>const</b> function<Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>><b>&</b>);
|
||||
}
|
||||
</pre>
|
||||
|
||||
@@ -128,13 +126,22 @@
|
||||
</pre>
|
||||
<p> A special provision is made for pointers to member functions. Though they are not function objects, Boost.Function will adapt them internally to function objects. This requires that a pointer to member function of the form <code>R (X::*mf)(Arg1, Arg2, ..., Arg<em>N</em>) <em>cv-quals</em></code> be adapted to a function object with the following function call operator overloads:
|
||||
<pre>
|
||||
R <b>operator</b>()(<em>cv-quals</em> X& x, Arg1 arg1, Arg2 arg2, ..., Arg<em>N</em> arg<em>N</em>) <b>const</b>
|
||||
{
|
||||
<b>return</b> x.*mf(arg1, arg2, ..., arg<em>N</em>);
|
||||
}
|
||||
|
||||
R <b>operator</b>()(<em>cv-quals</em> X* x, Arg1 arg1, Arg2 arg2, ..., Arg<em>N</em> arg<em>N</em>) <b>const</b>
|
||||
{
|
||||
<b>return</b> x->*mf(arg1, arg2, ..., arg<em>N</em>);
|
||||
}
|
||||
|
||||
<b>template</b><<b>typename P</b>>
|
||||
R <b>operator</b>()(<em>cv-quals</em> P& x, Arg1 arg1, Arg2 arg2, ..., Arg<em>N</em> arg<em>N</em>) <b>const</b>
|
||||
{
|
||||
<b>return</b> (*x).*mf(arg1, arg2, ..., arg<em>N</em>);
|
||||
}
|
||||
</pre>
|
||||
<li><a name="stateless"></a>A function object <code>f</code> of type <code>F</code> is <em>stateless</em> if it is a function pointer or if <a href="../../type_traits/index.htm#properties"><code>boost::is_stateless<T></code></a> is true. The construction of or copy to a Boost.Function object from a stateless function object will not cause exceptions to be thrown and will not allocate any storage.</li>
|
||||
</ul>
|
||||
|
||||
<h2><a name="function_base">Class <code>function_base</code></a></h2>
|
||||
@@ -167,52 +174,34 @@
|
||||
<ul>
|
||||
<li><b>Effects</b>: Constructs the <code>Mixin</code> subobject with the given mixin.</li>
|
||||
<li><b>Postconditions</b>: <code>f.<a href="#empty">empty</a>()</code>.</li>
|
||||
<li><b>Throws</b>: will not throw unless construction of the <code>Mixin</code> subobject throws.</li>
|
||||
<li><b>Throws</b>: will not throw.</li>
|
||||
</ul>
|
||||
|
||||
<p> <a name="functionN_copy"><code>function<i>N</i>(<b>const</b> function<i>N</i><b>&</b> g);</code></a>
|
||||
<ul>
|
||||
<li><b>Postconditions</b>: <code>f</code> contains a copy of the <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for the <code>f</code> is copy-constructed from the mixin of <code>g</code>.</li>
|
||||
<li><b>Throws</b>: will not throw unless copying the target of <code>g</code> or construction of the <code>Mixin</code> subobject throws.</li>
|
||||
</ul>
|
||||
|
||||
<p> <a name="functionN_target"><code><b>template</b><<b>typename</b> F> function<i>N</i>(F g, <b>const</b> Mixin<b>&</b> = Mixin());</code></a>
|
||||
<p> <a name="functionN_target"><code><b>template</b><<b>typename</b> F> function<i>N</i>(<b>const</b> F<b>&</b> g, <b>const</b> Mixin<b>&</b> = Mixin());</code></a>
|
||||
<ul>
|
||||
<li><b>Requires</b>: <code>g</code> is a <a href="#compatible">compatible</a> function object.</li>
|
||||
<li><b>Effects</b>: Constructs the <code>Mixin</code> subobject from the given mixin.</li>
|
||||
<li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code> if <code>g</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g</code> is empty.</li>
|
||||
<li><b>Throws</b>: will not throw when <code>g</code> is a <a href="#stateless">stateless</a> function object unless construction of the <code>Mixin</code> subobject throws.</li>
|
||||
</ul>
|
||||
|
||||
<p> <a name="functionN_target_ref"><code><b>template</b><<b>typename</b> F> function<i>N</i>(<a href="../../bind/ref.html">reference_wrapper</a><F> g);</code></a>
|
||||
<ul>
|
||||
<li><b>Requires</b>: <code>g.get()</code> is a <a href="#compatible">compatible</a> function object.</li>
|
||||
<li><b>Effects</b>: Constructs the <code>Mixin</code> subobject from the given mixin.</li>
|
||||
<li><b>Postconditions</b>: <code>this</code> object targets <code>g</code> (<em>not</em> a copy of <code>g.get()</code>) if <code>g.get()</code> is nonempty, or <code>this->empty()</code> if <code>g.get()</code> is empty.</li>
|
||||
<li><b>Throws</b>: will not throw unless the construction of the <code>Mixin</code> subobject throws.</li>
|
||||
<li><b>Rationale</b>: <code>g</code> is a reference-to-<code><b>const</b></code> because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of <code>g</code> is reference-to-<code><b>const</b></code> pointer-to-function.</li>
|
||||
</ul>
|
||||
|
||||
<p> <a name="functionN_copy_assn"><code>function<i>N</i><b>&</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&</b> g);</code></a>
|
||||
<ul>
|
||||
<li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for <code>f</code> is assigned the value of the mixin for <code>g</code>.</li>
|
||||
<li><b>Returns</b>: <code>*this</code>.</li>
|
||||
<li><b>Throws</b>: will not throw when the target of <code>g</code> is a <a href="#stateless">stateless</a> function object or a reference to the function object, unless the copy of the <code>Mixin</code> subobject throws.</li>
|
||||
</ul>
|
||||
|
||||
<p> <a name="functionN_target_assn"><code><b>template</b><<b>typename</b> F> function<i>N</i><b>&</b> <b>operator</b>=(F g);</code></a>
|
||||
<p> <a name="functionN_target_assn"><code><b>template</b><<b>typename</b> F> function<i>N</i><b>&</b> <b>operator</b>=(<b>const</b> F<b>&</b> g);</code></a>
|
||||
<ul>
|
||||
<li><b>Requires</b>: <code>g</code> is a <a href="#compatible">compatible</a> function object.</li>
|
||||
<li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code> if <code>g</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g</code> is empty.</li>
|
||||
<li><b>Returns</b>: <code>*this</code>.</li>
|
||||
<li><b>Throws</b>: will not throw when <code>g</code> is a <a href="#stateless">stateless</a> function object.</li>
|
||||
</ul>
|
||||
|
||||
<p> <a name="functionN_target_ref_assn"><code><b>template</b><<b>typename</b> F> function<i>N</i><b>&</b> <b>operator</b>=(<a href="../../bind/ref.html">reference_wrapper</a><F> g);</code></a>
|
||||
<ul>
|
||||
<li><b>Requires</b>: <code>g.get()</code> is a <a href="#compatible">compatible</a> function object.</li>
|
||||
<li><b>Postconditions</b>: <code>f</code> targets <code>g.get()</code> (not a copy of <code>g.get()</code>) if <code>g.get()</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g.get()</code> is empty.</li>
|
||||
<li><b>Returns</b>: <code>*this</code>.</li>
|
||||
<li><b>Throws</b>: will throw only if the destruction or deallocation of the target of <code>this</code> throws.</li>
|
||||
<li><b>Rationale</b>: <code>g</code> is a reference-to-<code><b>const</b></code> because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of <code>g</code> is reference-to-<code><b>const</b></code> pointer-to-function.</li>
|
||||
</ul>
|
||||
|
||||
<p> <a name="functionN_copy_set"><code><b>void</b> set(<b>const</b> function<i>N</i><b>&</b> g);</code></a>
|
||||
@@ -220,7 +209,7 @@
|
||||
<li><b>Effects</b>: <code><a href="#functionN_copy_assn">*this = g</a></code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> <a name="functionN_target_set"><code><b>template</b><<b>typename</b> F> <b>void</b> set(F g);</code></a>
|
||||
<p> <a name="functionN_target_set"><code><b>template</b><<b>typename</b> F> <b>void</b> set(<b>const</b> F<b>&</b> g);</code></a>
|
||||
<ul>
|
||||
<li><b>Effects</b>: <code><a href="#functionN_target_assn">*this = g</a></code>.</li>
|
||||
</ul>
|
||||
@@ -266,8 +255,8 @@
|
||||
<b>typename</b> Policy,
|
||||
<b>typename</b> Mixin,
|
||||
<b>typename</b> Allocator>
|
||||
<b>void</b> <a name="swap_functionN">swap</a>(function<i>N</i><ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator><b>&</b> f,
|
||||
function<i>N</i><ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator><b>&</b> g);
|
||||
<b>void</b> <a name="swap_functionN">swap</a>(<b>const</b> function<i>N</i><Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator><b>&</b> f,
|
||||
<b>const</b> function<i>N</i><Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator><b>&</b> g);
|
||||
</pre>
|
||||
<ul>
|
||||
<li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>
|
||||
@@ -280,20 +269,18 @@
|
||||
<b>typename</b> Arg2,
|
||||
<i>...</i>
|
||||
<b>typename</b> Arg<i>MAX_ARGS</i>>
|
||||
<b>void</b> <a name="swap_function">swap</a>(function<ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>><b>&</b> f,
|
||||
function<ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>><b>&</b> g);
|
||||
<b>void</b> <a name="swap_function">swap</a>(<b>const</b> function<Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>><b>&</b> f,
|
||||
<b>const</b> function<Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>><b>&</b> g);
|
||||
</pre>
|
||||
<ul>
|
||||
<li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>
|
||||
</ul>
|
||||
|
||||
<hr>
|
||||
<p><a name="novoid">[1]</a> On compilers not supporting void returns, when the <code>ReturnType</code> is <b>void</b>, the <code>result_type</code> of a Boost.Function object is implementation-defined.
|
||||
<hr>
|
||||
<address><a href="mailto:gregod@cs.rpi.edu">Douglas Gregor</a></address>
|
||||
<!-- Created: Fri Jul 13 10:57:20 EDT 2001 -->
|
||||
<!-- hhmts start -->
|
||||
Last modified: Thu Jan 31 21:55:35 EST 2002
|
||||
Last modified: Sun Oct 28 00:40:55 EDT 2001
|
||||
<!-- hhmts end -->
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -60,11 +60,9 @@ else
|
||||
<p> Free function pointers can be considered singleton function objects with const function call operators, and can therefore be directly used with the function object wrappers:
|
||||
<pre>
|
||||
float mul_ints(int x, int y) { return ((float)x) * y; }
|
||||
f = &mul_ints;
|
||||
f = &mul_ints;
|
||||
</pre>
|
||||
|
||||
<p> Note that the <code>&</code> isn't really necessary unless you happen to be using Microsoft Visual C++ version 6.
|
||||
|
||||
<h3>Member functions</h3>
|
||||
<a name="member_func">
|
||||
<p> In many systems, callbacks often call to member functions of a particular
|
||||
@@ -75,10 +73,10 @@ object. This is often referred to as "argument binding", and is beyond the scope
|
||||
};
|
||||
|
||||
boost::function<int, X*, int> f;
|
||||
f = &X::foo;
|
||||
f = &X::foo;
|
||||
|
||||
X x;
|
||||
f(&x, 5);
|
||||
f(&x, 5);
|
||||
</pre>
|
||||
<p> Several libraries exist that support argument binding. Three such libraries are summarized below:
|
||||
<ul>
|
||||
@@ -99,30 +97,6 @@ object. This is often referred to as "argument binding", and is beyond the scope
|
||||
<li><a href="http://lambda.cs.utu.fi/">The Lambda library</a>. This library provides a powerful composition mechanism to construct function objects that uses very natural C++ syntax. Lambda requires a compiler that is reasonably conformant to the C++ standard. Note that it is not a Boost library.</li>
|
||||
</ul>
|
||||
|
||||
<h3>References to Functions</h3>
|
||||
<p> In some cases it is expensive (or semantically incorrect) to have
|
||||
Boost.Function clone a function object. In such cases, it is possible
|
||||
to request that Boost.Function keep only a reference to the actual
|
||||
function object. This is done using the <a
|
||||
href="../../bind/ref.html"><code>ref</code></a> and <a
|
||||
href="../../bind/ref.html"><code>cref</code></a> functions to wrap a
|
||||
reference to a function object:
|
||||
|
||||
<pre>
|
||||
stateful_type a_function_object;
|
||||
boost::function<int, int> f;
|
||||
f = ref(a_function_object);
|
||||
|
||||
boost::function<int, int> f2(f);
|
||||
</pre>
|
||||
|
||||
Here, <code>f</code> will not make a copy of
|
||||
<code>a_function_object</code>, nor will <code>f2</code> when it is
|
||||
targeted to <code>f</code>'s reference to
|
||||
<code>a_function_object</code>. Additionally, when using references to
|
||||
function objects, Boost.Function will not throw exceptions during
|
||||
assignment or construction.
|
||||
|
||||
<h2><a name="family">The <code>function</code> family</a></h2>
|
||||
<p> The header <<a href="../../../boost/function.hpp">boost/function.hpp</a>> defines the primary entry point to the function object wrappers, the class template <code>boost::function</code>. This class template is essentially a thin wrapper around a set of similar numbered function object wrappers, <code>boost::function0</code>, <code>boost::function1</code>, etc., where the number indicates the number of arguments passed to the function object target. The declaration of <code>f</code> above could also be written as:
|
||||
<pre>
|
||||
@@ -199,7 +173,7 @@ boost::function2<float, int, int, SynchronizedPolicy, SynchronizedMixin> f
|
||||
<address><a href="mailto:gregod@cs.rpi.edu">Douglas Gregor</a></address>
|
||||
<!-- Created: Fri Jul 13 12:47:11 EDT 2001 -->
|
||||
<!-- hhmts start -->
|
||||
Last modified: Fri Dec 14 19:58:14 EST 2001
|
||||
Last modified: Sun Oct 28 00:49:02 EDT 2001
|
||||
<!-- hhmts end -->
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -27,9 +27,7 @@ void do_sum_avg(int values[], int n, int& sum, float& avg)
|
||||
int
|
||||
main()
|
||||
{
|
||||
// The second parameter should be int[], but some compilers (e.g., GCC)
|
||||
// complain about this
|
||||
boost::function<void, int*, int, int&, float&> sum_avg;
|
||||
boost::function<void, int[], int, int&, float&> sum_avg;
|
||||
|
||||
sum_avg = &do_sum_avg;
|
||||
|
||||
|
||||
@@ -456,35 +456,56 @@ namespace boost {
|
||||
function() : base_type() {}
|
||||
|
||||
template<typename Functor>
|
||||
function(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) : base_type(f) {}
|
||||
function(const Functor& f) : base_type(f) {}
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
template<typename Functor> function(Functor* f) : base_type(f) {}
|
||||
#endif // __BORLANDC__
|
||||
|
||||
function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
|
||||
|
||||
template<typename Functor>
|
||||
self_type& operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
|
||||
function& operator=(const Functor& f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
template<typename Functor>
|
||||
self_type& operator=(Functor* f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
#endif // __BORLANDC__
|
||||
|
||||
self_type& operator=(const base_type& f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
self_type& operator=(const self_type& f)
|
||||
self_type& operator=(const self_type& f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
|
||||
void set(const Functor& f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
}
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
template<typename Functor>
|
||||
void set(Functor* f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
}
|
||||
#endif // __BORLANDC__
|
||||
|
||||
void set(const base_type& f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
|
||||
@@ -23,13 +23,6 @@
|
||||
#include <typeinfo>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/type_traits.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406
|
||||
# define BOOST_FUNCTION_TARGET_FIX(x) x
|
||||
#else
|
||||
# define BOOST_FUNCTION_TARGET_FIX(x)
|
||||
#endif // not MSVC
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
@@ -129,41 +122,20 @@ namespace boost {
|
||||
struct function_ptr_tag {};
|
||||
struct function_obj_tag {};
|
||||
struct member_ptr_tag {};
|
||||
struct function_obj_ref_tag {};
|
||||
struct stateless_function_obj_tag {};
|
||||
|
||||
template<typename F>
|
||||
class get_function_tag
|
||||
{
|
||||
typedef typename IF<(is_pointer<F>::value),
|
||||
typedef typename IF<(is_pointer<F>::value),
|
||||
function_ptr_tag,
|
||||
function_obj_tag>::type ptr_or_obj_tag;
|
||||
|
||||
typedef typename IF<(is_member_pointer<F>::value),
|
||||
member_ptr_tag,
|
||||
ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
|
||||
|
||||
typedef typename IF<(is_reference_wrapper<F>::value),
|
||||
function_obj_ref_tag,
|
||||
ptr_or_obj_or_mem_tag>::type or_ref_tag;
|
||||
|
||||
public:
|
||||
typedef typename IF<(is_stateless<F>::value),
|
||||
stateless_function_obj_tag,
|
||||
or_ref_tag>::type type;
|
||||
typedef typename IF<(is_member_pointer<F>::value),
|
||||
member_ptr_tag,
|
||||
ptr_or_obj_tag>::type type;
|
||||
};
|
||||
|
||||
// The trivial manager does nothing but return the same pointer (if we
|
||||
// are cloning) or return the null pointer (if we are deleting).
|
||||
inline any_pointer trivial_manager(any_pointer f,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
if (op == clone_functor_tag)
|
||||
return f;
|
||||
else
|
||||
return any_pointer(reinterpret_cast<void*>(0));
|
||||
}
|
||||
|
||||
/**
|
||||
* The functor_manager class contains a static function "manage" which
|
||||
* can clone or destroy the given function/function object pointer.
|
||||
@@ -301,7 +273,7 @@ namespace boost {
|
||||
// Is this function empty?
|
||||
bool empty() const { return !manager; }
|
||||
|
||||
public: // should be protected, but GCC 2.95.3 will fail to allow access
|
||||
protected:
|
||||
detail::function::any_pointer (*manager)(
|
||||
detail::function::any_pointer,
|
||||
detail::function::functor_manager_operation_type);
|
||||
|
||||
@@ -50,16 +50,10 @@
|
||||
BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(stateless_void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
|
||||
BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(get_stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
@@ -107,7 +101,7 @@ namespace boost {
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
|
||||
FunctionObj* f = static_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
return (*f)(BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
};
|
||||
@@ -124,43 +118,12 @@ namespace boost {
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
|
||||
FunctionObj* f = static_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
(*f)(BOOST_FUNCTION_ARGS);
|
||||
return unusable();
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static R invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)
|
||||
{
|
||||
FunctionObj f = FunctionObj();
|
||||
return f(BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static unusable invoke(any_pointer BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj f = FunctionObj();
|
||||
f(BOOST_FUNCTION_ARGS);
|
||||
return unusable();
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionPtr,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
@@ -202,28 +165,6 @@ namespace boost {
|
||||
>
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
typedef typename IF<(is_void<R>::value),
|
||||
BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>,
|
||||
BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>
|
||||
>::type type;
|
||||
};
|
||||
|
||||
} // end namespace function
|
||||
} // end namespace detail
|
||||
|
||||
@@ -236,9 +177,6 @@ namespace boost {
|
||||
>
|
||||
class BOOST_FUNCTION_FUNCTION : public function_base, public Mixin
|
||||
{
|
||||
typedef typename detail::function::function_return_type<R>::type
|
||||
internal_result_type;
|
||||
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
|
||||
|
||||
@@ -248,12 +186,8 @@ namespace boost {
|
||||
typedef T0 first_argument_type;
|
||||
typedef T1 second_argument_type;
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
typedef R result_type;
|
||||
#else
|
||||
typedef internal_result_type result_type;
|
||||
#endif // BOOST_NO_VOID_RETURNS
|
||||
typedef typename detail::function::function_return_type<R>::type
|
||||
result_type;
|
||||
typedef Policy policy_type;
|
||||
typedef Mixin mixin_type;
|
||||
typedef Allocator allocator_type;
|
||||
@@ -269,14 +203,23 @@ namespace boost {
|
||||
// MSVC chokes if the following two constructors are collapsed into
|
||||
// one with a default parameter.
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) :
|
||||
BOOST_FUNCTION_FUNCTION(const Functor& f) :
|
||||
function_base(), Mixin(), invoker(0)
|
||||
{
|
||||
this->assign_to(f);
|
||||
}
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_FUNCTION(Functor f, const Mixin& m) :
|
||||
BOOST_FUNCTION_FUNCTION(Functor* f) :
|
||||
function_base(), Mixin(), invoker(0)
|
||||
{
|
||||
this->assign_to(f);
|
||||
}
|
||||
#endif // __BORLANDC__
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_FUNCTION(const Functor& f, const Mixin& m) :
|
||||
function_base(), Mixin(m), invoker(0)
|
||||
{
|
||||
this->assign_to(f);
|
||||
@@ -297,16 +240,11 @@ namespace boost {
|
||||
policy_type policy;
|
||||
policy.precall(this);
|
||||
|
||||
internal_result_type result = invoker(function_base::functor
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_ARGS);
|
||||
result_type result = invoker(functor BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_ARGS);
|
||||
|
||||
policy.postcall(this);
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
return static_cast<result_type>(result);
|
||||
#else
|
||||
return result;
|
||||
#endif // BOOST_NO_VOID_RETURNS
|
||||
}
|
||||
|
||||
// The distinction between when to use BOOST_FUNCTION_FUNCTION and
|
||||
@@ -315,19 +253,35 @@ namespace boost {
|
||||
// handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
|
||||
// construct.
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_FUNCTION&
|
||||
operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
|
||||
BOOST_FUNCTION_FUNCTION& operator=(const Functor& f)
|
||||
{
|
||||
self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
template<typename Functor>
|
||||
void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
|
||||
BOOST_FUNCTION_FUNCTION& operator=(Functor* f)
|
||||
{
|
||||
self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
#endif // __BORLANDC__
|
||||
|
||||
template<typename Functor>
|
||||
void set(const Functor& f)
|
||||
{
|
||||
self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
|
||||
}
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
template<typename Functor>
|
||||
void set(Functor* f)
|
||||
{
|
||||
self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
|
||||
}
|
||||
#endif // __BORLANDC__
|
||||
|
||||
// Assignment from another BOOST_FUNCTION_FUNCTION
|
||||
BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
|
||||
{
|
||||
@@ -352,8 +306,8 @@ namespace boost {
|
||||
if (&other == this)
|
||||
return;
|
||||
|
||||
std::swap(function_base::manager, other.manager);
|
||||
std::swap(function_base::functor, other.functor);
|
||||
std::swap(manager, other.manager);
|
||||
std::swap(functor, other.functor);
|
||||
std::swap(invoker, other.invoker);
|
||||
std::swap(static_cast<Mixin&>(*this), static_cast<Mixin&>(other));
|
||||
}
|
||||
@@ -361,10 +315,10 @@ namespace boost {
|
||||
// Clear out a target, if there is one
|
||||
void clear()
|
||||
{
|
||||
if (function_base::manager)
|
||||
function_base::functor = function_base::manager(function_base::functor, detail::function::destroy_functor_tag);
|
||||
if (manager)
|
||||
functor = manager(functor, detail::function::destroy_functor_tag);
|
||||
|
||||
function_base::manager = 0;
|
||||
manager = 0;
|
||||
invoker = 0;
|
||||
}
|
||||
|
||||
@@ -373,13 +327,13 @@ namespace boost {
|
||||
{
|
||||
if (!f.empty()) {
|
||||
invoker = f.invoker;
|
||||
function_base::manager = f.manager;
|
||||
function_base::functor = f.manager(f.functor, detail::function::clone_functor_tag);
|
||||
manager = f.manager;
|
||||
functor = f.manager(f.functor, detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
void assign_to(Functor f)
|
||||
void assign_to(const Functor& f)
|
||||
{
|
||||
typedef typename detail::function::get_function_tag<Functor>::type tag;
|
||||
this->assign_to(f, tag());
|
||||
@@ -399,12 +353,10 @@ namespace boost {
|
||||
invoker_type;
|
||||
|
||||
invoker = &invoker_type::invoke;
|
||||
function_base::manager = &detail::function::functor_manager<FunctionPtr,
|
||||
manager = &detail::function::functor_manager<FunctionPtr,
|
||||
Allocator>::manage;
|
||||
function_base::functor = function_base::manager(detail::function::any_pointer(
|
||||
// should be a reinterpret cast, but some compilers
|
||||
// insist on giving cv-qualifiers to free functions
|
||||
(void (*)())(f)
|
||||
functor = manager(detail::function::any_pointer(
|
||||
reinterpret_cast<void (*)()>(f)
|
||||
),
|
||||
detail::function::clone_functor_tag);
|
||||
}
|
||||
@@ -419,7 +371,7 @@ namespace boost {
|
||||
#endif // BOOST_FUNCTION_NUM_ARGS > 0
|
||||
|
||||
template<typename FunctionObj>
|
||||
void assign_to(FunctionObj f, detail::function::function_obj_tag)
|
||||
void assign_to(const FunctionObj& f, detail::function::function_obj_tag)
|
||||
{
|
||||
if (!detail::function::has_empty_target(&f)) {
|
||||
typedef
|
||||
@@ -431,55 +383,17 @@ namespace boost {
|
||||
invoker_type;
|
||||
|
||||
invoker = &invoker_type::invoke;
|
||||
function_base::manager = &detail::function::functor_manager<FunctionObj,
|
||||
manager = &detail::function::functor_manager<FunctionObj,
|
||||
Allocator>::manage;
|
||||
function_base::functor =
|
||||
function_base::manager(detail::function::any_pointer(const_cast<FunctionObj*>(&f)),
|
||||
functor =
|
||||
manager(detail::function::any_pointer(const_cast<FunctionObj*>(&f)),
|
||||
detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename FunctionObj>
|
||||
void assign_to(const reference_wrapper<FunctionObj>& f,
|
||||
detail::function::function_obj_ref_tag)
|
||||
{
|
||||
if (!detail::function::has_empty_target(&f.get())) {
|
||||
typedef
|
||||
typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
|
||||
invoker = &invoker_type::invoke;
|
||||
function_base::manager = &detail::function::trivial_manager;
|
||||
function_base::functor =
|
||||
function_base::manager(detail::function::any_pointer(
|
||||
const_cast<FunctionObj*>(&f.get())),
|
||||
detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename FunctionObj>
|
||||
void assign_to(FunctionObj, detail::function::stateless_function_obj_tag)
|
||||
{
|
||||
typedef
|
||||
typename detail::function::
|
||||
BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
invoker = &invoker_type::invoke;
|
||||
function_base::manager = &detail::function::trivial_manager;
|
||||
function_base::functor = detail::function::any_pointer(this);
|
||||
}
|
||||
|
||||
typedef internal_result_type (*invoker_type)(detail::function::any_pointer
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS);
|
||||
typedef result_type (*invoker_type)(detail::function::any_pointer
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS);
|
||||
|
||||
invoker_type invoker;
|
||||
};
|
||||
@@ -515,10 +429,7 @@ namespace boost {
|
||||
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
|
||||
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
|
||||
|
||||
|
||||
@@ -50,7 +50,7 @@ And, of course, function pointers have several advantages over Boost.Function:
|
||||
<p> Function object wrappers will be the size of two function pointers plus one function pointer or data pointer (whichever is larger). On common 32-bit platforms, this amounts to 12 bytes per wrapper. Additionally, the function object target will be allocated on the heap.
|
||||
|
||||
<h3>Copying efficiency</h3>
|
||||
<p> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <a href="../bind/ref.html"><code>ref</code></a>) if the cost of this cloning becomes prohibitive.
|
||||
<p> Copying function object wrappers requires allocating member for a copy of the function object target. The default allocator may be replaced with a faster custom allocator if the cost of this cloning becomes prohibitive.
|
||||
|
||||
<h3>Invocation efficiency</h3>
|
||||
<p> With a properly inlining compiler, an invocation of a function object requires one call through a function pointer. If the call is to a free function pointer, an additional call must be made to that function pointer (unless the compiler has very powerful interprocedural analysis).
|
||||
|
||||
@@ -102,7 +102,7 @@ test_zero_args()
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = write_five;
|
||||
v1 = &write_five;
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
@@ -129,7 +129,7 @@ test_zero_args()
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = write_three;
|
||||
v1 = &write_three;
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
@@ -604,35 +604,6 @@ test_member_functions()
|
||||
BOOST_TEST(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
int operator()(int x, int y) const { return x+y; }
|
||||
|
||||
add_with_throw_on_copy() {}
|
||||
|
||||
add_with_throw_on_copy(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
}
|
||||
|
||||
add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
}
|
||||
};
|
||||
|
||||
static void
|
||||
test_ref()
|
||||
{
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function2<int, int, int> f(ref(atc));
|
||||
BOOST_TEST(f(1, 3) == 4);
|
||||
}
|
||||
catch(std::runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
@@ -640,6 +611,5 @@ int test_main(int, char* [])
|
||||
test_two_args();
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -102,7 +102,7 @@ test_zero_args()
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
v1 = &write_five;
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
@@ -111,7 +111,7 @@ test_zero_args()
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
v1 = &write_three;
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
@@ -163,7 +163,7 @@ test_zero_args()
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v2.set(BOOST_FUNCTION_TARGET_FIX(&) write_five);
|
||||
v2.set(&write_five);
|
||||
BOOST_TEST(v2);
|
||||
|
||||
// Invocation
|
||||
@@ -172,7 +172,7 @@ test_zero_args()
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
v2 = &write_three;
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
@@ -227,7 +227,7 @@ test_zero_args()
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assign to a function from a function with a function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
v2 = &write_five;
|
||||
v1 = v2;
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
@@ -603,35 +603,6 @@ test_member_functions()
|
||||
BOOST_TEST(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
int operator()(int x, int y) const { return x+y; }
|
||||
|
||||
add_with_throw_on_copy() {}
|
||||
|
||||
add_with_throw_on_copy(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
}
|
||||
|
||||
add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
}
|
||||
};
|
||||
|
||||
static void
|
||||
test_ref()
|
||||
{
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function<int, int, int> f(ref(atc));
|
||||
BOOST_TEST(f(1, 3) == 4);
|
||||
}
|
||||
catch(std::runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
@@ -639,7 +610,5 @@ int test_main(int, char* [])
|
||||
test_two_args();
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -20,7 +20,7 @@
|
||||
#include <boost/function.hpp>
|
||||
|
||||
struct id_mixin
|
||||
{
|
||||
{
|
||||
id_mixin(const id_mixin& rhs) : id(rhs.id) {}
|
||||
id_mixin& operator=(const id_mixin& rhs){id = rhs.id; return *this;}
|
||||
id_mixin(int i = 0){ id = i;}
|
||||
@@ -49,12 +49,12 @@ int test_main(int, char*[])
|
||||
|
||||
f.id = 21;
|
||||
BOOST_TEST(f.id == 21);
|
||||
|
||||
|
||||
boost::swap(f,g);
|
||||
BOOST_TEST(f.id == 7);
|
||||
BOOST_TEST(g.id == 21);
|
||||
|
||||
g = f;
|
||||
g = f;
|
||||
BOOST_TEST(g.id == 7);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -11,4 +11,4 @@ compile-fail libs/function/test/function_test_fail1.cpp
|
||||
compile-fail libs/function/test/function_test_fail2.cpp
|
||||
run libs/function/test/mixin_test.cpp
|
||||
run libs/function/test/policy_test.cpp
|
||||
run libs/function/test/stateless_test.cpp
|
||||
|
||||
|
||||
@@ -1,47 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
|
||||
//
|
||||
// Permission to copy, use, sell and distribute this software is granted
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <stdexcept>
|
||||
|
||||
struct stateless_integer_add {
|
||||
int operator()(int x, int y) const { return x+y; }
|
||||
|
||||
void* operator new(std::size_t, stateless_integer_add*)
|
||||
{
|
||||
throw std::runtime_error("Cannot allocate a stateless_integer_add");
|
||||
}
|
||||
|
||||
void operator delete(void*, stateless_integer_add*)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
namespace boost {
|
||||
template<>
|
||||
struct is_stateless<stateless_integer_add> {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
boost::function<int, int, int> f;
|
||||
f = stateless_integer_add();
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user