mirror of
https://github.com/boostorg/function.git
synced 2025-06-25 20:11:37 +02:00
Compare commits
3 Commits
svn-branch
...
boost-1.33
| Author | SHA1 | Date | |
|---|---|---|---|
| 18693742af | |||
| f5f459f75e | |||
| f2c7079a02 |
@ -1,15 +1,5 @@
|
||||
# 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 ;
|
||||
|
||||
boostbook function-doc
|
||||
:
|
||||
function.xml
|
||||
:
|
||||
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
|
||||
;
|
||||
boostbook function-doc : function.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$">
|
||||
|
||||
@ -1,60 +1,10 @@
|
||||
<?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.37.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Improved the performance of Boost.Function's
|
||||
swap() operation for large function objects. Original patch
|
||||
contributed by Niels Dekker.</para></listitem>
|
||||
|
||||
<listitem><para>Added a new header <boost/function/function_typeof.hpp> that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
|
||||
|
||||
<listitem><para>Added a new header <boost/function/function_fwd.hpp> that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
|
||||
|
||||
<listitem><para>The <methodname alt="boost::function::target">target</methodname>()
|
||||
function now respects the cv-qualifiers of function objects
|
||||
stored by reference
|
||||
(using <classname>boost::reference_wrapper</classname>), such
|
||||
that a reference to a <code>const</code> function object cannot
|
||||
be accessed as a reference to a non-<code>const</code> function
|
||||
object.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.36.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Boost.Function now implements allocator support
|
||||
in the same way that is is provided in C++0x, based on C++
|
||||
committee
|
||||
proposal <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2308.html">N2308</ulink>. This
|
||||
change removes the <computeroutput>Allocator</computeroutput>
|
||||
template parameter of <classname>boost::function</classname> in
|
||||
favor of a constructor that takes an argument. While this is a
|
||||
backward-incompatible change, it is likely to affect only a few
|
||||
users. This change to Function was contributed by Emil
|
||||
Dotchevski, which also authored the corresponding C++ committee
|
||||
proposal.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<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>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>All features deprecated in version 1.29.0 have
|
||||
|
||||
13
doc/misc.xml
13
doc/misc.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.misc" last-revision="$Date$">
|
||||
@ -24,7 +17,7 @@
|
||||
<para> And, of course, function pointers have several advantages over Boost.Function:
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para> Function pointers are smaller (the size of one pointer instead of four or more) </para></listitem>
|
||||
<listitem><para> Function pointers are smaller (the size of one pointer instead of three) </para></listitem>
|
||||
<listitem><para> Function pointers are faster (Boost.Function may require two calls through function pointers) </para></listitem>
|
||||
<listitem><para> Function pointers are backward-compatible with C libraries.</para></listitem>
|
||||
<listitem><para> More readable error messages. </para></listitem>
|
||||
@ -37,12 +30,12 @@
|
||||
|
||||
<section>
|
||||
<title>Function object wrapper size</title>
|
||||
<para> Function object wrappers will be the size of a struct containing a member function pointer and two data pointers. The actual size can vary significantly depending on the underlying platform; on 32-bit Mac OS X with GCC, this amounts to 16 bytes, while it is 32 bytes Windows with Visual C++. Additionally, the function object target may be allocated on the heap, if it cannot be placed into the small-object buffer in the <code>boost::function</code> object.</para>
|
||||
<para> Function object wrappers will be the size of two function pointers plus one function pointer or data pointer (whichever is larger). On common 32-bit platforms, this amounts to 12 bytes per wrapper. Additionally, the function object target will be allocated on the heap.</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Copying efficiency</title>
|
||||
<para> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <computeroutput>ref</computeroutput>) if the cost of this cloning becomes prohibitive. Small function objects can be stored within the <code>boost::function</code> object itself, improving copying efficiency.</para>
|
||||
<para> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <computeroutput>ref</computeroutput>) if the cost of this cloning becomes prohibitive.</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
|
||||
@ -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">
|
||||
|
||||
@ -125,12 +118,6 @@
|
||||
<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>
|
||||
</class>
|
||||
|
||||
@ -141,6 +128,9 @@
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator">
|
||||
<default><classname>std::allocator</classname><void></default>
|
||||
</template-type-parameter>
|
||||
</template>
|
||||
|
||||
<inherit access="public"><classname>function_base</classname></inherit>
|
||||
@ -157,6 +147,7 @@
|
||||
</description>
|
||||
|
||||
<typedef name="result_type"><type>R</type></typedef>
|
||||
<typedef name="allocator_type"><type>Allocator</type></typedef>
|
||||
<typedef name="argument_type">
|
||||
<type>T1</type><purpose>If N == 1</purpose>
|
||||
</typedef>
|
||||
@ -191,7 +182,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>
|
||||
|
||||
@ -210,23 +201,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>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</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>
|
||||
|
||||
<effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
|
||||
<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>
|
||||
|
||||
@ -234,7 +213,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">
|
||||
@ -242,11 +222,13 @@
|
||||
<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>
|
||||
|
||||
@ -304,13 +286,6 @@
|
||||
<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">
|
||||
@ -322,7 +297,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>
|
||||
|
||||
@ -333,11 +308,13 @@
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype><classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<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>
|
||||
|
||||
@ -349,10 +326,11 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
@ -361,11 +339,12 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
@ -373,10 +352,11 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<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>
|
||||
@ -385,11 +365,12 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
@ -397,14 +378,16 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN>&</paramtype></parameter>
|
||||
<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> stores an object of
|
||||
@ -444,10 +427,11 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
@ -456,11 +440,12 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
@ -468,10 +453,11 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<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>
|
||||
@ -480,11 +466,12 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
@ -492,14 +479,16 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN>&</paramtype></parameter>
|
||||
<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
|
||||
@ -539,8 +528,11 @@
|
||||
<template-type-parameter name="Signature">
|
||||
<purpose>Function type R (T1, T2, ..., TN)</purpose>
|
||||
</template-type-parameter>
|
||||
<template-type-parameter name="Allocator">
|
||||
<default><classname>std::allocator</classname><void></default>
|
||||
</template-type-parameter>
|
||||
</template>
|
||||
<inherit access="public"><classname>functionN</classname><R, T1, T2, ..., TN></inherit>
|
||||
<inherit access="public"><classname>functionN</classname><R, T1, T2, ..., TN, Allocator></inherit>
|
||||
|
||||
<purpose>A generalized function pointer that can be used for
|
||||
callbacks or wrapping function objects.</purpose>
|
||||
@ -562,6 +554,7 @@
|
||||
</description>
|
||||
|
||||
<typedef name="result_type"><type>R</type></typedef>
|
||||
<typedef name="allocator_type"><type>Allocator</type></typedef>
|
||||
<typedef name="argument_type">
|
||||
<type>T1</type><purpose>If N == 1</purpose>
|
||||
</typedef>
|
||||
@ -596,7 +589,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>
|
||||
|
||||
@ -623,39 +616,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>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</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>
|
||||
|
||||
<effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
|
||||
<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">
|
||||
@ -663,6 +645,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">
|
||||
@ -725,12 +708,6 @@
|
||||
<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">
|
||||
@ -742,7 +719,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>
|
||||
|
||||
@ -750,11 +727,13 @@
|
||||
<function name="swap">
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype><classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<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>
|
||||
|
||||
@ -763,47 +742,53 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<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>&</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>&</paramtype></parameter>
|
||||
<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>&</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>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2>&</paramtype></parameter>
|
||||
<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> stores an object of
|
||||
@ -838,47 +823,53 @@
|
||||
<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>&</paramtype></parameter>
|
||||
<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>&</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>&</paramtype></parameter>
|
||||
<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>&</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>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2>&</paramtype></parameter>
|
||||
<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
|
||||
|
||||
@ -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$">
|
||||
|
||||
@ -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"
|
||||
@ -35,12 +28,12 @@ form to use for your compiler.
|
||||
<row>
|
||||
<entry>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara>GNU C++ 2.95.x, 3.0.x and later versions</simpara></listitem>
|
||||
<listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
|
||||
<listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
|
||||
<listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
|
||||
<listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
|
||||
<listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
|
||||
<listitem><simpara>Microsoft Visual C++ 7.1 and later versions</simpara></listitem>
|
||||
<listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
|
||||
</itemizedlist>
|
||||
</entry>
|
||||
<entry>
|
||||
|
||||
@ -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>
|
||||
|
||||
@ -23,8 +21,8 @@
|
||||
// in anything that may be included by function_template.hpp doesn't break
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
// Older Visual Age C++ version do not handle the file iteration well
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800)
|
||||
// Visual Age C++ doesn't handle the file iteration well
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 0
|
||||
# include <boost/function/function0.hpp>
|
||||
# endif
|
||||
|
||||
@ -11,7 +11,6 @@
|
||||
#define BOOST_FUNCTION_PROLOGUE_HPP
|
||||
# include <cassert>
|
||||
# include <algorithm>
|
||||
# include <boost/config/no_tr1/functional.hpp> // unary_function, binary_function
|
||||
# include <boost/throw_exception.hpp>
|
||||
# include <boost/config.hpp>
|
||||
# include <boost/function/function_base.hpp>
|
||||
@ -22,5 +21,4 @@
|
||||
# include <boost/preprocessor/cat.hpp>
|
||||
# include <boost/preprocessor/repeat.hpp>
|
||||
# include <boost/preprocessor/inc.hpp>
|
||||
# include <boost/type_traits/is_void.hpp>
|
||||
#endif // BOOST_FUNCTION_PROLOGUE_HPP
|
||||
|
||||
@ -1,9 +1,8 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2006
|
||||
// Copyright Emil Dotchevski 2007
|
||||
// Use, modification and distribution is subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// Copyright Douglas 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)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
@ -15,48 +14,25 @@
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <new>
|
||||
#include <typeinfo>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/sp_typeinfo.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/type_traits/has_trivial_copy.hpp>
|
||||
#include <boost/type_traits/has_trivial_destructor.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/type_traits/is_integral.hpp>
|
||||
#include <boost/type_traits/is_volatile.hpp>
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#include <boost/type_traits/ice.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>
|
||||
#include <boost/function/function_fwd.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_STD_TYPEINFO
|
||||
// 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( BOOST_NO_TYPEID )
|
||||
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
|
||||
#elif (defined(__GNUC__) && __GNUC__ >= 3) \
|
||||
# if (defined(__GNUC__) && __GNUC__ >= 3) \
|
||||
|| defined(_AIX) \
|
||||
|| ( defined(__sgi) && defined(__host_mips))
|
||||
# include <cstring>
|
||||
@ -72,7 +48,22 @@
|
||||
# define BOOST_FUNCTION_TARGET_FIX(x)
|
||||
#endif // not MSVC
|
||||
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
|
||||
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
|
||||
// Work around a compiler bug.
|
||||
// boost::python::objects::function has to be seen by the compiler before the
|
||||
// boost::function class template.
|
||||
namespace boost { namespace python { namespace objects {
|
||||
class function;
|
||||
}}}
|
||||
#endif
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|
||||
|| defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
|
||||
|| !(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), \
|
||||
@ -86,54 +77,70 @@
|
||||
Type>::type
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
namespace boost {
|
||||
|
||||
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
|
||||
// The library shipping with MIPSpro 7.3.1.3m has a broken allocator<void>
|
||||
class function_base;
|
||||
|
||||
template<typename Signature,
|
||||
typename Allocator = std::allocator<function_base> >
|
||||
class function;
|
||||
#else
|
||||
template<typename Signature, typename Allocator = std::allocator<void> >
|
||||
class function;
|
||||
#endif
|
||||
|
||||
template<typename Signature, typename Allocator>
|
||||
inline void swap(function<Signature, Allocator>& f1,
|
||||
function<Signature, Allocator>& f2)
|
||||
{
|
||||
f1.swap(f2);
|
||||
}
|
||||
|
||||
} // end namespace boost
|
||||
#endif // have partial specialization
|
||||
|
||||
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
|
||||
mutable void* obj_ptr;
|
||||
|
||||
// For pointers to std::type_info objects
|
||||
struct type_t {
|
||||
// (get_functor_type_tag, check_functor_type_tag).
|
||||
const detail::sp_typeinfo* type;
|
||||
|
||||
// Whether the type is const-qualified.
|
||||
bool const_qualified;
|
||||
// Whether the type is volatile-qualified.
|
||||
bool volatile_qualified;
|
||||
} type;
|
||||
|
||||
// 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;
|
||||
|
||||
// For references to function objects. We explicitly keep
|
||||
// track of the cv-qualifiers on the object referenced.
|
||||
struct obj_ref_t {
|
||||
mutable void* obj_ptr;
|
||||
bool is_const_qualified;
|
||||
bool is_volatile_qualified;
|
||||
} obj_ref;
|
||||
|
||||
// To relax aliasing constraints
|
||||
mutable char data;
|
||||
void* obj_ptr;
|
||||
const void* const_obj_ptr;
|
||||
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
|
||||
@ -161,10 +168,8 @@ namespace boost {
|
||||
// The operation type to perform on the given functor/function pointer
|
||||
enum functor_manager_operation_type {
|
||||
clone_functor_tag,
|
||||
move_functor_tag,
|
||||
destroy_functor_tag,
|
||||
check_functor_type_tag,
|
||||
get_functor_type_tag
|
||||
check_functor_type_tag
|
||||
};
|
||||
|
||||
// Tags used to decide between different types of functions
|
||||
@ -172,103 +177,54 @@ 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
|
||||
struct trivial_manager
|
||||
{
|
||||
static inline void
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
static inline any_pointer
|
||||
get(any_pointer f, functor_manager_operation_type op)
|
||||
{
|
||||
switch (op) {
|
||||
case clone_functor_tag:
|
||||
out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
|
||||
return;
|
||||
|
||||
case move_functor_tag:
|
||||
out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
|
||||
in_buffer.obj_ref.obj_ptr = 0;
|
||||
return;
|
||||
case clone_functor_tag: return f;
|
||||
|
||||
case destroy_functor_tag:
|
||||
out_buffer.obj_ref.obj_ptr = 0;
|
||||
return;
|
||||
return make_any_pointer(reinterpret_cast<void*>(0));
|
||||
|
||||
case check_functor_type_tag:
|
||||
{
|
||||
const detail::sp_typeinfo& check_type
|
||||
= *out_buffer.type.type;
|
||||
|
||||
// Check whether we have the same type. We can add
|
||||
// cv-qualifiers, but we can't take them away.
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
|
||||
&& (!in_buffer.obj_ref.is_const_qualified
|
||||
|| out_buffer.type.const_qualified)
|
||||
&& (!in_buffer.obj_ref.is_volatile_qualified
|
||||
|| out_buffer.type.volatile_qualified))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
std::type_info* t = static_cast<std::type_info*>(f.obj_ptr);
|
||||
return BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(F), *t)?
|
||||
f
|
||||
: make_any_pointer(reinterpret_cast<void*>(0));
|
||||
}
|
||||
return;
|
||||
|
||||
case get_functor_type_tag:
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(F);
|
||||
out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
|
||||
out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
|
||||
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))));
|
||||
};
|
||||
|
||||
template <typename F,typename A>
|
||||
struct functor_wrapper: public F, public A
|
||||
{
|
||||
functor_wrapper( F f, A a ):
|
||||
F(f),
|
||||
A(a)
|
||||
{
|
||||
}
|
||||
|
||||
functor_wrapper(const functor_wrapper& f) :
|
||||
F(static_cast<const F&>(f)),
|
||||
A(static_cast<const A&>(f))
|
||||
{
|
||||
// Clears up a warning with GCC 3.2.3
|
||||
return make_any_pointer(reinterpret_cast<void*>(0));
|
||||
}
|
||||
};
|
||||
|
||||
@ -276,272 +232,95 @@ namespace boost {
|
||||
* The functor_manager class contains a static function "manage" which
|
||||
* can clone or destroy the given function/function object pointer.
|
||||
*/
|
||||
template<typename Functor>
|
||||
struct functor_manager_common
|
||||
{
|
||||
typedef Functor functor_type;
|
||||
|
||||
// Function pointers
|
||||
static inline void
|
||||
manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
if (op == clone_functor_tag)
|
||||
out_buffer.func_ptr = in_buffer.func_ptr;
|
||||
else if (op == move_functor_tag) {
|
||||
out_buffer.func_ptr = in_buffer.func_ptr;
|
||||
in_buffer.func_ptr = 0;
|
||||
} else if (op == destroy_functor_tag)
|
||||
out_buffer.func_ptr = 0;
|
||||
else if (op == check_functor_type_tag) {
|
||||
const detail::sp_typeinfo& check_type
|
||||
= *out_buffer.type.type;
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
|
||||
out_buffer.obj_ptr = &in_buffer.func_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Function objects that fit in the small-object buffer.
|
||||
static inline void
|
||||
manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
if (op == clone_functor_tag || op == move_functor_tag) {
|
||||
const functor_type* in_functor =
|
||||
reinterpret_cast<const functor_type*>(&in_buffer.data);
|
||||
new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
|
||||
|
||||
if (op == move_functor_tag) {
|
||||
functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
|
||||
(void)f; // suppress warning about the value of f not being used (MSVC)
|
||||
f->~Functor();
|
||||
}
|
||||
} else if (op == destroy_functor_tag) {
|
||||
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
|
||||
functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
|
||||
(void)f; // suppress warning about the value of f not being used (MSVC)
|
||||
f->~Functor();
|
||||
} else if (op == check_functor_type_tag) {
|
||||
const detail::sp_typeinfo& check_type
|
||||
= *out_buffer.type.type;
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
|
||||
out_buffer.obj_ptr = &in_buffer.data;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Functor>
|
||||
template<typename Functor, typename Allocator>
|
||||
struct functor_manager
|
||||
{
|
||||
private:
|
||||
typedef Functor functor_type;
|
||||
|
||||
// Function pointers
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_ptr_tag)
|
||||
// For function pointers, the manager is trivial
|
||||
static inline any_pointer
|
||||
manager(any_pointer function_ptr,
|
||||
functor_manager_operation_type op,
|
||||
function_ptr_tag)
|
||||
{
|
||||
functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
|
||||
if (op == clone_functor_tag)
|
||||
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_)
|
||||
{
|
||||
functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
|
||||
}
|
||||
|
||||
// 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;
|
||||
#else
|
||||
typedef functor_type* pointer_type;
|
||||
#endif // BOOST_NO_STD_ALLOCATOR
|
||||
|
||||
# ifndef BOOST_NO_STD_ALLOCATOR
|
||||
allocator_type allocator;
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
|
||||
if (op == clone_functor_tag) {
|
||||
// Clone the functor
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
// jewillco: Changing this to static_cast because GCC 2.95.3 is
|
||||
// obsolete.
|
||||
const functor_type* f =
|
||||
static_cast<const functor_type*>(in_buffer.obj_ptr);
|
||||
functor_type* new_f = new functor_type(*f);
|
||||
out_buffer.obj_ptr = new_f;
|
||||
} else if (op == move_functor_tag) {
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
in_buffer.obj_ptr = 0;
|
||||
} else if (op == destroy_functor_tag) {
|
||||
/* Cast from the void pointer to the functor pointer type */
|
||||
functor_type* f =
|
||||
static_cast<functor_type*>(out_buffer.obj_ptr);
|
||||
delete f;
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else if (op == check_functor_type_tag) {
|
||||
const detail::sp_typeinfo& check_type
|
||||
= *out_buffer.type.type;
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
}
|
||||
}
|
||||
static_cast<functor_type*>(function_obj_ptr.obj_ptr);
|
||||
|
||||
// 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 use the small-object optimization buffer.
|
||||
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)
|
||||
{
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
switch (op) {
|
||||
case get_functor_type_tag:
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
return;
|
||||
|
||||
default:
|
||||
manager(in_buffer, out_buffer, op, tag_type());
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Functor, typename Allocator>
|
||||
struct functor_manager_a
|
||||
{
|
||||
private:
|
||||
typedef Functor functor_type;
|
||||
|
||||
// Function pointers
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_ptr_tag)
|
||||
{
|
||||
functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
|
||||
}
|
||||
|
||||
// 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_)
|
||||
{
|
||||
functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
|
||||
}
|
||||
|
||||
// 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_)
|
||||
{
|
||||
typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
|
||||
typedef typename Allocator::template rebind<functor_wrapper_type>::other
|
||||
wrapper_allocator_type;
|
||||
typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
|
||||
|
||||
if (op == clone_functor_tag) {
|
||||
// Clone the functor
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
const functor_wrapper_type* f =
|
||||
static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
|
||||
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
|
||||
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
|
||||
wrapper_allocator.construct(copy, *f);
|
||||
# ifndef BOOST_NO_STD_ALLOCATOR
|
||||
pointer_type copy = allocator.allocate(1);
|
||||
allocator.construct(copy, *f);
|
||||
|
||||
// Get back to the original pointer type
|
||||
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
|
||||
out_buffer.obj_ptr = new_f;
|
||||
} else if (op == move_functor_tag) {
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
in_buffer.obj_ptr = 0;
|
||||
} else if (op == destroy_functor_tag) {
|
||||
/* Cast from the void pointer to the functor_wrapper_type */
|
||||
functor_wrapper_type* victim =
|
||||
static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
|
||||
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
|
||||
wrapper_allocator.destroy(victim);
|
||||
wrapper_allocator.deallocate(victim,1);
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else if (op == check_functor_type_tag) {
|
||||
const detail::sp_typeinfo& check_type
|
||||
= *out_buffer.type.type;
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
functor_type* new_f = static_cast<functor_type*>(copy);
|
||||
# else
|
||||
functor_type* new_f = new functor_type(*f);
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
return make_any_pointer(static_cast<void*>(new_f));
|
||||
}
|
||||
else {
|
||||
/* Cast from the void pointer to the functor pointer type */
|
||||
functor_type* f =
|
||||
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
|
||||
type */
|
||||
pointer_type victim = static_cast<pointer_type>(f);
|
||||
|
||||
// Destroy and deallocate the functor
|
||||
allocator.destroy(victim);
|
||||
allocator.deallocate(victim, 1);
|
||||
# else
|
||||
delete f;
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
|
||||
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)>());
|
||||
}
|
||||
|
||||
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.type.type = &BOOST_SP_TYPEID(functor_type);
|
||||
out_buffer.type.const_qualified = false;
|
||||
out_buffer.type.volatile_qualified = false;
|
||||
return;
|
||||
|
||||
default:
|
||||
manager(in_buffer, out_buffer, op, tag_type());
|
||||
return;
|
||||
if (op == check_functor_type_tag) {
|
||||
std::type_info* type =
|
||||
static_cast<std::type_info*>(functor_ptr.obj_ptr);
|
||||
return (BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(Functor), *type)?
|
||||
functor_ptr
|
||||
: make_any_pointer(reinterpret_cast<void*>(0)));
|
||||
}
|
||||
else {
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
return manager(functor_ptr, op, tag_type());
|
||||
}
|
||||
}
|
||||
};
|
||||
@ -607,17 +386,6 @@ namespace boost {
|
||||
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
|
||||
|
||||
@ -630,65 +398,62 @@ 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 BOOST_SP_TYPEID(void)
|
||||
if this is empty. */
|
||||
const detail::sp_typeinfo& target_type() const
|
||||
function_base() : manager(0)
|
||||
{
|
||||
if (!vtable) return BOOST_SP_TYPEID(void);
|
||||
|
||||
detail::function::function_buffer type;
|
||||
get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
|
||||
return *type.type.type;
|
||||
functor.obj_ptr = 0;
|
||||
}
|
||||
|
||||
// Is this function empty?
|
||||
bool empty() const { return !manager; }
|
||||
|
||||
template<typename Functor>
|
||||
Functor* target()
|
||||
{
|
||||
if (!vtable) return 0;
|
||||
if (!manager) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
type_result.type.const_qualified = is_const<Functor>::value;
|
||||
type_result.type.volatile_qualified = is_volatile<Functor>::value;
|
||||
get_vtable()->manager(functor, type_result,
|
||||
detail::function::check_functor_type_tag);
|
||||
return static_cast<Functor*>(type_result.obj_ptr);
|
||||
detail::function::any_pointer result =
|
||||
manager(detail::function::make_any_pointer(&typeid(Functor)),
|
||||
detail::function::check_functor_type_tag);
|
||||
if (!result.obj_ptr) return 0;
|
||||
else {
|
||||
typedef typename detail::function::get_function_tag<Functor>::type tag;
|
||||
return get_functor_pointer<Functor>(tag(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
if (!manager) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.type.type = &BOOST_SP_TYPEID(Functor);
|
||||
type_result.type.const_qualified = true;
|
||||
type_result.type.volatile_qualified = is_volatile<Functor>::value;
|
||||
get_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 static_cast<const Functor*>(type_result.obj_ptr);
|
||||
detail::function::any_pointer result =
|
||||
manager(detail::function::make_any_pointer(&typeid(Functor)),
|
||||
detail::function::check_functor_type_tag);
|
||||
if (!result.obj_ptr) return 0;
|
||||
else {
|
||||
typedef typename detail::function::get_function_tag<Functor>::type tag;
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
return get_functor_pointer(tag(), 0, (Functor*)0);
|
||||
#else
|
||||
return get_functor_pointer<Functor>(tag(), 0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
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 ))
|
||||
if (const F* fp = this->target( (F*)0 )) {
|
||||
#else
|
||||
if (const F* fp = this->template target<F>())
|
||||
if (const F* fp = this->template target<F>()) {
|
||||
#endif
|
||||
{
|
||||
return function_equal(*fp, f);
|
||||
} else {
|
||||
return false;
|
||||
@ -719,17 +484,44 @@ public:
|
||||
#endif
|
||||
|
||||
public: // should be protected, but GCC 2.95.3 will fail to allow access
|
||||
detail::function::vtable_base* get_vtable() const {
|
||||
return reinterpret_cast<detail::function::vtable_base*>(
|
||||
reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
|
||||
}
|
||||
detail::function::any_pointer (*manager)(
|
||||
detail::function::any_pointer,
|
||||
detail::function::functor_manager_operation_type);
|
||||
detail::function::any_pointer functor;
|
||||
|
||||
bool has_trivial_copy_and_destroy() const {
|
||||
return reinterpret_cast<std::size_t>(vtable) & 0x01;
|
||||
}
|
||||
private:
|
||||
template<typename Functor>
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
Functor* get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0)
|
||||
#else
|
||||
Functor* get_functor_pointer(detail::function::function_ptr_tag, int)
|
||||
#endif
|
||||
{ return reinterpret_cast<Functor*>(&functor.func_ptr); }
|
||||
|
||||
detail::function::vtable_base* vtable;
|
||||
mutable detail::function::function_buffer functor;
|
||||
template<typename Functor, typename Tag>
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
Functor* get_functor_pointer(Tag, long, Functor * = 0)
|
||||
#else
|
||||
Functor* get_functor_pointer(Tag, long)
|
||||
#endif
|
||||
{ return static_cast<Functor*>(functor.obj_ptr); }
|
||||
|
||||
template<typename Functor>
|
||||
const Functor*
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0) const
|
||||
#else
|
||||
get_functor_pointer(detail::function::function_ptr_tag, int) const
|
||||
#endif
|
||||
{ return reinterpret_cast<const Functor*>(&functor.func_ptr); }
|
||||
|
||||
template<typename Functor, typename Tag>
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
const Functor* get_functor_pointer(Tag, long, Functor * = 0) const
|
||||
#else
|
||||
const Functor* get_functor_pointer(Tag, long) const
|
||||
#endif
|
||||
{ return static_cast<const Functor*>(functor.const_obj_ptr); }
|
||||
};
|
||||
|
||||
/**
|
||||
@ -903,8 +695,4 @@ namespace detail {
|
||||
#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,70 +0,0 @@
|
||||
// Boost.Function library
|
||||
// Copyright (C) Douglas Gregor 2008
|
||||
//
|
||||
// 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_FWD_HPP
|
||||
#define BOOST_FUNCTION_FWD_HPP
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
|
||||
// Work around a compiler bug.
|
||||
// boost::python::objects::function has to be seen by the compiler before the
|
||||
// boost::function class template.
|
||||
namespace boost { namespace python { namespace objects {
|
||||
class function;
|
||||
}}}
|
||||
#endif
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|
||||
|| defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
|
||||
|| !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
|
||||
# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
class bad_function_call;
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
// Preferred syntax
|
||||
template<typename Signature> class function;
|
||||
|
||||
template<typename Signature>
|
||||
inline void swap(function<Signature>& f1, function<Signature>& f2)
|
||||
{
|
||||
f1.swap(f2);
|
||||
}
|
||||
#endif // have partial specialization
|
||||
|
||||
// Portable syntax
|
||||
template<typename R> class function0;
|
||||
template<typename R, typename T1> class function1;
|
||||
template<typename R, typename T1, typename T2> class function2;
|
||||
template<typename R, typename T1, typename T2, typename T3> class function3;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4>
|
||||
class function4;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5>
|
||||
class function5;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6>
|
||||
class function6;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6, typename T7>
|
||||
class function7;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6, typename T7, typename T8>
|
||||
class function8;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6, typename T7, typename T8, typename T9>
|
||||
class function9;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6, typename T7, typename T8, typename T9,
|
||||
typename T10>
|
||||
class function10;
|
||||
}
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,45 +0,0 @@
|
||||
// Boost.Function library - Typeof support
|
||||
// Copyright (C) Douglas Gregor 2008
|
||||
//
|
||||
// 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_TYPEOF_HPP
|
||||
#define BOOST_FUNCTION_TYPEOF_HPP
|
||||
#include <boost/function/function_fwd.hpp>
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
|
||||
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::bad_function_call)
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function, (typename))
|
||||
#endif
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function0, (typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function1, (typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function2, (typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function3,
|
||||
(typename)(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function4,
|
||||
(typename)(typename)(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function5,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function6,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function7,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename)
|
||||
(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function8,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename)
|
||||
(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function9,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename)
|
||||
(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function10,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename)
|
||||
(typename)(typename)(typename)(typename))
|
||||
#endif
|
||||
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>
|
||||
|
||||
68
test/Jamfile
Normal file
68
test/Jamfile
Normal file
@ -0,0 +1,68 @@
|
||||
# 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 : : : : ]
|
||||
|
||||
[ run libs/function/test/contains_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains2_test.cpp : : : : ]
|
||||
;
|
||||
}
|
||||
@ -8,7 +8,6 @@
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
project
|
||||
: requirements <toolset>msvc:<asynch-exceptions>on
|
||||
: source-location $(BOOST_ROOT)
|
||||
;
|
||||
|
||||
@ -59,9 +58,6 @@ import testing ;
|
||||
|
||||
[ run libs/function/test/contains2_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/nothrow_swap.cpp : : : : ]
|
||||
|
||||
[ compile libs/function/test/function_typeof_test.cpp ]
|
||||
;
|
||||
}
|
||||
|
||||
|
||||
@ -27,14 +27,6 @@ struct counting_allocator : public std::allocator<T>
|
||||
typedef counting_allocator<U> other;
|
||||
};
|
||||
|
||||
counting_allocator()
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
counting_allocator( counting_allocator<U> )
|
||||
{
|
||||
}
|
||||
|
||||
T* allocate(std::size_t n)
|
||||
{
|
||||
@ -49,27 +41,20 @@ struct counting_allocator : public std::allocator<T>
|
||||
}
|
||||
};
|
||||
|
||||
struct enable_small_object_optimization
|
||||
{
|
||||
};
|
||||
|
||||
struct disable_small_object_optimization
|
||||
{
|
||||
int unused_state_data[32];
|
||||
};
|
||||
|
||||
template <typename base>
|
||||
struct plus_int: base
|
||||
struct plus_int
|
||||
{
|
||||
int operator()(int x, int y) const { return x + y; }
|
||||
|
||||
int unused_state_data;
|
||||
};
|
||||
|
||||
static int do_minus(int x, int y) { return x-y; }
|
||||
|
||||
template <typename base>
|
||||
struct DoNothing: base
|
||||
struct DoNothing
|
||||
{
|
||||
void operator()() const {}
|
||||
|
||||
int unused_state_data;
|
||||
};
|
||||
|
||||
static void do_nothing() {}
|
||||
@ -77,61 +62,33 @@ static void do_nothing() {}
|
||||
int
|
||||
test_main(int, char*[])
|
||||
{
|
||||
function2<int, int, int> f;
|
||||
f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
|
||||
function2<int, int, int, counting_allocator<int> > f;
|
||||
f = plus_int();
|
||||
f.clear();
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||
f.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
f.assign( plus_int<disable_small_object_optimization>(), std::allocator<int>() );
|
||||
f.clear();
|
||||
f.assign( plus_int<enable_small_object_optimization>(), std::allocator<int>() );
|
||||
f.clear();
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f.assign( &do_minus, counting_allocator<int>() );
|
||||
f = &do_minus;
|
||||
f.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
f.assign( &do_minus, std::allocator<int>() );
|
||||
f.clear();
|
||||
|
||||
function0<void> fv;
|
||||
function0<void, counting_allocator<int> > fv;
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
|
||||
fv = DoNothing();
|
||||
fv.clear();
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||
fv.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
fv.assign( DoNothing<disable_small_object_optimization>(), std::allocator<int>() );
|
||||
fv.clear();
|
||||
fv.assign( DoNothing<enable_small_object_optimization>(), std::allocator<int>() );
|
||||
fv.clear();
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv.assign( &do_nothing, counting_allocator<int>() );
|
||||
fv = &do_nothing;
|
||||
fv.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
fv.assign( &do_nothing, std::allocator<int>() );
|
||||
fv.clear();
|
||||
|
||||
function0<void> fv2;
|
||||
fv.assign(&do_nothing, std::allocator<int>() );
|
||||
fv2.assign(fv, std::allocator<int>() );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -88,15 +88,6 @@ static void target_test()
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<Seventeen>());
|
||||
BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
|
||||
|
||||
const Seventeen const_seventeen = this_seventeen;
|
||||
f = boost::ref(const_seventeen);
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<const Seventeen>());
|
||||
BOOST_CHECK(f.target<const Seventeen>() == &const_seventeen);
|
||||
BOOST_CHECK(f.target<const volatile Seventeen>());
|
||||
BOOST_CHECK(!f.target<Seventeen>());
|
||||
BOOST_CHECK(!f.target<volatile Seventeen>());
|
||||
}
|
||||
|
||||
static void equal_test()
|
||||
|
||||
@ -636,54 +636,6 @@ test_ref()
|
||||
}
|
||||
}
|
||||
|
||||
static unsigned construction_count = 0;
|
||||
static unsigned destruction_count = 0;
|
||||
|
||||
struct MySmallFunctor {
|
||||
MySmallFunctor() { ++construction_count; }
|
||||
MySmallFunctor(const MySmallFunctor &) { ++construction_count; }
|
||||
~MySmallFunctor() { ++destruction_count; }
|
||||
int operator()() { return 0; }
|
||||
};
|
||||
|
||||
struct MyLargeFunctor {
|
||||
MyLargeFunctor() { ++construction_count; }
|
||||
MyLargeFunctor(const MyLargeFunctor &) { ++construction_count; }
|
||||
~MyLargeFunctor() { ++destruction_count; }
|
||||
int operator()() { return 0; }
|
||||
|
||||
float data[128];
|
||||
};
|
||||
|
||||
void test_construct_destroy_count()
|
||||
{
|
||||
{
|
||||
boost::function0<int> f;
|
||||
boost::function0<int> g;
|
||||
f = MySmallFunctor();
|
||||
g = MySmallFunctor();
|
||||
f.swap(g);
|
||||
}
|
||||
|
||||
// MySmallFunctor objects should be constructed as many times as
|
||||
// they are destroyed.
|
||||
BOOST_CHECK(construction_count == destruction_count);
|
||||
|
||||
construction_count = 0;
|
||||
destruction_count = 0;
|
||||
{
|
||||
boost::function0<int> f;
|
||||
boost::function0<int> g;
|
||||
f = MyLargeFunctor();
|
||||
g = MyLargeFunctor();
|
||||
f.swap(g);
|
||||
}
|
||||
|
||||
// MyLargeFunctor objects should be constructed as many times as
|
||||
// they are destroyed.
|
||||
BOOST_CHECK(construction_count == destruction_count);
|
||||
}
|
||||
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
@ -692,6 +644,5 @@ int test_main(int, char* [])
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_construct_destroy_count();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -10,11 +10,12 @@
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <functional>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
using boost::function;
|
||||
using std::string;
|
||||
using namespace boost;
|
||||
using namespace std;
|
||||
|
||||
int global_int;
|
||||
|
||||
@ -525,7 +526,7 @@ test_zero_args()
|
||||
static void
|
||||
test_one_arg()
|
||||
{
|
||||
std::negate<int> neg;
|
||||
negate<int> neg;
|
||||
|
||||
function<int (int)> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
@ -607,12 +608,12 @@ struct add_with_throw_on_copy {
|
||||
|
||||
add_with_throw_on_copy(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
throw runtime_error("But this CAN'T throw");
|
||||
}
|
||||
|
||||
add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
throw runtime_error("But this CAN'T throw");
|
||||
}
|
||||
};
|
||||
|
||||
@ -621,38 +622,14 @@ test_ref()
|
||||
{
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function<int (int, int)> f(boost::ref(atc));
|
||||
boost::function<int (int, int)> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
}
|
||||
catch(std::runtime_error e) {
|
||||
catch(runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
static void dummy() {}
|
||||
|
||||
static void test_empty_ref()
|
||||
{
|
||||
boost::function<void()> f1;
|
||||
boost::function<void()> f2(boost::ref(f1));
|
||||
|
||||
try {
|
||||
f2();
|
||||
BOOST_ERROR("Exception didn't throw for reference to empty function.");
|
||||
}
|
||||
catch(std::runtime_error e) {}
|
||||
|
||||
f1 = dummy;
|
||||
|
||||
try {
|
||||
f2();
|
||||
}
|
||||
catch(std::runtime_error e) {
|
||||
BOOST_ERROR("Error calling referenced function.");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void test_exception()
|
||||
{
|
||||
boost::function<int (int, int)> f;
|
||||
@ -676,12 +653,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()
|
||||
@ -698,7 +675,6 @@ int test_main(int, char* [])
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_empty_ref();
|
||||
test_exception();
|
||||
test_implicit();
|
||||
test_call();
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright (C) Douglas Gregor 2001-2005. Use, modification and
|
||||
// Copyright Douglas 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 Douglas 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,18 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2008. 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
|
||||
#include <boost/function/function_typeof.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
void f(boost::function0<void> f, boost::function0<void> g)
|
||||
{
|
||||
BOOST_STATIC_ASSERT((boost::is_same<boost::function0<void>, BOOST_TYPEOF(f = g)>::value));
|
||||
}
|
||||
@ -15,21 +15,21 @@
|
||||
#include <boost/lambda/bind.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
using namespace boost::lambda;
|
||||
|
||||
static unsigned
|
||||
func_impl(int arg1, bool arg2, double arg3)
|
||||
{
|
||||
using namespace std;
|
||||
return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
using boost::function;
|
||||
using namespace boost::lambda;
|
||||
|
||||
function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
|
||||
function <unsigned(double)> f2 = boost::lambda::bind(f1, false, _1);
|
||||
function <unsigned()> f3 = boost::lambda::bind(f2, 4.0);
|
||||
function <unsigned(double)> f2 = bind(f1, false, _1);
|
||||
function <unsigned()> f3 = bind(f2, 4.0);
|
||||
|
||||
f3();
|
||||
|
||||
|
||||
@ -1,60 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2008. 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
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
struct tried_to_copy { };
|
||||
|
||||
struct MaybeThrowOnCopy {
|
||||
MaybeThrowOnCopy(int value = 0) : value(value) { }
|
||||
|
||||
MaybeThrowOnCopy(const MaybeThrowOnCopy& other) : value(other.value) {
|
||||
if (throwOnCopy)
|
||||
throw tried_to_copy();
|
||||
}
|
||||
|
||||
MaybeThrowOnCopy& operator=(const MaybeThrowOnCopy& other) {
|
||||
if (throwOnCopy)
|
||||
throw tried_to_copy();
|
||||
value = other.value;
|
||||
return *this;
|
||||
}
|
||||
|
||||
int operator()() { return value; }
|
||||
|
||||
int value;
|
||||
|
||||
// Make sure that this function object doesn't trigger the
|
||||
// small-object optimization in Function.
|
||||
float padding[100];
|
||||
|
||||
static bool throwOnCopy;
|
||||
};
|
||||
|
||||
bool MaybeThrowOnCopy::throwOnCopy = false;
|
||||
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
boost::function0<int> f;
|
||||
boost::function0<int> g;
|
||||
|
||||
MaybeThrowOnCopy::throwOnCopy = false;
|
||||
f = MaybeThrowOnCopy(1);
|
||||
g = MaybeThrowOnCopy(2);
|
||||
BOOST_CHECK(f() == 1);
|
||||
BOOST_CHECK(g() == 2);
|
||||
|
||||
MaybeThrowOnCopy::throwOnCopy = true;
|
||||
f.swap(g);
|
||||
BOOST_CHECK(f() == 2);
|
||||
BOOST_CHECK(g() == 1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -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