mirror of
https://github.com/boostorg/function.git
synced 2025-07-01 15:01:02 +02:00
Compare commits
3 Commits
boost-1.35
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| ca0591c8dc | |||
| b61864a392 | |||
| 8623578cc7 |
@ -1,8 +1,3 @@
|
||||
# Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
# 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)
|
||||
project boost/doc ;
|
||||
import boostbook : boostbook ;
|
||||
|
||||
|
||||
26
doc/faq.xml
26
doc/faq.xml
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
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)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section id="function.faq" last-revision="$Date$">
|
||||
@ -139,25 +132,6 @@ function objects with parameters that don't exactly match.</para>
|
||||
application a reference-counting allocator could be used.</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
|
||||
<qandaentry>
|
||||
<question><para>How much overhead does a call through <code><classname>boost::function</classname></code> incur?</para></question>
|
||||
<answer>
|
||||
<para>The cost of <code>boost::function</code> can be reasonably
|
||||
consistently measured at around 20ns +/- 10 ns on a modern >2GHz
|
||||
platform versus directly inlining the code.</para>
|
||||
|
||||
<para>However, the performance of your application may benefit
|
||||
from or be disadvantaged by <code>boost::function</code>
|
||||
depending on how your C++ optimiser optimises. Similar to a
|
||||
standard function pointer, differences of order of 10% have been
|
||||
noted to the benefit or disadvantage of using
|
||||
<code>boost::function</code> to call a function that contains a
|
||||
tight loop depending on your compilation circumstances.</para>
|
||||
|
||||
<para>[Answer provided by Matt Hurd. See <ulink url="http://article.gmane.org/gmane.comp.lib.boost.devel/33278"/>]</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
</qandaset>
|
||||
|
||||
</section>
|
||||
|
||||
@ -8,14 +8,13 @@
|
||||
<author>
|
||||
<firstname>Douglas</firstname>
|
||||
<surname>Gregor</surname>
|
||||
<email>dgregor -at- cs.indiana.edu</email>
|
||||
<email>gregod@cs.rpi.edu</email>
|
||||
</author>
|
||||
|
||||
<copyright>
|
||||
<year>2001</year>
|
||||
<year>2002</year>
|
||||
<year>2003</year>
|
||||
<year>2004</year>
|
||||
<holder>Douglas Gregor</holder>
|
||||
</copyright>
|
||||
|
||||
|
||||
@ -1,25 +1,11 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
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)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section id="function.history" last-revision="$Date$">
|
||||
<title>History & Compatibility Notes</title>
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
|
||||
<listitem><para><bold>Version 1.34.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Boost.Function now implements a small buffer optimization, which can drastically improve the performance when copying or construction Boost.Function objects storing small function objects. For instance, <code>bind(&X:foo, &x, _1, _2)</code> requires no heap allocation when placed into a Boost.Function object. Note that some exception-safety guarantees have changed: assignment provides the basic exception guarantee and <code>swap()</code> may throw.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.30.0</bold>: </para>
|
||||
<listitem><para><emphasis role="bold">Version 1.30.0</emphasis>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>All features deprecated in version 1.29.0 have
|
||||
been removed from Boost.Function.</para></listitem>
|
||||
@ -46,7 +32,7 @@
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.29.0</bold>:
|
||||
<listitem><para><emphasis role="bold">Version 1.29.0</emphasis>:
|
||||
Boost.Function has been partially redesigned to minimize the
|
||||
interface and make it cleaner. Several seldom- or never-used
|
||||
features of the older Boost.Function have been deprecated and will
|
||||
|
||||
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
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)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section id="function.misc" last-revision="$Date$">
|
||||
|
||||
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
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)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
|
||||
@ -86,49 +79,7 @@
|
||||
<method-group name="capacity">
|
||||
<method name="empty" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="target access">
|
||||
<overloaded-method name="target">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>Functor*</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>const Functor*</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>If <code>this</code> stores a target of type
|
||||
<code>Functor</code>, returns the address of the
|
||||
target. Otherwise, returns the NULL
|
||||
pointer.</simpara></returns>
|
||||
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="contains" cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const Functor&</paramtype>
|
||||
</parameter>
|
||||
<returns><simpara><code>true</code> if <code>this-><methodname>target</methodname><Functor>()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this->target<Functor>()), f)</code></simpara></returns>
|
||||
|
||||
</method>
|
||||
|
||||
<method name="target_type" cv="const">
|
||||
<type>const std::type_info&</type>
|
||||
<returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-><methodname>empty</methodname>()</code>.</simpara></returns>
|
||||
<returns><simpara><code>true</code> if <code>this</code> has a target, and <code>false</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
@ -195,7 +146,7 @@
|
||||
</struct>
|
||||
|
||||
<constructor>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
@ -214,10 +165,11 @@
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<destructor>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
|
||||
|
||||
</destructor>
|
||||
|
||||
@ -225,7 +177,8 @@
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>functionN</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
@ -233,18 +186,20 @@
|
||||
<type>void</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname>&</paramtype></parameter>
|
||||
<effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="clear">
|
||||
<type>void</type>
|
||||
<postconditions><simpara>this-><methodname>empty</methodname>()</simpara></postconditions>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="capacity">
|
||||
<method name="empty" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
|
||||
<returns><simpara><code>true</code> if <code>this</code> has a target, and <code>false</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
@ -261,49 +216,6 @@
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="target access">
|
||||
<overloaded-method name="target">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>Functor*</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>const Functor*</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>If <code>this</code> stores a target of type
|
||||
<code>Functor</code>, returns the address of the
|
||||
target. Otherwise, returns the NULL
|
||||
pointer.</simpara></returns>
|
||||
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="contains" cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const Functor&</paramtype>
|
||||
</parameter>
|
||||
<returns><simpara><code>true</code> if <code>this-><methodname>target</methodname><Functor>()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this->target<Functor>()), f)</code></simpara></returns>
|
||||
|
||||
</method>
|
||||
|
||||
<method name="target_type" cv="const">
|
||||
<type>const std::type_info&</type>
|
||||
<returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-><methodname>empty</methodname>()</code>.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
</method-group>
|
||||
|
||||
<method-group name="invocation">
|
||||
<method name="operator()" cv="const">
|
||||
<type>result_type</type>
|
||||
@ -313,7 +225,7 @@
|
||||
<parameter name="aN"><paramtype>argN_type</paramtype></parameter>
|
||||
<effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
|
||||
<returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
@ -330,211 +242,50 @@
|
||||
<parameter name="f1"><paramtype><classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</function>
|
||||
</free-function-group>
|
||||
|
||||
<free-function-group name="comparison operators">
|
||||
<overloaded-function name="operator==">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN, Allocator2>&</paramtype></parameter>
|
||||
</signature>
|
||||
<free-function-group name="undefined operators">
|
||||
<function name="operator==">
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN, Allocator2>&</paramtype></parameter>
|
||||
<notes><simpara>This function must be left undefined.</simpara></notes>
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>==</code>. This undefined <code>void operator ==</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
|
||||
</function>
|
||||
|
||||
<returns><simpara>True when <code>f</code> stores an object of
|
||||
type <code>Functor</code> and one of the following conditions applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() == g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and
|
||||
<code><functionname>function_equal</functionname>(*(f.target<Functor>()),
|
||||
g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>functionN</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>functionN</code>
|
||||
instances can be compared via <code>==</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator==</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
|
||||
<overloaded-function name="operator!=">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN, Allocator2>&</paramtype></parameter>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>True when <code>f</code> does not store an
|
||||
object of type <code>Functor</code> or it stores an object of
|
||||
type <code>Functor</code> and one of the following conditions
|
||||
applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() != g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>!<functionname>function_equal</functionname>(*(f.target<Functor>()), g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>functionN</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>functionN</code>
|
||||
instances can be compared via <code>!=</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator!=</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
<function name="operator!=">
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN, Allocator2>&</paramtype></parameter>
|
||||
<notes><simpara>This function must be left undefined.</simpara></notes>
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>!=</code>. This undefined <code>void operator !=</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
|
||||
</function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
|
||||
@ -604,7 +355,7 @@
|
||||
</struct>
|
||||
|
||||
<constructor>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
@ -631,26 +382,28 @@
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<destructor>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
|
||||
|
||||
</destructor>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
<paramtype>const <classname>functionN</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
|
||||
<throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></throws>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
@ -658,6 +411,7 @@
|
||||
<type>void</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname>&</paramtype></parameter>
|
||||
<effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="clear">
|
||||
@ -670,7 +424,7 @@
|
||||
<method-group name="capacity">
|
||||
<method name="empty" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
|
||||
<returns><simpara><code>true</code> if <code>this</code> has a target, and <code>false</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
@ -687,47 +441,6 @@
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="target access">
|
||||
<overloaded-method name="target">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>Functor*</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>const Functor*</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>If <code>this</code> stores a target of type
|
||||
<code>Functor</code>, returns the address of the
|
||||
target. Otherwise, returns the NULL
|
||||
pointer.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="contains" cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const Functor&</paramtype>
|
||||
</parameter>
|
||||
<returns><simpara><code>true</code> if <code>this-><methodname>target</methodname><Functor>()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this->target<Functor>()), f)</code></simpara></returns>
|
||||
|
||||
</method>
|
||||
|
||||
<method name="target_type" cv="const">
|
||||
<type>const std::type_info&</type>
|
||||
<returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-><methodname>empty</methodname>()</code>.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="invocation">
|
||||
<method name="operator()" cv="const">
|
||||
<type>result_type</type>
|
||||
@ -737,7 +450,7 @@
|
||||
<parameter name="aN"><paramtype>argN_type</paramtype></parameter>
|
||||
<effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
|
||||
<returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
@ -751,196 +464,40 @@
|
||||
<parameter name="f1"><paramtype><classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</function>
|
||||
</free-function-group>
|
||||
|
||||
<free-function-group name="comparison operators">
|
||||
<overloaded-function name="operator==">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2, Allocator2>&</paramtype></parameter>
|
||||
</signature>
|
||||
<free-function-group name="undefined operators">
|
||||
<function name="operator==">
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2, Allocator2>&</paramtype></parameter>
|
||||
<notes><simpara>This function must be left undefined.</simpara></notes>
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>==</code>. This undefined <code>void operator ==</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
|
||||
</function>
|
||||
|
||||
<returns><simpara>True when <code>f</code> stores an object of
|
||||
type <code>Functor</code> and one of the following conditions applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() == g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code><functionname>function_equals</functionname>(*(f.target<Functor>()), g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>function</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>function</code>
|
||||
instances can be compared via <code>==</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator==</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
|
||||
<overloaded-function name="operator!=">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2, Allocator2>&</paramtype></parameter>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>True when <code>f</code> does not store an
|
||||
object of type <code>Functor</code> or it stores an object of
|
||||
type <code>Functor</code> and one of the following conditions
|
||||
applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() != g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>!<functionname>function_equals</functionname>(*(f.target<Functor>()), g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>function</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>function</code>
|
||||
instances can be compared via <code>!=</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator!=</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
<function name="operator!=">
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2, Allocator2>&</paramtype></parameter>
|
||||
<notes><simpara>This function must be left undefined.</simpara></notes>
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>!=</code>. This undefined <code>void operator !=</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
|
||||
</function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
</namespace>
|
||||
</header>
|
||||
|
||||
<header name="boost/function_equal.hpp">
|
||||
<namespace name="boost">
|
||||
<function name="function_equal">
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
<template-type-parameter name="G"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const F&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="g">
|
||||
<paramtype>const G&</paramtype>
|
||||
</parameter>
|
||||
<purpose><simpara>Compare two function objects for equality.</simpara></purpose>
|
||||
<returns><simpara><code>f == g</code>.</simpara></returns>
|
||||
<throws><simpara>Only if <code>f == g</code> throws.</simpara></throws>
|
||||
</function>
|
||||
</namespace>
|
||||
</header>
|
||||
</library-reference>
|
||||
|
||||
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
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)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<testsuite id="function.testsuite" last-revision="$Date$">
|
||||
@ -33,12 +26,6 @@
|
||||
<if-fails><para>Either Boost.Lambda does not work on the platform, or Boost.Function cannot safely be applied without the use of <functionname>boost::unlambda</functionname>.</para></if-fails>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="contains_test.cpp">
|
||||
<purpose><para>Test the operation of the
|
||||
<code><methodname>target</methodname></code> member function and the
|
||||
equality operators.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<compile-fail-test filename="function_test_fail1.cpp">
|
||||
<purpose><para>Test the (incorrect!) use of comparisons between Boost.Function function objects.</para></purpose>
|
||||
<if-fails><para>Intuitive (but incorrect!) code may compile and will give meaningless results.</para></if-fails>
|
||||
|
||||
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
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)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section xmlns:xi="http://www.w3.org/2001/XInclude" id="function.tutorial"
|
||||
@ -255,17 +248,17 @@ f(&x, 5);</programlisting>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.std_bind.cxx98"> <classname>boost::function</classname><int (int)> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
</entry>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.std_bind.portable"> <classname alt="functionN">boost::function1</classname><int, int> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@ -281,7 +274,7 @@ f(5); // Call x.foo(5)</programlisting>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>References to Function Objects</title> <para> In some cases it is
|
||||
<title>References to Functions</title> <para> 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
|
||||
@ -300,18 +293,18 @@ f(5); // Call x.foo(5)</programlisting>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.ref.cxx98">stateful_type a_function_object;
|
||||
<classname>boost::function</classname><int (int)> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
<programlisting name="function.tutorial.ref.cxx98"> stateful_type a_function_object;
|
||||
<classname>boost::function</classname><int (int)> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
|
||||
<classname>boost::function</classname><int (int)> f2(f);</programlisting>
|
||||
<classname>boost::function</classname><int (int)> f2(f);</programlisting>
|
||||
</entry>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.ref.portable">stateful_type a_function_object;
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
<programlisting name="function.tutorial.ref.portable"> stateful_type a_function_object;
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f2(f);</programlisting>
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f2(f);</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@ -328,37 +321,5 @@ using references to function objects, Boost.Function will not throw
|
||||
exceptions during assignment or construction.
|
||||
</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Comparing Boost.Function function objects</title>
|
||||
|
||||
<para>Function object wrappers can be compared via <code>==</code>
|
||||
or <code>!=</code> against any function object that can be stored
|
||||
within the wrapper. If the function object wrapper contains a
|
||||
function object of that type, it will be compared against the given
|
||||
function object (which must be either be
|
||||
<conceptname>EqualityComparable</conceptname> or have an overloaded <functionname>boost::function_equal</functionname>). For instance:</para>
|
||||
|
||||
<programlisting name="function.tutorial.compare">int compute_with_X(X*, int);
|
||||
|
||||
f = &X::foo;
|
||||
assert(f == &X::foo);
|
||||
assert(&compute_with_X != f);</programlisting>
|
||||
|
||||
<para>When comparing against an instance of
|
||||
<code><classname>reference_wrapper</classname></code>, the address
|
||||
of the object in the
|
||||
<code><classname>reference_wrapper</classname></code> is compared
|
||||
against the address of the object stored by the function object
|
||||
wrapper:</para>
|
||||
|
||||
<programlisting name="function.tutorial.compare-ref">a_stateful_object so1, so2;
|
||||
f = <functionname>boost::ref</functionname>(so1);
|
||||
assert(f == <functionname>boost::ref</functionname>(so1));
|
||||
assert(f == so1); <emphasis>// Only if a_stateful_object is <conceptname>EqualityComparable</conceptname></emphasis>
|
||||
assert(f != <functionname>boost::ref</functionname>(so2));</programlisting>
|
||||
|
||||
</section>
|
||||
|
||||
</section>
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library examples
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library examples
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library examples
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -10,8 +10,6 @@
|
||||
// William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
|
||||
// design of this library.
|
||||
|
||||
#include <functional> // unary_function, binary_function
|
||||
|
||||
#include <boost/preprocessor/iterate.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
@ -24,7 +22,7 @@
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
// Visual Age C++ doesn't handle the file iteration well
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, <= 600)
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 0
|
||||
# include <boost/function/function0.hpp>
|
||||
# endif
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2003. Use, modification and
|
||||
// Copyright Doug Gregor 2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
#
|
||||
# Boost.Function library
|
||||
#
|
||||
# Copyright (C) 2001-2003 Douglas Gregor (gregod@cs.rpi.edu)
|
||||
# Copyright (C) 2001-2003 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.
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2003. Use, modification and
|
||||
// Copyright Doug Gregor 2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -11,7 +11,6 @@
|
||||
#define BOOST_FUNCTION_PROLOGUE_HPP
|
||||
# include <cassert>
|
||||
# include <algorithm>
|
||||
# include <functional> // unary_function, binary_function
|
||||
# include <boost/throw_exception.hpp>
|
||||
# include <boost/config.hpp>
|
||||
# include <boost/function/function_base.hpp>
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2006. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2004. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -14,46 +14,17 @@
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <new>
|
||||
#include <typeinfo>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/type_traits/is_integral.hpp>
|
||||
#include <boost/type_traits/arithmetic_traits.hpp>
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#include <boost/type_traits/is_stateless.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/pending/ct_if.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/type_traits/alignment_of.hpp>
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
# include "boost/utility/enable_if.hpp"
|
||||
#else
|
||||
# include "boost/mpl/bool.hpp"
|
||||
#endif
|
||||
#include <boost/function_equal.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( push )
|
||||
# pragma warning( disable : 4793 ) // complaint about native code generation
|
||||
# pragma warning( disable : 4127 ) // "conditional expression is constant"
|
||||
#endif
|
||||
|
||||
// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
|
||||
#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
|
||||
// Embedded VC++ does not have type_info in namespace std
|
||||
# define BOOST_FUNCTION_STD_NS
|
||||
#else
|
||||
# define BOOST_FUNCTION_STD_NS std
|
||||
#endif
|
||||
|
||||
// Borrowed from Boost.Python library: determines the cases where we
|
||||
// need to use std::type_info::name to compare instead of operator==.
|
||||
# if (defined(__GNUC__) && __GNUC__ >= 3) \
|
||||
|| defined(_AIX) \
|
||||
|| ( defined(__sgi) && defined(__host_mips))
|
||||
# include <cstring>
|
||||
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
|
||||
(std::strcmp((X).name(),(Y).name()) == 0)
|
||||
# else
|
||||
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
|
||||
@ -73,24 +44,10 @@ namespace boost { namespace python { namespace objects {
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|
||||
|| defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
|
||||
|| !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
|
||||
|| !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
|
||||
# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
|
||||
#endif
|
||||
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
|
||||
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
|
||||
typename ::boost::enable_if_c<(::boost::type_traits::ice_not< \
|
||||
(::boost::is_integral<Functor>::value)>::value), \
|
||||
Type>::type
|
||||
#else
|
||||
// BCC doesn't recognize this depends on a template argument and complains
|
||||
// about the use of 'typename'
|
||||
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
|
||||
::boost::enable_if_c<(::boost::type_traits::ice_not< \
|
||||
(::boost::is_integral<Functor>::value)>::value), \
|
||||
Type>::type
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
namespace boost {
|
||||
|
||||
@ -119,36 +76,42 @@ inline void swap(function<Signature, Allocator>& f1,
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
namespace function {
|
||||
class X;
|
||||
|
||||
/**
|
||||
* A buffer used to store small function objects in
|
||||
* boost::function. It is a union containing function pointers,
|
||||
* object pointers, and a structure that resembles a bound
|
||||
* member function pointer.
|
||||
*/
|
||||
union function_buffer
|
||||
* A union of a function pointer and a void pointer. This is necessary
|
||||
* because 5.2.10/6 allows reinterpret_cast<> to safely cast between
|
||||
* function pointer types and 5.2.9/10 allows static_cast<> to safely
|
||||
* cast between a void pointer and an object pointer. But it is not legal
|
||||
* to cast between a function pointer and a void* (in either direction),
|
||||
* so function requires a union of the two. */
|
||||
union any_pointer
|
||||
{
|
||||
// For pointers to function objects
|
||||
void* obj_ptr;
|
||||
|
||||
// For pointers to std::type_info objects
|
||||
// (get_functor_type_tag, check_functor_type_tag).
|
||||
const void* const_obj_ptr;
|
||||
|
||||
// For function pointers of all kinds
|
||||
mutable void (*func_ptr)();
|
||||
|
||||
// For bound member pointers
|
||||
struct bound_memfunc_ptr_t {
|
||||
void (X::*memfunc_ptr)(int);
|
||||
void* obj_ptr;
|
||||
} bound_memfunc_ptr;
|
||||
|
||||
// To relax aliasing constraints
|
||||
mutable char data;
|
||||
void (*func_ptr)();
|
||||
char data[1];
|
||||
};
|
||||
|
||||
inline any_pointer make_any_pointer(void* o)
|
||||
{
|
||||
any_pointer p;
|
||||
p.obj_ptr = o;
|
||||
return p;
|
||||
}
|
||||
|
||||
inline any_pointer make_any_pointer(const void* o)
|
||||
{
|
||||
any_pointer p;
|
||||
p.const_obj_ptr = o;
|
||||
return p;
|
||||
}
|
||||
|
||||
inline any_pointer make_any_pointer(void (*f)())
|
||||
{
|
||||
any_pointer p;
|
||||
p.func_ptr = f;
|
||||
return p;
|
||||
}
|
||||
|
||||
/**
|
||||
* The unusable class is a placeholder for unused function arguments
|
||||
* It is also completely unusable except that it constructable from
|
||||
@ -176,9 +139,7 @@ namespace boost {
|
||||
// The operation type to perform on the given functor/function pointer
|
||||
enum functor_manager_operation_type {
|
||||
clone_functor_tag,
|
||||
destroy_functor_tag,
|
||||
check_functor_type_tag,
|
||||
get_functor_type_tag
|
||||
destroy_functor_tag
|
||||
};
|
||||
|
||||
// Tags used to decide between different types of functions
|
||||
@ -186,78 +147,39 @@ namespace boost {
|
||||
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 mpl::if_c<(is_pointer<F>::value),
|
||||
function_ptr_tag,
|
||||
function_obj_tag>::type ptr_or_obj_tag;
|
||||
typedef typename ct_if<(is_pointer<F>::value),
|
||||
function_ptr_tag,
|
||||
function_obj_tag>::type ptr_or_obj_tag;
|
||||
|
||||
typedef typename mpl::if_c<(is_member_pointer<F>::value),
|
||||
member_ptr_tag,
|
||||
ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
|
||||
typedef typename ct_if<(is_member_pointer<F>::value),
|
||||
member_ptr_tag,
|
||||
ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
|
||||
|
||||
typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
|
||||
function_obj_ref_tag,
|
||||
ptr_or_obj_or_mem_tag>::type or_ref_tag;
|
||||
typedef typename ct_if<(is_reference_wrapper<F>::value),
|
||||
function_obj_ref_tag,
|
||||
ptr_or_obj_or_mem_tag>::type or_ref_tag;
|
||||
|
||||
public:
|
||||
typedef or_ref_tag type;
|
||||
typedef typename ct_if<(is_stateless<F>::value),
|
||||
stateless_function_obj_tag,
|
||||
or_ref_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).
|
||||
template<typename F>
|
||||
struct reference_manager
|
||||
inline any_pointer trivial_manager(any_pointer f,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
static inline void
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
switch (op) {
|
||||
case clone_functor_tag:
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
return;
|
||||
|
||||
case destroy_functor_tag:
|
||||
out_buffer.obj_ptr = 0;
|
||||
return;
|
||||
|
||||
case check_functor_type_tag:
|
||||
{
|
||||
// DPG TBD: Since we're only storing a pointer, it's
|
||||
// possible that the user could ask for a base class or
|
||||
// derived class. Is that okay?
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
return;
|
||||
|
||||
case get_functor_type_tag:
|
||||
out_buffer.const_obj_ptr = &typeid(F);
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Determine if boost::function can use the small-object
|
||||
* optimization with the function object type F.
|
||||
*/
|
||||
template<typename F>
|
||||
struct function_allows_small_object_optimization
|
||||
{
|
||||
BOOST_STATIC_CONSTANT
|
||||
(bool,
|
||||
value = ((sizeof(F) <= sizeof(function_buffer) &&
|
||||
(alignment_of<function_buffer>::value
|
||||
% alignment_of<F>::value == 0))));
|
||||
};
|
||||
if (op == clone_functor_tag)
|
||||
return f;
|
||||
else
|
||||
return make_any_pointer(reinterpret_cast<void*>(0));
|
||||
}
|
||||
|
||||
/**
|
||||
* The functor_manager class contains a static function "manage" which
|
||||
@ -270,57 +192,30 @@ namespace boost {
|
||||
typedef Functor functor_type;
|
||||
|
||||
// For function pointers, the manager is trivial
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_ptr_tag)
|
||||
static inline any_pointer
|
||||
manager(any_pointer function_ptr,
|
||||
functor_manager_operation_type op,
|
||||
function_ptr_tag)
|
||||
{
|
||||
if (op == clone_functor_tag)
|
||||
out_buffer.func_ptr = in_buffer.func_ptr;
|
||||
else if (op == destroy_functor_tag)
|
||||
out_buffer.func_ptr = 0;
|
||||
else /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = &in_buffer.func_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
return function_ptr;
|
||||
else
|
||||
return make_any_pointer(static_cast<void (*)()>(0));
|
||||
}
|
||||
|
||||
// Function objects that fit in the small-object buffer.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, mpl::true_)
|
||||
{
|
||||
if (op == clone_functor_tag) {
|
||||
const functor_type* in_functor =
|
||||
reinterpret_cast<const functor_type*>(&in_buffer.data);
|
||||
new ((void*)&out_buffer.data) functor_type(*in_functor);
|
||||
} else if (op == destroy_functor_tag) {
|
||||
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
|
||||
reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
|
||||
} else /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = &in_buffer.data;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Function objects that require heap allocation
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, mpl::false_)
|
||||
// For function object pointers, we clone the pointer to each
|
||||
// function has its own version.
|
||||
static inline any_pointer
|
||||
manager(any_pointer function_obj_ptr,
|
||||
functor_manager_operation_type op,
|
||||
function_obj_tag)
|
||||
{
|
||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
||||
typedef typename Allocator::template rebind<functor_type>::other
|
||||
allocator_type;
|
||||
typedef typename allocator_type::pointer pointer_type;
|
||||
typedef typename Allocator::template rebind<functor_type>::other
|
||||
allocator_type;
|
||||
typedef typename allocator_type::pointer pointer_type;
|
||||
#else
|
||||
typedef functor_type* pointer_type;
|
||||
typedef functor_type* pointer_type;
|
||||
#endif // BOOST_NO_STD_ALLOCATOR
|
||||
|
||||
# ifndef BOOST_NO_STD_ALLOCATOR
|
||||
@ -328,10 +223,8 @@ namespace boost {
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
|
||||
if (op == clone_functor_tag) {
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
const functor_type* f =
|
||||
(const functor_type*)(in_buffer.obj_ptr);
|
||||
functor_type* f =
|
||||
static_cast<functor_type*>(function_obj_ptr.obj_ptr);
|
||||
|
||||
// Clone the functor
|
||||
# ifndef BOOST_NO_STD_ALLOCATOR
|
||||
@ -343,11 +236,12 @@ namespace boost {
|
||||
# else
|
||||
functor_type* new_f = new functor_type(*f);
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
out_buffer.obj_ptr = new_f;
|
||||
} else if (op == destroy_functor_tag) {
|
||||
return make_any_pointer(static_cast<void*>(new_f));
|
||||
}
|
||||
else {
|
||||
/* Cast from the void pointer to the functor pointer type */
|
||||
functor_type* f =
|
||||
static_cast<functor_type*>(out_buffer.obj_ptr);
|
||||
reinterpret_cast<functor_type*>(function_obj_ptr.obj_ptr);
|
||||
|
||||
# ifndef BOOST_NO_STD_ALLOCATOR
|
||||
/* Cast from the functor pointer type to the allocator's pointer
|
||||
@ -360,129 +254,23 @@ namespace boost {
|
||||
# else
|
||||
delete f;
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
|
||||
return make_any_pointer(static_cast<void*>(0));
|
||||
}
|
||||
}
|
||||
|
||||
// For function objects, we determine whether the function
|
||||
// object can use the small-object optimization buffer or
|
||||
// whether we need to allocate it on the heap.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_obj_tag)
|
||||
{
|
||||
manager(in_buffer, out_buffer, op,
|
||||
mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
|
||||
}
|
||||
|
||||
// For member pointers, we treat them as function objects with
|
||||
// the small-object optimization always enabled.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, member_ptr_tag)
|
||||
{
|
||||
manager(in_buffer, out_buffer, op, mpl::true_());
|
||||
}
|
||||
|
||||
public:
|
||||
/* Dispatch to an appropriate manager based on whether we have a
|
||||
function pointer or a function object pointer. */
|
||||
static inline void
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
static any_pointer
|
||||
manage(any_pointer functor_ptr, functor_manager_operation_type op)
|
||||
{
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
switch (op) {
|
||||
case get_functor_type_tag:
|
||||
out_buffer.const_obj_ptr = &typeid(functor_type);
|
||||
return;
|
||||
|
||||
default:
|
||||
manager(in_buffer, out_buffer, op, tag_type());
|
||||
return;
|
||||
}
|
||||
return manager(functor_ptr, op, tag_type());
|
||||
}
|
||||
};
|
||||
|
||||
// A type that is only used for comparisons against zero
|
||||
struct useless_clear_type {};
|
||||
|
||||
#ifdef BOOST_NO_SFINAE
|
||||
// These routines perform comparisons between a Boost.Function
|
||||
// object and an arbitrary function object (when the last
|
||||
// parameter is mpl::bool_<false>) or against zero (when the
|
||||
// last parameter is mpl::bool_<true>). They are only necessary
|
||||
// for compilers that don't support SFINAE.
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
|
||||
{ return f.empty(); }
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_not_equal(const Function& f, const Functor&, int,
|
||||
mpl::bool_<true>)
|
||||
{ return !f.empty(); }
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_equal(const Function& f, const Functor& g, long,
|
||||
mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return function_equal(*fp, g);
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_equal(const Function& f, const reference_wrapper<Functor>& g,
|
||||
int, mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp == g.get_pointer();
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_not_equal(const Function& f, const Functor& g, long,
|
||||
mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return !function_equal(*fp, g);
|
||||
else return true;
|
||||
}
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_not_equal(const Function& f,
|
||||
const reference_wrapper<Functor>& g, int,
|
||||
mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp != g.get_pointer();
|
||||
else return true;
|
||||
}
|
||||
#endif // BOOST_NO_SFINAE
|
||||
|
||||
/**
|
||||
* Stores the "manager" portion of the vtable for a
|
||||
* boost::function object.
|
||||
*/
|
||||
struct vtable_base
|
||||
{
|
||||
void (*manager)(const function_buffer& in_buffer,
|
||||
function_buffer& out_buffer,
|
||||
functor_manager_operation_type op);
|
||||
};
|
||||
} // end namespace function
|
||||
} // end namespace detail
|
||||
|
||||
@ -495,93 +283,19 @@ namespace boost {
|
||||
class function_base
|
||||
{
|
||||
public:
|
||||
function_base() : vtable(0) { }
|
||||
|
||||
/** Determine if the function is empty (i.e., has no target). */
|
||||
bool empty() const { return !vtable; }
|
||||
|
||||
/** Retrieve the type of the stored function object, or typeid(void)
|
||||
if this is empty. */
|
||||
const BOOST_FUNCTION_STD_NS::type_info& target_type() const
|
||||
function_base() : manager(0)
|
||||
{
|
||||
if (!vtable) return typeid(void);
|
||||
|
||||
detail::function::function_buffer type;
|
||||
vtable->manager(functor, type, detail::function::get_functor_type_tag);
|
||||
return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
|
||||
functor.obj_ptr = 0;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
Functor* target()
|
||||
{
|
||||
if (!vtable) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.const_obj_ptr = &typeid(Functor);
|
||||
vtable->manager(functor, type_result,
|
||||
detail::function::check_functor_type_tag);
|
||||
return static_cast<Functor*>(type_result.obj_ptr);
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
const Functor* target( Functor * = 0 ) const
|
||||
#else
|
||||
const Functor* target() const
|
||||
#endif
|
||||
{
|
||||
if (!vtable) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.const_obj_ptr = &typeid(Functor);
|
||||
vtable->manager(functor, type_result,
|
||||
detail::function::check_functor_type_tag);
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
return (const Functor*)(type_result.obj_ptr);
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
bool contains(const F& f) const
|
||||
{
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
if (const F* fp = this->target( (F*)0 ))
|
||||
#else
|
||||
if (const F* fp = this->template target<F>())
|
||||
#endif
|
||||
{
|
||||
return function_equal(*fp, f);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
|
||||
// GCC 3.3 and newer cannot copy with the global operator==, due to
|
||||
// problems with instantiation of function return types before it
|
||||
// has been verified that the argument types match up.
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(Functor g) const
|
||||
{
|
||||
if (const Functor* fp = target<Functor>())
|
||||
return function_equal(*fp, g);
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(Functor g) const
|
||||
{
|
||||
if (const Functor* fp = target<Functor>())
|
||||
return !function_equal(*fp, g);
|
||||
else return true;
|
||||
}
|
||||
#endif
|
||||
// Is this function empty?
|
||||
bool empty() const { return !manager; }
|
||||
|
||||
public: // should be protected, but GCC 2.95.3 will fail to allow access
|
||||
const detail::function::vtable_base* vtable;
|
||||
mutable detail::function::function_buffer functor;
|
||||
detail::function::any_pointer (*manager)(
|
||||
detail::function::any_pointer,
|
||||
detail::function::functor_manager_operation_type);
|
||||
detail::function::any_pointer functor;
|
||||
};
|
||||
|
||||
/**
|
||||
@ -594,7 +308,16 @@ public:
|
||||
bad_function_call() : std::runtime_error("call to empty boost::function") {}
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
/* Poison comparison between Boost.Function objects (because it is
|
||||
* meaningless). The comparisons would otherwise be allowed because of the
|
||||
* conversion required to allow syntax such as:
|
||||
* boost::function<int, int> f;
|
||||
* if (f) { f(5); }
|
||||
*/
|
||||
void operator==(const function_base&, const function_base&);
|
||||
void operator!=(const function_base&, const function_base&);
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
|
||||
inline bool operator==(const function_base& f,
|
||||
detail::function::useless_clear_type*)
|
||||
{
|
||||
@ -620,116 +343,6 @@ inline bool operator!=(detail::function::useless_clear_type*,
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NO_SFINAE
|
||||
// Comparisons between boost::function objects and arbitrary function objects
|
||||
template<typename Functor>
|
||||
inline bool operator==(const function_base& f, Functor g)
|
||||
{
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_equal(f, g, 0, integral());
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
inline bool operator==(Functor g, const function_base& f)
|
||||
{
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_equal(f, g, 0, integral());
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
inline bool operator!=(const function_base& f, Functor g)
|
||||
{
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_not_equal(f, g, 0, integral());
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
inline bool operator!=(Functor g, const function_base& f)
|
||||
{
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_not_equal(f, g, 0, integral());
|
||||
}
|
||||
#else
|
||||
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
// Comparisons between boost::function objects and arbitrary function
|
||||
// objects. GCC 3.3 and before has an obnoxious bug that prevents this
|
||||
// from working.
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(const function_base& f, Functor g)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return function_equal(*fp, g);
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(Functor g, const function_base& f)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return function_equal(g, *fp);
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(const function_base& f, Functor g)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return !function_equal(*fp, g);
|
||||
else return true;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(Functor g, const function_base& f)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return !function_equal(g, *fp);
|
||||
else return true;
|
||||
}
|
||||
# endif
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(const function_base& f, reference_wrapper<Functor> g)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp == g.get_pointer();
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(reference_wrapper<Functor> g, const function_base& f)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return g.get_pointer() == fp;
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(const function_base& f, reference_wrapper<Functor> g)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp != g.get_pointer();
|
||||
else return true;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(reference_wrapper<Functor> g, const function_base& f)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return g.get_pointer() != fp;
|
||||
else return true;
|
||||
}
|
||||
|
||||
#endif // Compiler supporting SFINAE
|
||||
|
||||
namespace detail {
|
||||
namespace function {
|
||||
inline bool has_empty_target(const function_base* f)
|
||||
@ -752,11 +365,4 @@ namespace detail {
|
||||
} // end namespace detail
|
||||
} // end namespace boost
|
||||
|
||||
#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
|
||||
#undef BOOST_FUNCTION_COMPARE_TYPE_ID
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( pop )
|
||||
#endif
|
||||
|
||||
#endif // BOOST_FUNCTION_BASE_HEADER
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2006. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -11,11 +11,6 @@
|
||||
// protection.
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( push )
|
||||
# pragma warning( disable : 4127 ) // "conditional expression is constant"
|
||||
#endif
|
||||
|
||||
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
|
||||
|
||||
#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
|
||||
@ -27,7 +22,7 @@
|
||||
#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
|
||||
|
||||
#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
|
||||
typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
|
||||
typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(arg, BOOST_PP_CAT(BOOST_PP_INC(I),_type));
|
||||
|
||||
#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
|
||||
|
||||
@ -55,33 +50,16 @@
|
||||
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_FUNCTION_REF_INVOKER \
|
||||
BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
|
||||
BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_MEMBER_INVOKER \
|
||||
BOOST_JOIN(member_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
|
||||
BOOST_JOIN(void_member_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_FUNCTION_REF_INVOKER \
|
||||
BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
|
||||
BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_INVOKER \
|
||||
BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
|
||||
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
# define BOOST_FUNCTION_VOID_RETURN_TYPE void
|
||||
# define BOOST_FUNCTION_RETURN(X) X
|
||||
#else
|
||||
# define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable
|
||||
# define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
|
||||
#endif
|
||||
#define BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(get_stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
@ -93,7 +71,7 @@ namespace boost {
|
||||
>
|
||||
struct BOOST_FUNCTION_FUNCTION_INVOKER
|
||||
{
|
||||
static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
|
||||
static R invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
{
|
||||
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
|
||||
@ -108,13 +86,13 @@ namespace boost {
|
||||
>
|
||||
struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
|
||||
{
|
||||
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
static unusable invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
|
||||
BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
|
||||
f(BOOST_FUNCTION_ARGS);
|
||||
return unusable();
|
||||
}
|
||||
};
|
||||
|
||||
@ -125,15 +103,11 @@ namespace boost {
|
||||
>
|
||||
struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
static R invoke(any_pointer function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f;
|
||||
if (function_allows_small_object_optimization<FunctionObj>::value)
|
||||
f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
|
||||
else
|
||||
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
|
||||
return (*f)(BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
};
|
||||
@ -145,17 +119,14 @@ namespace boost {
|
||||
>
|
||||
struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
static unusable invoke(any_pointer function_obj_ptr
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f;
|
||||
if (function_allows_small_object_optimization<FunctionObj>::value)
|
||||
f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
|
||||
else
|
||||
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
|
||||
FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
|
||||
(*f)(BOOST_FUNCTION_ARGS);
|
||||
return unusable();
|
||||
}
|
||||
};
|
||||
|
||||
@ -164,15 +135,12 @@ namespace boost {
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
|
||||
struct BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
static R invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)
|
||||
{
|
||||
FunctionObj* f =
|
||||
reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
return (*f)(BOOST_FUNCTION_ARGS);
|
||||
FunctionObj f = FunctionObj();
|
||||
return f(BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
@ -181,57 +149,18 @@ namespace boost {
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
|
||||
struct BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
static unusable invoke(any_pointer BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f =
|
||||
reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
|
||||
FunctionObj f = FunctionObj();
|
||||
f(BOOST_FUNCTION_ARGS);
|
||||
return unusable();
|
||||
}
|
||||
};
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||
/* Handle invocation of member pointers. */
|
||||
template<
|
||||
typename MemberPtr,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_MEMBER_INVOKER
|
||||
{
|
||||
static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
MemberPtr* f =
|
||||
reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
|
||||
return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename MemberPtr,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
|
||||
{
|
||||
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
MemberPtr* f =
|
||||
reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
|
||||
BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
template<
|
||||
typename FunctionPtr,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
@ -239,7 +168,7 @@ namespace boost {
|
||||
>
|
||||
struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
|
||||
{
|
||||
typedef typename mpl::if_c<(is_void<R>::value),
|
||||
typedef typename ct_if<(is_void<R>::value),
|
||||
BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
|
||||
FunctionPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
@ -260,7 +189,7 @@ namespace boost {
|
||||
>
|
||||
struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
typedef typename mpl::if_c<(is_void<R>::value),
|
||||
typedef typename ct_if<(is_void<R>::value),
|
||||
BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
@ -279,15 +208,15 @@ namespace boost {
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
|
||||
struct BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
typedef typename mpl::if_c<(is_void<R>::value),
|
||||
BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
|
||||
typedef typename ct_if<(is_void<R>::value),
|
||||
BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>,
|
||||
BOOST_FUNCTION_FUNCTION_REF_INVOKER<
|
||||
BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
@ -295,258 +224,6 @@ namespace boost {
|
||||
>::type type;
|
||||
};
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||
/* Retrieve the appropriate invoker for a member pointer. */
|
||||
template<
|
||||
typename MemberPtr,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_GET_MEMBER_INVOKER
|
||||
{
|
||||
typedef typename mpl::if_c<(is_void<R>::value),
|
||||
BOOST_FUNCTION_VOID_MEMBER_INVOKER<
|
||||
MemberPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>,
|
||||
BOOST_FUNCTION_MEMBER_INVOKER<
|
||||
MemberPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>
|
||||
>::type type;
|
||||
};
|
||||
#endif
|
||||
|
||||
/* Given the tag returned by get_function_tag, retrieve the
|
||||
actual invoker that will be used for the given function
|
||||
object.
|
||||
|
||||
Each specialization contains an "apply" nested class template
|
||||
that accepts the function object, return type, function
|
||||
argument types, and allocator. The resulting "apply" class
|
||||
contains two typedefs, "invoker_type" and "manager_type",
|
||||
which correspond to the invoker and manager types. */
|
||||
template<typename Tag>
|
||||
struct BOOST_FUNCTION_GET_INVOKER { };
|
||||
|
||||
/* Retrieve the invoker for a function pointer. */
|
||||
template<>
|
||||
struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
|
||||
{
|
||||
template<typename FunctionPtr,
|
||||
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
struct apply
|
||||
{
|
||||
typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
|
||||
FunctionPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
|
||||
typedef functor_manager<FunctionPtr, Allocator> manager_type;
|
||||
};
|
||||
};
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||
/* Retrieve the invoker for a member pointer. */
|
||||
template<>
|
||||
struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
|
||||
{
|
||||
template<typename MemberPtr,
|
||||
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
struct apply
|
||||
{
|
||||
typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
|
||||
MemberPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
|
||||
typedef functor_manager<MemberPtr, Allocator> manager_type;
|
||||
};
|
||||
};
|
||||
#endif
|
||||
|
||||
/* Retrieve the invoker for a function object. */
|
||||
template<>
|
||||
struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
|
||||
{
|
||||
template<typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
struct apply
|
||||
{
|
||||
typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
|
||||
typedef functor_manager<FunctionObj, Allocator> manager_type;
|
||||
};
|
||||
};
|
||||
|
||||
/* Retrieve the invoker for a reference to a function object. */
|
||||
template<>
|
||||
struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
|
||||
{
|
||||
template<typename RefWrapper,
|
||||
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
struct apply
|
||||
{
|
||||
typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
|
||||
typename RefWrapper::type,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
|
||||
typedef reference_manager<typename RefWrapper::type> manager_type;
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* vtable for a specific boost::function instance.
|
||||
*/
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
struct BOOST_FUNCTION_VTABLE
|
||||
{
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
typedef R result_type;
|
||||
#else
|
||||
typedef typename function_return_type<R>::type result_type;
|
||||
#endif // BOOST_NO_VOID_RETURNS
|
||||
|
||||
typedef result_type (*invoker_type)(function_buffer&
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS);
|
||||
|
||||
template<typename F>
|
||||
bool assign_to(const F& f, function_buffer& functor) const
|
||||
{
|
||||
typedef typename get_function_tag<F>::type tag;
|
||||
return assign_to(f, functor, tag());
|
||||
}
|
||||
|
||||
void clear(function_buffer& functor) const
|
||||
{
|
||||
if (base.manager)
|
||||
base.manager(functor, functor, destroy_functor_tag);
|
||||
}
|
||||
#ifndef BOOST_NO_PRIVATE_IN_AGGREGATE
|
||||
private:
|
||||
#endif
|
||||
// Function pointers
|
||||
template<typename FunctionPtr>
|
||||
bool
|
||||
assign_to(FunctionPtr f, function_buffer& functor,
|
||||
function_ptr_tag) const
|
||||
{
|
||||
this->clear(functor);
|
||||
if (f) {
|
||||
// should be a reinterpret cast, but some compilers insist
|
||||
// on giving cv-qualifiers to free functions
|
||||
functor.func_ptr = (void (*)())(f);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Member pointers
|
||||
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||
template<typename MemberPtr>
|
||||
bool
|
||||
assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
|
||||
{
|
||||
if (f) {
|
||||
// Always use the small-object optimization for member
|
||||
// pointers.
|
||||
assign_functor(f, functor, mpl::true_());
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
#endif // BOOST_FUNCTION_NUM_ARGS > 0
|
||||
|
||||
// Function objects
|
||||
// Assign to a function object using the small object optimization
|
||||
template<typename FunctionObj>
|
||||
void
|
||||
assign_functor(const FunctionObj& f, function_buffer& functor,
|
||||
mpl::true_) const
|
||||
{
|
||||
new ((void*)&functor.data) FunctionObj(f);
|
||||
}
|
||||
|
||||
// Assign to a function object allocated on the heap.
|
||||
template<typename FunctionObj>
|
||||
void
|
||||
assign_functor(const FunctionObj& f, function_buffer& functor,
|
||||
mpl::false_) const
|
||||
{
|
||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
||||
typedef typename Allocator::template rebind<FunctionObj>::other
|
||||
allocator_type;
|
||||
typedef typename allocator_type::pointer pointer_type;
|
||||
|
||||
allocator_type allocator;
|
||||
pointer_type copy = allocator.allocate(1);
|
||||
allocator.construct(copy, f);
|
||||
|
||||
// Get back to the original pointer type
|
||||
functor.obj_ptr = static_cast<FunctionObj*>(copy);
|
||||
# else
|
||||
functor.obj_ptr = new FunctionObj(f);
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
}
|
||||
|
||||
template<typename FunctionObj>
|
||||
bool
|
||||
assign_to(const FunctionObj& f, function_buffer& functor,
|
||||
function_obj_tag) const
|
||||
{
|
||||
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
|
||||
assign_functor(f, functor,
|
||||
mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Reference to a function object
|
||||
template<typename FunctionObj>
|
||||
bool
|
||||
assign_to(const reference_wrapper<FunctionObj>& f,
|
||||
function_buffer& functor, function_obj_ref_tag) const
|
||||
{
|
||||
if (!boost::detail::function::has_empty_target(f.get_pointer())) {
|
||||
// DPG TBD: We might need to detect constness of
|
||||
// FunctionObj to assign into obj_ptr or const_obj_ptr to
|
||||
// be truly legit, but no platform in existence makes
|
||||
// const void* different from void*.
|
||||
functor.const_obj_ptr = f.get_pointer();
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
vtable_base base;
|
||||
invoker_type invoker;
|
||||
};
|
||||
} // end namespace function
|
||||
} // end namespace detail
|
||||
|
||||
@ -556,31 +233,12 @@ namespace boost {
|
||||
typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
|
||||
>
|
||||
class BOOST_FUNCTION_FUNCTION : public function_base
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS == 1
|
||||
|
||||
, public std::unary_function<T0,R>
|
||||
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 2
|
||||
|
||||
, public std::binary_function<T0,T1,R>
|
||||
|
||||
#endif
|
||||
|
||||
{
|
||||
public:
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
typedef R result_type;
|
||||
#else
|
||||
typedef typename boost::detail::function::function_return_type<R>::type
|
||||
result_type;
|
||||
#endif // BOOST_NO_VOID_RETURNS
|
||||
typedef typename detail::function::function_return_type<R>::type
|
||||
internal_result_type;
|
||||
|
||||
private:
|
||||
typedef boost::detail::function::BOOST_FUNCTION_VTABLE<
|
||||
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
|
||||
vtable_type;
|
||||
|
||||
struct clear_type {};
|
||||
|
||||
public:
|
||||
@ -590,7 +248,7 @@ namespace boost {
|
||||
template<typename Args>
|
||||
struct sig
|
||||
{
|
||||
typedef result_type type;
|
||||
typedef internal_result_type type;
|
||||
};
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS == 1
|
||||
@ -603,10 +261,16 @@ namespace boost {
|
||||
BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
|
||||
BOOST_FUNCTION_ARG_TYPES
|
||||
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
typedef R result_type;
|
||||
#else
|
||||
typedef internal_result_type result_type;
|
||||
#endif // BOOST_NO_VOID_RETURNS
|
||||
typedef Allocator allocator_type;
|
||||
typedef BOOST_FUNCTION_FUNCTION self_type;
|
||||
|
||||
BOOST_FUNCTION_FUNCTION() : function_base() { }
|
||||
BOOST_FUNCTION_FUNCTION() : function_base()
|
||||
, invoker(0) {}
|
||||
|
||||
// MSVC chokes if the following two constructors are collapsed into
|
||||
// one with a default parameter.
|
||||
@ -614,46 +278,50 @@ namespace boost {
|
||||
BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
,typename enable_if_c<
|
||||
(boost::type_traits::ice_not<
|
||||
(::boost::type_traits::ice_not<
|
||||
(is_integral<Functor>::value)>::value),
|
||||
int>::type = 0
|
||||
#endif // BOOST_NO_SFINAE
|
||||
) :
|
||||
function_base()
|
||||
function_base(),
|
||||
invoker(0)
|
||||
{
|
||||
this->assign_to(f);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
|
||||
BOOST_FUNCTION_FUNCTION(clear_type*) : function_base(), invoker(0) {}
|
||||
#else
|
||||
BOOST_FUNCTION_FUNCTION(int zero) : function_base()
|
||||
BOOST_FUNCTION_FUNCTION(int zero) : function_base(), invoker(0)
|
||||
{
|
||||
BOOST_ASSERT(zero == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()
|
||||
BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) :
|
||||
function_base(),
|
||||
invoker(0)
|
||||
{
|
||||
this->assign_to_own(f);
|
||||
}
|
||||
|
||||
~BOOST_FUNCTION_FUNCTION() { clear(); }
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
// MSVC 6.0 and prior require all definitions to be inline, but
|
||||
// these definitions can become very costly.
|
||||
result_type operator()(BOOST_FUNCTION_PARMS) const
|
||||
{
|
||||
if (this->empty())
|
||||
boost::throw_exception(bad_function_call());
|
||||
|
||||
return reinterpret_cast<const vtable_type*>(vtable)->invoker
|
||||
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
internal_result_type result = invoker(this->functor
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_ARGS);
|
||||
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
return static_cast<result_type>(result);
|
||||
#else
|
||||
result_type operator()(BOOST_FUNCTION_PARMS) const;
|
||||
#endif
|
||||
return result;
|
||||
#endif // BOOST_NO_VOID_RETURNS
|
||||
}
|
||||
|
||||
// The distinction between when to use BOOST_FUNCTION_FUNCTION and
|
||||
// when to use self_type is obnoxious. MSVC cannot handle self_type as
|
||||
@ -663,7 +331,7 @@ namespace boost {
|
||||
template<typename Functor>
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
typename enable_if_c<
|
||||
(boost::type_traits::ice_not<
|
||||
(::boost::type_traits::ice_not<
|
||||
(is_integral<Functor>::value)>::value),
|
||||
BOOST_FUNCTION_FUNCTION&>::type
|
||||
#else
|
||||
@ -671,17 +339,7 @@ namespace boost {
|
||||
#endif
|
||||
operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
|
||||
{
|
||||
this->clear();
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
try {
|
||||
this->assign_to(f);
|
||||
} catch (...) {
|
||||
vtable = 0;
|
||||
throw;
|
||||
}
|
||||
#else
|
||||
this->assign_to(f);
|
||||
#endif
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -706,17 +364,7 @@ namespace boost {
|
||||
if (&f == this)
|
||||
return *this;
|
||||
|
||||
this->clear();
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
try {
|
||||
this->assign_to_own(f);
|
||||
} catch (...) {
|
||||
vtable = 0;
|
||||
throw;
|
||||
}
|
||||
#else
|
||||
this->assign_to_own(f);
|
||||
#endif
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -725,18 +373,21 @@ namespace boost {
|
||||
if (&other == this)
|
||||
return;
|
||||
|
||||
BOOST_FUNCTION_FUNCTION tmp = *this;
|
||||
*this = other;
|
||||
other = tmp;
|
||||
std::swap(this->manager, other.manager);
|
||||
std::swap(this->functor, other.functor);
|
||||
std::swap(invoker, other.invoker);
|
||||
}
|
||||
|
||||
// Clear out a target, if there is one
|
||||
void clear()
|
||||
{
|
||||
if (vtable) {
|
||||
reinterpret_cast<const vtable_type*>(vtable)->clear(this->functor);
|
||||
vtable = 0;
|
||||
if (this->manager) {
|
||||
function_base::functor =
|
||||
this->manager(this->functor, detail::function::destroy_functor_tag);
|
||||
}
|
||||
|
||||
this->manager = 0;
|
||||
invoker = 0;
|
||||
}
|
||||
|
||||
#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
|
||||
@ -762,33 +413,131 @@ namespace boost {
|
||||
void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
|
||||
{
|
||||
if (!f.empty()) {
|
||||
this->vtable = f.vtable;
|
||||
f.vtable->manager(f.functor, this->functor,
|
||||
boost::detail::function::clone_functor_tag);
|
||||
invoker = f.invoker;
|
||||
this->manager = f.manager;
|
||||
this->functor =
|
||||
f.manager(f.functor, detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
void assign_to(const Functor& f)
|
||||
void assign_to(Functor f)
|
||||
{
|
||||
using detail::function::vtable_base;
|
||||
|
||||
typedef typename detail::function::get_function_tag<Functor>::type tag;
|
||||
typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
|
||||
typedef typename get_invoker::
|
||||
template apply<Functor, R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
|
||||
handler_type;
|
||||
|
||||
typedef typename handler_type::invoker_type invoker_type;
|
||||
typedef typename handler_type::manager_type manager_type;
|
||||
|
||||
static const vtable_type stored_vtable =
|
||||
{ { &manager_type::manage }, &invoker_type::invoke };
|
||||
|
||||
if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base;
|
||||
else vtable = 0;
|
||||
this->assign_to(f, tag());
|
||||
}
|
||||
|
||||
template<typename FunctionPtr>
|
||||
void assign_to(FunctionPtr f, detail::function::function_ptr_tag)
|
||||
{
|
||||
clear();
|
||||
|
||||
if (f) {
|
||||
typedef typename detail::function::BOOST_FUNCTION_GET_FUNCTION_INVOKER<
|
||||
FunctionPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
invoker_type;
|
||||
|
||||
invoker = &invoker_type::invoke;
|
||||
this->manager =
|
||||
&detail::function::functor_manager<FunctionPtr, Allocator>::manage;
|
||||
this->functor =
|
||||
this->manager(detail::function::make_any_pointer(
|
||||
// should be a reinterpret cast, but some compilers
|
||||
// insist on giving cv-qualifiers to free functions
|
||||
(void (*)())(f)
|
||||
),
|
||||
detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||
template<typename MemberPtr>
|
||||
void assign_to(MemberPtr f, detail::function::member_ptr_tag)
|
||||
{
|
||||
this->assign_to(mem_fn(f));
|
||||
}
|
||||
#endif // BOOST_FUNCTION_NUM_ARGS > 0
|
||||
|
||||
template<typename FunctionObj>
|
||||
void assign_to(FunctionObj f, detail::function::function_obj_tag)
|
||||
{
|
||||
if (!detail::function::has_empty_target(addressof(f))) {
|
||||
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;
|
||||
this->manager = &detail::function::functor_manager<
|
||||
FunctionObj, Allocator>::manage;
|
||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
||||
typedef typename Allocator::template rebind<FunctionObj>::other
|
||||
allocator_type;
|
||||
typedef typename allocator_type::pointer pointer_type;
|
||||
allocator_type allocator;
|
||||
pointer_type copy = allocator.allocate(1);
|
||||
allocator.construct(copy, f);
|
||||
|
||||
// Get back to the original pointer type
|
||||
FunctionObj* new_f = static_cast<FunctionObj*>(copy);
|
||||
#else
|
||||
FunctionObj* new_f = new FunctionObj(f);
|
||||
#endif // BOOST_NO_STD_ALLOCATOR
|
||||
this->functor =
|
||||
detail::function::make_any_pointer(static_cast<void*>(new_f));
|
||||
}
|
||||
}
|
||||
|
||||
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_pointer())) {
|
||||
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;
|
||||
this->manager = &detail::function::trivial_manager;
|
||||
this->functor =
|
||||
this->manager(
|
||||
detail::function::make_any_pointer(
|
||||
const_cast<FunctionObj*>(f.get_pointer())),
|
||||
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;
|
||||
this->manager = &detail::function::trivial_manager;
|
||||
this->functor = detail::function::make_any_pointer(this);
|
||||
}
|
||||
|
||||
typedef internal_result_type (*invoker_type)(detail::function::any_pointer
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS);
|
||||
|
||||
invoker_type invoker;
|
||||
};
|
||||
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
||||
@ -807,47 +556,6 @@ namespace boost {
|
||||
f1.swap(f2);
|
||||
}
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
typename BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
|
||||
Allocator>::result_type
|
||||
BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
|
||||
|
||||
Allocator>
|
||||
::operator()(BOOST_FUNCTION_PARMS) const
|
||||
{
|
||||
if (this->empty())
|
||||
boost::throw_exception(bad_function_call());
|
||||
|
||||
return reinterpret_cast<const vtable_type*>(vtable)->invoker
|
||||
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Poison comparisons between boost::function objects of the same type.
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
||||
typename Allocator>
|
||||
void operator==(const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
||||
Allocator>&,
|
||||
const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
||||
Allocator>&);
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
||||
typename Allocator>
|
||||
void operator!=(const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
||||
Allocator>&,
|
||||
const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
||||
Allocator>&);
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS == 0
|
||||
@ -878,7 +586,7 @@ public:
|
||||
function(Functor f
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
,typename enable_if_c<
|
||||
(boost::type_traits::ice_not<
|
||||
(::boost::type_traits::ice_not<
|
||||
(is_integral<Functor>::value)>::value),
|
||||
int>::type = 0
|
||||
#endif
|
||||
@ -904,7 +612,7 @@ public:
|
||||
template<typename Functor>
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
typename enable_if_c<
|
||||
(boost::type_traits::ice_not<
|
||||
(::boost::type_traits::ice_not<
|
||||
(is_integral<Functor>::value)>::value),
|
||||
self_type&>::type
|
||||
#else
|
||||
@ -937,8 +645,6 @@ public:
|
||||
} // end namespace boost
|
||||
|
||||
// Cleanup after ourselves...
|
||||
#undef BOOST_FUNCTION_VTABLE
|
||||
#undef BOOST_FUNCTION_GET_INVOKER
|
||||
#undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
|
||||
#undef BOOST_FUNCTION_COMMA
|
||||
#undef BOOST_FUNCTION_FUNCTION
|
||||
@ -946,14 +652,12 @@ public:
|
||||
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
|
||||
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
|
||||
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
|
||||
#undef BOOST_FUNCTION_MEMBER_INVOKER
|
||||
#undef BOOST_FUNCTION_VOID_MEMBER_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_FUNCTION_REF_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_MEMBER_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
|
||||
#undef BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
#undef BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
#undef BOOST_FUNCTION_PARMS
|
||||
@ -961,9 +665,3 @@ public:
|
||||
#undef BOOST_FUNCTION_ARGS
|
||||
#undef BOOST_FUNCTION_ARG_TYPE
|
||||
#undef BOOST_FUNCTION_ARG_TYPES
|
||||
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
#undef BOOST_FUNCTION_RETURN
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( pop )
|
||||
#endif
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
#
|
||||
# Boost.Function library
|
||||
#
|
||||
# Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
# Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
# distribution is 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)
|
||||
|
||||
@ -1,28 +0,0 @@
|
||||
// Copyright Douglas Gregor 2004.
|
||||
// Copyright 2005 Peter Dimov
|
||||
|
||||
// Use, modification and distribution is 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)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
#ifndef BOOST_FUNCTION_EQUAL_HPP
|
||||
#define BOOST_FUNCTION_EQUAL_HPP
|
||||
|
||||
namespace boost {
|
||||
|
||||
template<typename F, typename G>
|
||||
bool function_equal_impl(const F& f, const G& g, long)
|
||||
{ return f == g; }
|
||||
|
||||
// function_equal_impl needs to be unqualified to pick
|
||||
// user overloads on two-phase compilers
|
||||
|
||||
template<typename F, typename G>
|
||||
bool function_equal(const F& f, const G& g)
|
||||
{ return function_equal_impl(f, g, 0); }
|
||||
|
||||
} // end namespace boost
|
||||
|
||||
#endif // BOOST_FUNCTION_EQUAL_HPP
|
||||
15
index.html
15
index.html
@ -1,20 +1,9 @@
|
||||
<html>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
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)
|
||||
-->
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/function.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/function.html">../../doc/html/function.html</a> <hr>
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
||||
<a href="../../doc/html/function.html">../../doc/html/function.html</a>
|
||||
</body>
|
||||
</html>
|
||||
</html>
|
||||
|
||||
65
test/Jamfile
Normal file
65
test/Jamfile
Normal file
@ -0,0 +1,65 @@
|
||||
# Function library
|
||||
|
||||
# Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
# Use, modification and distribution is 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)
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
# Testing Jamfile autogenerated from XML source
|
||||
subproject libs/function/test ;
|
||||
|
||||
# bring in rules for testing
|
||||
SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
|
||||
include testing.jam ;
|
||||
|
||||
# Make tests run by default.
|
||||
DEPENDS all : test ;
|
||||
|
||||
{
|
||||
# look in BOOST_ROOT for sources first, just in this Jamfile
|
||||
local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
|
||||
|
||||
test-suite function
|
||||
:
|
||||
[ run libs/function/test/function_test.cpp : : : : lib_function_test ]
|
||||
|
||||
[ run libs/function/test/function_n_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/allocator_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/stateless_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/lambda_test.cpp : : : : ]
|
||||
|
||||
[ compile-fail libs/function/test/function_test_fail1.cpp : : : : ]
|
||||
|
||||
[ compile-fail libs/function/test/function_test_fail2.cpp : : : : ]
|
||||
|
||||
[ compile libs/function/test/function_30.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_arith_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_arith_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/sum_avg_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/sum_avg_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/mem_fun_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/mem_fun_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/std_bind_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/std_bind_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_portable.cpp : : : : ]
|
||||
;
|
||||
}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Function library
|
||||
|
||||
# Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
# Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
# distribution is 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)
|
||||
@ -53,11 +53,6 @@ import testing ;
|
||||
[ run libs/function/test/function_ref_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains2_test.cpp : : : : ]
|
||||
|
||||
;
|
||||
}
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -41,20 +41,11 @@ struct counting_allocator : public std::allocator<T>
|
||||
}
|
||||
};
|
||||
|
||||
struct plus_int
|
||||
{
|
||||
int operator()(int x, int y) const { return x + y; }
|
||||
|
||||
int unused_state_data[32];
|
||||
};
|
||||
|
||||
static int do_minus(int x, int y) { return x-y; }
|
||||
|
||||
struct DoNothing
|
||||
{
|
||||
void operator()() const {}
|
||||
|
||||
int unused_state_data[32];
|
||||
};
|
||||
|
||||
static void do_nothing() {}
|
||||
@ -63,32 +54,28 @@ int
|
||||
test_main(int, char*[])
|
||||
{
|
||||
function2<int, int, int, counting_allocator<int> > f;
|
||||
f = plus_int();
|
||||
f = plus<int>();
|
||||
f.clear();
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f = &do_minus;
|
||||
f.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
|
||||
function0<void, counting_allocator<int> > fv;
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = DoNothing();
|
||||
fv.clear();
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = &do_nothing;
|
||||
fv.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,88 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2004.
|
||||
// Copyright 2005 Peter Dimov
|
||||
|
||||
// Use, modification and distribution is 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/function.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
static int forty_two()
|
||||
{
|
||||
return 42;
|
||||
}
|
||||
|
||||
struct Seventeen
|
||||
{
|
||||
int operator()() const
|
||||
{
|
||||
return 17;
|
||||
}
|
||||
};
|
||||
|
||||
bool operator==(const Seventeen&, const Seventeen&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
struct ReturnInt
|
||||
{
|
||||
explicit ReturnInt(int value) : value(value)
|
||||
{
|
||||
}
|
||||
|
||||
int operator()() const
|
||||
{
|
||||
return value;
|
||||
}
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
bool operator==(const ReturnInt& x, const ReturnInt& y)
|
||||
{
|
||||
return x.value == y.value;
|
||||
}
|
||||
|
||||
bool operator!=(const ReturnInt& x, const ReturnInt& y)
|
||||
{
|
||||
return x.value != y.value;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function0<int> fn;
|
||||
|
||||
fn = &forty_two;
|
||||
|
||||
BOOST_TEST( fn() == 42 );
|
||||
|
||||
BOOST_TEST( fn.contains(&forty_two) );
|
||||
BOOST_TEST( !fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(12) ) );
|
||||
|
||||
fn = Seventeen();
|
||||
|
||||
BOOST_TEST( fn() == 17 );
|
||||
|
||||
BOOST_TEST( !fn.contains( &forty_two ) );
|
||||
BOOST_TEST( fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(12) ) );
|
||||
|
||||
fn = ReturnInt(12);
|
||||
|
||||
BOOST_TEST( fn() == 12 );
|
||||
|
||||
BOOST_TEST( !fn.contains( &forty_two ) );
|
||||
BOOST_TEST( !fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( fn.contains( ReturnInt(12) ) );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,226 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2004. Use, modification and
|
||||
// distribution is 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/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
static int forty_two() { return 42; }
|
||||
|
||||
struct Seventeen
|
||||
{
|
||||
int operator()() const { return 17; }
|
||||
};
|
||||
|
||||
struct ReturnInt
|
||||
{
|
||||
explicit ReturnInt(int value) : value(value) {}
|
||||
|
||||
int operator()() const { return value; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
bool operator==(const ReturnInt& x, const ReturnInt& y)
|
||||
{ return x.value == y.value; }
|
||||
|
||||
bool operator!=(const ReturnInt& x, const ReturnInt& y)
|
||||
{ return x.value != y.value; }
|
||||
|
||||
namespace contain_test {
|
||||
|
||||
struct ReturnIntFE
|
||||
{
|
||||
explicit ReturnIntFE(int value) : value(value) {}
|
||||
|
||||
int operator()() const { return value; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
|
||||
namespace contain_test {
|
||||
# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
|
||||
{ return x.value == y.value; }
|
||||
# else
|
||||
bool function_equal_impl(const ReturnIntFE& x, const ReturnIntFE& y, int)
|
||||
{ return x.value == y.value; }
|
||||
# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
}
|
||||
#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
namespace boost {
|
||||
# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
bool
|
||||
function_equal(const contain_test::ReturnIntFE& x,
|
||||
const contain_test::ReturnIntFE& y)
|
||||
{ return x.value == y.value; }
|
||||
# else
|
||||
bool
|
||||
function_equal_impl(const contain_test::ReturnIntFE& x,
|
||||
const contain_test::ReturnIntFE& y, int)
|
||||
{ return x.value == y.value; }
|
||||
# endif
|
||||
}
|
||||
#endif
|
||||
|
||||
static void target_test()
|
||||
{
|
||||
boost::function0<int> f;
|
||||
|
||||
f = &forty_two;
|
||||
BOOST_CHECK(*f.target<int (*)()>() == &forty_two);
|
||||
BOOST_CHECK(!f.target<Seventeen>());
|
||||
|
||||
f = Seventeen();
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<Seventeen>());
|
||||
|
||||
Seventeen this_seventeen;
|
||||
f = boost::ref(this_seventeen);
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<Seventeen>());
|
||||
BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
|
||||
}
|
||||
|
||||
static void equal_test()
|
||||
{
|
||||
boost::function0<int> f;
|
||||
|
||||
f = &forty_two;
|
||||
BOOST_CHECK(f == &forty_two);
|
||||
BOOST_CHECK(f != ReturnInt(17));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two == f);
|
||||
BOOST_CHECK(ReturnInt(17) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(&forty_two));
|
||||
|
||||
f = ReturnInt(17);
|
||||
BOOST_CHECK(f != &forty_two);
|
||||
BOOST_CHECK(f == ReturnInt(17));
|
||||
BOOST_CHECK(f != ReturnInt(16));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two != f);
|
||||
BOOST_CHECK(ReturnInt(17) == f);
|
||||
BOOST_CHECK(ReturnInt(16) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(ReturnInt(17)));
|
||||
|
||||
f = contain_test::ReturnIntFE(17);
|
||||
BOOST_CHECK(f != &forty_two);
|
||||
BOOST_CHECK(f == contain_test::ReturnIntFE(17));
|
||||
BOOST_CHECK(f != contain_test::ReturnIntFE(16));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two != f);
|
||||
BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
|
||||
BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
boost::function<int(void)> g;
|
||||
|
||||
g = &forty_two;
|
||||
BOOST_CHECK(g == &forty_two);
|
||||
BOOST_CHECK(g != ReturnInt(17));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two == g);
|
||||
BOOST_CHECK(ReturnInt(17) != g);
|
||||
# endif
|
||||
|
||||
g = ReturnInt(17);
|
||||
BOOST_CHECK(g != &forty_two);
|
||||
BOOST_CHECK(g == ReturnInt(17));
|
||||
BOOST_CHECK(g != ReturnInt(16));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two != g);
|
||||
BOOST_CHECK(ReturnInt(17) == g);
|
||||
BOOST_CHECK(ReturnInt(16) != g);
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
static void ref_equal_test()
|
||||
{
|
||||
{
|
||||
ReturnInt ri(17);
|
||||
boost::function0<int> f = boost::ref(ri);
|
||||
|
||||
// References and values are equal
|
||||
BOOST_CHECK(f == boost::ref(ri));
|
||||
BOOST_CHECK(f == ri);
|
||||
BOOST_CHECK(boost::ref(ri) == f);
|
||||
BOOST_CHECK(!(f != boost::ref(ri)));
|
||||
BOOST_CHECK(!(f != ri));
|
||||
BOOST_CHECK(!(boost::ref(ri) != f));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri == f);
|
||||
BOOST_CHECK(!(ri != f));
|
||||
#endif
|
||||
|
||||
// Values equal, references inequal
|
||||
ReturnInt ri2(17);
|
||||
BOOST_CHECK(f == ri2);
|
||||
BOOST_CHECK(f != boost::ref(ri2));
|
||||
BOOST_CHECK(boost::ref(ri2) != f);
|
||||
BOOST_CHECK(!(f != ri2));
|
||||
BOOST_CHECK(!(f == boost::ref(ri2)));
|
||||
BOOST_CHECK(!(boost::ref(ri2) == f));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri2 == f);
|
||||
BOOST_CHECK(!(ri2 != f));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
{
|
||||
ReturnInt ri(17);
|
||||
boost::function<int(void)> f = boost::ref(ri);
|
||||
|
||||
// References and values are equal
|
||||
BOOST_CHECK(f == boost::ref(ri));
|
||||
BOOST_CHECK(f == ri);
|
||||
BOOST_CHECK(boost::ref(ri) == f);
|
||||
BOOST_CHECK(!(f != boost::ref(ri)));
|
||||
BOOST_CHECK(!(f != ri));
|
||||
BOOST_CHECK(!(boost::ref(ri) != f));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri == f);
|
||||
BOOST_CHECK(!(ri != f));
|
||||
# endif
|
||||
|
||||
// Values equal, references inequal
|
||||
ReturnInt ri2(17);
|
||||
BOOST_CHECK(f == ri2);
|
||||
BOOST_CHECK(f != boost::ref(ri2));
|
||||
BOOST_CHECK(boost::ref(ri2) != f);
|
||||
BOOST_CHECK(!(f != ri2));
|
||||
BOOST_CHECK(!(f == boost::ref(ri2)));
|
||||
BOOST_CHECK(!(boost::ref(ri2) == f));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri2 == f);
|
||||
BOOST_CHECK(!(ri2 != f));
|
||||
# endif
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
target_test();
|
||||
equal_test();
|
||||
ref_equal_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -56,30 +56,30 @@ test_zero_args()
|
||||
|
||||
// Default construction
|
||||
func_void_type v1;
|
||||
BOOST_CHECK(v1.empty());
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v1.clear();
|
||||
BOOST_CHECK(!v1);
|
||||
BOOST_TEST(!v1);
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = v1;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v1 = five;
|
||||
@ -88,61 +88,61 @@ test_zero_args()
|
||||
global_int = 0;
|
||||
v1 = (v1);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear
|
||||
v1 = 0;
|
||||
BOOST_CHECK(v1.empty());
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = &write_five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = &write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Construction from another function (that is empty)
|
||||
v1.clear();
|
||||
func_void_type v2(v1);
|
||||
BOOST_CHECK(!v2? true : false);
|
||||
BOOST_TEST(!v2? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v2 = three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v2 = (five);
|
||||
@ -150,86 +150,86 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
v2.clear();
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v2 = (&write_five);
|
||||
BOOST_CHECK(v2? true : false);
|
||||
BOOST_TEST(v2? true : false);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Swapping
|
||||
v1 = five;
|
||||
swap(v1, v2);
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
swap(v1, v2);
|
||||
v1.clear();
|
||||
|
||||
// Assignment
|
||||
v2 = five;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a function from an empty function
|
||||
v2 = v1;
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to a function from a function with a functor
|
||||
v1 = three;
|
||||
v2 = v1;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assign to a function from a function with a function
|
||||
v2 = &write_five;
|
||||
v1 = v2;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construct a function given another function containing a function
|
||||
func_void_type v3(v1);
|
||||
@ -237,20 +237,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v3.clear();
|
||||
BOOST_CHECK(!v3? true : false);
|
||||
BOOST_TEST(!v3? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v3 = three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v3 = five;
|
||||
@ -258,38 +258,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v3.clear();
|
||||
BOOST_CHECK(v3.empty());
|
||||
BOOST_TEST(v3.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v3 = &write_five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v3 = &write_three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v3 = five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function containing a functor
|
||||
func_void_type v4(v3);
|
||||
@ -297,20 +297,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v4 = three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v4 = five;
|
||||
@ -318,38 +318,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v4 = &write_five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v4 = &write_three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v4 = five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a functor
|
||||
func_void_type v5(five);
|
||||
@ -357,20 +357,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v5 = three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v5 = five;
|
||||
@ -378,38 +378,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v5 = &write_five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v5 = &write_three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v5 = five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function
|
||||
func_void_type v6(&write_five);
|
||||
@ -417,20 +417,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v6 = three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v6 = five;
|
||||
@ -438,38 +438,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v6 = &write_five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v6 = &write_three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v6 = five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Const vs. non-const
|
||||
// Initialization for Borland C++ 5.5
|
||||
@ -479,19 +479,19 @@ test_zero_args()
|
||||
|
||||
global_int = 0;
|
||||
v7();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
global_int = 0;
|
||||
v8();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
// Test construction from 0 and comparison to 0
|
||||
func_void_type v9(0);
|
||||
BOOST_CHECK(v9 == 0);
|
||||
BOOST_TEST(v9 == 0);
|
||||
# if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540 || defined(BOOST_STRICT_CONFIG)
|
||||
BOOST_CHECK(0 == v9);
|
||||
BOOST_TEST(0 == v9);
|
||||
#else
|
||||
BOOST_CHECK(v9.empty());
|
||||
BOOST_TEST(v9.empty());
|
||||
#endif
|
||||
|
||||
// Test return values
|
||||
@ -501,31 +501,31 @@ test_zero_args()
|
||||
generate_three_obj gen_three = generate_three_obj();
|
||||
func_int_type i0(gen_five);
|
||||
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = gen_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_TEST(i0() == 3);
|
||||
i0 = &generate_five;
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = &generate_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_CHECK(i0? true : false);
|
||||
BOOST_TEST(i0() == 3);
|
||||
BOOST_TEST(i0? true : false);
|
||||
i0.clear();
|
||||
BOOST_CHECK(!i0? true : false);
|
||||
BOOST_TEST(!i0? true : false);
|
||||
|
||||
// Test return values with compatible types
|
||||
typedef function0<long> func_long_type;
|
||||
func_long_type i1(gen_five);
|
||||
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = gen_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_TEST(i1() == 3);
|
||||
i1 = &generate_five;
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = &generate_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_CHECK(i1? true : false);
|
||||
BOOST_TEST(i1() == 3);
|
||||
BOOST_TEST(i1? true : false);
|
||||
i1.clear();
|
||||
BOOST_CHECK(!i1? true : false);
|
||||
BOOST_TEST(!i1? true : false);
|
||||
}
|
||||
|
||||
static void
|
||||
@ -534,45 +534,45 @@ test_one_arg()
|
||||
negate<int> neg = negate<int>(); // Initialization for Borland C++ 5.5
|
||||
|
||||
function1<int, int> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
BOOST_TEST(f1(5) == -5);
|
||||
|
||||
function1<string, string> id(&identity_str);
|
||||
BOOST_CHECK(id("str") == "str");
|
||||
BOOST_TEST(id("str") == "str");
|
||||
|
||||
function1<std::string, const char*> id2(&identity_str);
|
||||
BOOST_CHECK(id2("foo") == "foo");
|
||||
BOOST_TEST(id2("foo") == "foo");
|
||||
|
||||
add_to_obj add_to(5);
|
||||
function1<int, int> f2(add_to);
|
||||
BOOST_CHECK(f2(3) == 8);
|
||||
BOOST_TEST(f2(3) == 8);
|
||||
|
||||
const function1<int, int> cf2(add_to);
|
||||
BOOST_CHECK(cf2(3) == 8);
|
||||
BOOST_TEST(cf2(3) == 8);
|
||||
}
|
||||
|
||||
static void
|
||||
test_two_args()
|
||||
{
|
||||
function2<string, const string&, const string&> cat(&string_cat);
|
||||
BOOST_CHECK(cat("str", "ing") == "string");
|
||||
BOOST_TEST(cat("str", "ing") == "string");
|
||||
|
||||
function2<int, short, short> sum(&sum_ints);
|
||||
BOOST_CHECK(sum(2, 3) == 5);
|
||||
BOOST_TEST(sum(2, 3) == 5);
|
||||
}
|
||||
|
||||
static void
|
||||
test_emptiness()
|
||||
{
|
||||
function0<float> f1;
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_TEST(f1.empty());
|
||||
|
||||
function0<float> f2;
|
||||
f2 = f1;
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_TEST(f2.empty());
|
||||
|
||||
function0<double> f3;
|
||||
f3 = f2;
|
||||
BOOST_CHECK(f3.empty());
|
||||
BOOST_TEST(f3.empty());
|
||||
}
|
||||
|
||||
struct X {
|
||||
@ -593,18 +593,18 @@ test_member_functions()
|
||||
X one(1);
|
||||
X five(5);
|
||||
|
||||
BOOST_CHECK(f1(&one) == 2);
|
||||
BOOST_CHECK(f1(&five) == 10);
|
||||
BOOST_TEST(f1(&one) == 2);
|
||||
BOOST_TEST(f1(&five) == 10);
|
||||
|
||||
boost::function1<int, X*> f1_2;
|
||||
f1_2 = &X::twice;
|
||||
|
||||
BOOST_CHECK(f1_2(&one) == 2);
|
||||
BOOST_CHECK(f1_2(&five) == 10);
|
||||
BOOST_TEST(f1_2(&one) == 2);
|
||||
BOOST_TEST(f1_2(&five) == 10);
|
||||
|
||||
boost::function2<int, X&, int> f2(&X::plus);
|
||||
BOOST_CHECK(f2(one, 3) == 4);
|
||||
BOOST_CHECK(f2(five, 4) == 9);
|
||||
BOOST_TEST(f2(one, 3) == 4);
|
||||
BOOST_TEST(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
@ -629,7 +629,7 @@ test_ref()
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function2<int, int, int> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
BOOST_TEST(f(1, 3) == 4);
|
||||
}
|
||||
catch(std::runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -10,6 +10,7 @@
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <functional>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
@ -55,30 +56,30 @@ test_zero_args()
|
||||
|
||||
// Default construction
|
||||
func_void_type v1;
|
||||
BOOST_CHECK(v1.empty());
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = five;
|
||||
BOOST_CHECK(v1 != 0);
|
||||
BOOST_TEST(v1 != 0);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v1.clear();
|
||||
BOOST_CHECK(v1 == 0);
|
||||
BOOST_TEST(v1 == 0);
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = v1;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v1 = five;
|
||||
@ -87,61 +88,61 @@ test_zero_args()
|
||||
global_int = 0;
|
||||
v1 = (v1);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear
|
||||
v1 = 0;
|
||||
BOOST_CHECK(0 == v1);
|
||||
BOOST_TEST(0 == v1);
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
BOOST_CHECK(0 != v1);
|
||||
BOOST_TEST(0 != v1);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = &write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Construction from another function (that is empty)
|
||||
v1.clear();
|
||||
func_void_type v2(v1);
|
||||
BOOST_CHECK(!v2? true : false);
|
||||
BOOST_TEST(!v2? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v2 = three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v2 = (five);
|
||||
@ -149,86 +150,86 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
v2.clear();
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
|
||||
BOOST_CHECK(v2? true : false);
|
||||
BOOST_TEST(v2? true : false);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Swapping
|
||||
v1 = five;
|
||||
swap(v1, v2);
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
swap(v1, v2);
|
||||
v1.clear();
|
||||
|
||||
// Assignment
|
||||
v2 = five;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a function from an empty function
|
||||
v2 = v1;
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to a function from a function with a functor
|
||||
v1 = three;
|
||||
v2 = v1;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assign to a function from a function with a function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
v1 = v2;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construct a function given another function containing a function
|
||||
func_void_type v3(v1);
|
||||
@ -236,20 +237,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v3.clear();
|
||||
BOOST_CHECK(!v3? true : false);
|
||||
BOOST_TEST(!v3? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v3 = three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v3 = five;
|
||||
@ -257,38 +258,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v3.clear();
|
||||
BOOST_CHECK(v3.empty());
|
||||
BOOST_TEST(v3.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v3 = &write_five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v3 = &write_three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v3 = five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function containing a functor
|
||||
func_void_type v4(v3);
|
||||
@ -296,20 +297,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v4 = three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v4 = five;
|
||||
@ -317,38 +318,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v4 = &write_five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v4 = &write_three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v4 = five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a functor
|
||||
func_void_type v5(five);
|
||||
@ -356,20 +357,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v5 = three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v5 = five;
|
||||
@ -377,38 +378,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v5 = &write_five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v5 = &write_three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v5 = five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function
|
||||
func_void_type v6(&write_five);
|
||||
@ -416,20 +417,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v6 = three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v6 = five;
|
||||
@ -437,38 +438,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v6 = &write_five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v6 = &write_three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v6 = five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Const vs. non-const
|
||||
write_const_1_nonconst_2 one_or_two;
|
||||
@ -477,16 +478,16 @@ test_zero_args()
|
||||
|
||||
global_int = 0;
|
||||
v7();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
global_int = 0;
|
||||
v8();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
// Test construction from 0 and comparison to 0
|
||||
func_void_type v9(0);
|
||||
BOOST_CHECK(v9 == 0);
|
||||
BOOST_CHECK(0 == v9);
|
||||
BOOST_TEST(v9 == 0);
|
||||
BOOST_TEST(0 == v9);
|
||||
|
||||
// Test return values
|
||||
typedef function<int ()> func_int_type;
|
||||
@ -495,31 +496,31 @@ test_zero_args()
|
||||
|
||||
func_int_type i0(gen_five);
|
||||
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = gen_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_TEST(i0() == 3);
|
||||
i0 = &generate_five;
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = &generate_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_CHECK(i0? true : false);
|
||||
BOOST_TEST(i0() == 3);
|
||||
BOOST_TEST(i0? true : false);
|
||||
i0.clear();
|
||||
BOOST_CHECK(!i0? true : false);
|
||||
BOOST_TEST(!i0? true : false);
|
||||
|
||||
// Test return values with compatible types
|
||||
typedef function<long ()> func_long_type;
|
||||
func_long_type i1(gen_five);
|
||||
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = gen_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_TEST(i1() == 3);
|
||||
i1 = &generate_five;
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = &generate_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_CHECK(i1? true : false);
|
||||
BOOST_TEST(i1() == 3);
|
||||
BOOST_TEST(i1? true : false);
|
||||
i1.clear();
|
||||
BOOST_CHECK(!i1? true : false);
|
||||
BOOST_TEST(!i1? true : false);
|
||||
}
|
||||
|
||||
static void
|
||||
@ -528,45 +529,45 @@ test_one_arg()
|
||||
negate<int> neg;
|
||||
|
||||
function<int (int)> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
BOOST_TEST(f1(5) == -5);
|
||||
|
||||
function<string (string)> id(&identity_str);
|
||||
BOOST_CHECK(id("str") == "str");
|
||||
BOOST_TEST(id("str") == "str");
|
||||
|
||||
function<string (const char*)> id2(&identity_str);
|
||||
BOOST_CHECK(id2("foo") == "foo");
|
||||
BOOST_TEST(id2("foo") == "foo");
|
||||
|
||||
add_to_obj add_to(5);
|
||||
function<int (int)> f2(add_to);
|
||||
BOOST_CHECK(f2(3) == 8);
|
||||
BOOST_TEST(f2(3) == 8);
|
||||
|
||||
const function<int (int)> cf2(add_to);
|
||||
BOOST_CHECK(cf2(3) == 8);
|
||||
BOOST_TEST(cf2(3) == 8);
|
||||
}
|
||||
|
||||
static void
|
||||
test_two_args()
|
||||
{
|
||||
function<string (const string&, const string&)> cat(&string_cat);
|
||||
BOOST_CHECK(cat("str", "ing") == "string");
|
||||
BOOST_TEST(cat("str", "ing") == "string");
|
||||
|
||||
function<int (short, short)> sum(&sum_ints);
|
||||
BOOST_CHECK(sum(2, 3) == 5);
|
||||
BOOST_TEST(sum(2, 3) == 5);
|
||||
}
|
||||
|
||||
static void
|
||||
test_emptiness()
|
||||
{
|
||||
function<float ()> f1;
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_TEST(f1.empty());
|
||||
|
||||
function<float ()> f2;
|
||||
f2 = f1;
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_TEST(f2.empty());
|
||||
|
||||
function<double ()> f3;
|
||||
f3 = f2;
|
||||
BOOST_CHECK(f3.empty());
|
||||
BOOST_TEST(f3.empty());
|
||||
}
|
||||
|
||||
struct X {
|
||||
@ -586,18 +587,18 @@ test_member_functions()
|
||||
X one(1);
|
||||
X five(5);
|
||||
|
||||
BOOST_CHECK(f1(&one) == 2);
|
||||
BOOST_CHECK(f1(&five) == 10);
|
||||
BOOST_TEST(f1(&one) == 2);
|
||||
BOOST_TEST(f1(&five) == 10);
|
||||
|
||||
boost::function<int (X*)> f1_2;
|
||||
f1_2 = &X::twice;
|
||||
|
||||
BOOST_CHECK(f1_2(&one) == 2);
|
||||
BOOST_CHECK(f1_2(&five) == 10);
|
||||
BOOST_TEST(f1_2(&one) == 2);
|
||||
BOOST_TEST(f1_2(&five) == 10);
|
||||
|
||||
boost::function<int (X&, int)> f2(&X::plus);
|
||||
BOOST_CHECK(f2(one, 3) == 4);
|
||||
BOOST_CHECK(f2(five, 4) == 9);
|
||||
BOOST_TEST(f2(one, 3) == 4);
|
||||
BOOST_TEST(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
@ -622,19 +623,83 @@ test_ref()
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function<int (int, int)> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
BOOST_TEST(f(1, 3) == 4);
|
||||
}
|
||||
catch(runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
static int alloc_count = 0;
|
||||
static int dealloc_count = 0;
|
||||
|
||||
template<typename T>
|
||||
struct counting_allocator : public allocator<T>
|
||||
{
|
||||
template<typename U>
|
||||
struct rebind
|
||||
{
|
||||
typedef counting_allocator<U> other;
|
||||
};
|
||||
|
||||
|
||||
T* allocate(size_t n)
|
||||
{
|
||||
alloc_count++;
|
||||
return allocator<T>::allocate(n);
|
||||
}
|
||||
|
||||
void deallocate(T* p, size_t n)
|
||||
{
|
||||
dealloc_count++;
|
||||
allocator<T>::deallocate(p, n);
|
||||
}
|
||||
};
|
||||
|
||||
static int do_minus(int x, int y) { return x-y; }
|
||||
|
||||
struct DoNothing
|
||||
{
|
||||
void operator()() const {}
|
||||
};
|
||||
|
||||
static void do_nothing() {}
|
||||
|
||||
static void test_allocator()
|
||||
{
|
||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
||||
boost::function<int (int, int), counting_allocator<int> > f;
|
||||
f = plus<int>();
|
||||
f.clear();
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f = &do_minus;
|
||||
f.clear();
|
||||
|
||||
boost::function<void (), counting_allocator<int> > fv;
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = DoNothing();
|
||||
fv.clear();
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = &do_nothing;
|
||||
fv.clear();
|
||||
#endif // ndef BOOST_NO_STD_ALLOCATOR
|
||||
}
|
||||
|
||||
static void test_exception()
|
||||
{
|
||||
boost::function<int (int, int)> f;
|
||||
try {
|
||||
f(5, 4);
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
catch(boost::bad_function_call) {
|
||||
// okay
|
||||
@ -652,12 +717,12 @@ static void test_implicit()
|
||||
|
||||
static void test_call_obj(boost::function<int (int, int)> f)
|
||||
{
|
||||
BOOST_CHECK(!f.empty());
|
||||
assert(!f.empty());
|
||||
}
|
||||
|
||||
static void test_call_cref(const boost::function<int (int, int)>& f)
|
||||
{
|
||||
BOOST_CHECK(!f.empty());
|
||||
assert(!f.empty());
|
||||
}
|
||||
|
||||
static void test_call()
|
||||
@ -674,6 +739,7 @@ int test_main(int, char* [])
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_allocator();
|
||||
test_exception();
|
||||
test_implicit();
|
||||
test_call();
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright (C) Douglas Gregor 2001-2005. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -22,7 +22,7 @@ test_main(int, char*[])
|
||||
if (f1 == f2) {
|
||||
}
|
||||
|
||||
BOOST_ERROR("This should not have compiled.");
|
||||
BOOST_CRITICAL_ERROR("This should not have compiled.");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright (C) Douglas Gregor 2001-2005. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -21,7 +21,7 @@ test_main(int, char*[])
|
||||
function0<int> f1;
|
||||
f1 = bad_fn;
|
||||
|
||||
BOOST_ERROR("This should not have compiled.");
|
||||
BOOST_CRITICAL_ERROR("This should not have compiled.");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is 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)
|
||||
@ -14,21 +14,23 @@
|
||||
struct stateless_integer_add {
|
||||
int operator()(int x, int y) const { return x+y; }
|
||||
|
||||
void* operator new(std::size_t)
|
||||
void* operator new(std::size_t, stateless_integer_add*)
|
||||
{
|
||||
throw std::runtime_error("Cannot allocate a stateless_integer_add");
|
||||
}
|
||||
|
||||
void* operator new(std::size_t, void* p)
|
||||
{
|
||||
return p;
|
||||
}
|
||||
|
||||
void operator delete(void*) throw()
|
||||
void operator delete(void*, stateless_integer_add*) throw()
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
namespace boost {
|
||||
template<>
|
||||
struct is_stateless<stateless_integer_add> {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
boost::function2<int, int, int> f;
|
||||
|
||||
Reference in New Issue
Block a user