forked from boostorg/function
Compare commits
18 Commits
svn-branch
...
svn-branch
Author | SHA1 | Date | |
---|---|---|---|
03bef419ac | |||
20efadeb6f | |||
4f50451f4b | |||
313a188f4d | |||
50525d7fcc | |||
eda8bd6d1c | |||
c07234dd7c | |||
fc782cd4fe | |||
0936dbdd03 | |||
adb7b0a214 | |||
cead36cd5b | |||
81e558491b | |||
2378ba59e7 | |||
53b95c386d | |||
3312c7ffcd | |||
de27ae9697 | |||
a7b9940f15 | |||
e4f165a4e8 |
22
CMakeLists.txt
Normal file
22
CMakeLists.txt
Normal file
@ -0,0 +1,22 @@
|
|||||||
|
#----------------------------------------------------------------------------
|
||||||
|
# This file was automatically generated from the original CMakeLists.txt file
|
||||||
|
# Add a variable to hold the headers for the library
|
||||||
|
set (lib_headers
|
||||||
|
function.hpp
|
||||||
|
function
|
||||||
|
)
|
||||||
|
|
||||||
|
# Add a library target to the build system
|
||||||
|
boost_library_project(
|
||||||
|
function
|
||||||
|
# SRCDIRS
|
||||||
|
TESTDIRS test
|
||||||
|
HEADERS ${lib_headers}
|
||||||
|
DOCDIRS doc
|
||||||
|
# DESCRIPTION
|
||||||
|
MODULARIZED
|
||||||
|
# AUTHORS
|
||||||
|
# MAINTAINERS
|
||||||
|
)
|
||||||
|
|
||||||
|
|
2
doc/CMakeLists.txt
Normal file
2
doc/CMakeLists.txt
Normal file
@ -0,0 +1,2 @@
|
|||||||
|
boost_add_documentation(function.xml
|
||||||
|
faq.xml history.xml misc.xml reference.xml tests.xml tutorial.xml)
|
@ -1,3 +1,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)
|
||||||
project boost/doc ;
|
project boost/doc ;
|
||||||
import boostbook : boostbook ;
|
import boostbook : boostbook ;
|
||||||
|
|
||||||
|
@ -1,4 +1,11 @@
|
|||||||
<?xml version="1.0" encoding="utf-8"?>
|
<?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"
|
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||||
<section id="function.faq" last-revision="$Date$">
|
<section id="function.faq" last-revision="$Date$">
|
||||||
|
@ -1,4 +1,11 @@
|
|||||||
<?xml version="1.0" encoding="utf-8"?>
|
<?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"
|
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||||
<section id="function.history" last-revision="$Date$">
|
<section id="function.history" last-revision="$Date$">
|
||||||
@ -6,6 +13,42 @@
|
|||||||
|
|
||||||
<itemizedlist spacing="compact">
|
<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>
|
<listitem><para><bold>Version 1.34.0</bold>: </para>
|
||||||
<itemizedlist spacing="compact">
|
<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>
|
<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>
|
||||||
|
13
doc/misc.xml
13
doc/misc.xml
@ -1,4 +1,11 @@
|
|||||||
<?xml version="1.0" encoding="utf-8"?>
|
<?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"
|
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||||
<section id="function.misc" last-revision="$Date$">
|
<section id="function.misc" last-revision="$Date$">
|
||||||
@ -17,7 +24,7 @@
|
|||||||
<para> And, of course, function pointers have several advantages over Boost.Function:
|
<para> And, of course, function pointers have several advantages over Boost.Function:
|
||||||
|
|
||||||
<itemizedlist spacing="compact">
|
<itemizedlist spacing="compact">
|
||||||
<listitem><para> Function pointers are smaller (the size of one pointer instead of three) </para></listitem>
|
<listitem><para> Function pointers are smaller (the size of one pointer instead of four or more) </para></listitem>
|
||||||
<listitem><para> Function pointers are faster (Boost.Function may require two calls through function pointers) </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> Function pointers are backward-compatible with C libraries.</para></listitem>
|
||||||
<listitem><para> More readable error messages. </para></listitem>
|
<listitem><para> More readable error messages. </para></listitem>
|
||||||
@ -30,12 +37,12 @@
|
|||||||
|
|
||||||
<section>
|
<section>
|
||||||
<title>Function object wrapper size</title>
|
<title>Function object wrapper size</title>
|
||||||
<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>
|
<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>
|
||||||
</section>
|
</section>
|
||||||
|
|
||||||
<section>
|
<section>
|
||||||
<title>Copying efficiency</title>
|
<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.</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. Small function objects can be stored within the <code>boost::function</code> object itself, improving copying efficiency.</para>
|
||||||
</section>
|
</section>
|
||||||
|
|
||||||
<section>
|
<section>
|
||||||
|
@ -1,4 +1,11 @@
|
|||||||
<?xml version="1.0" encoding="utf-8"?>
|
<?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"
|
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||||
|
|
||||||
@ -134,9 +141,6 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator">
|
|
||||||
<default><classname>std::allocator</classname><void></default>
|
|
||||||
</template-type-parameter>
|
|
||||||
</template>
|
</template>
|
||||||
|
|
||||||
<inherit access="public"><classname>function_base</classname></inherit>
|
<inherit access="public"><classname>function_base</classname></inherit>
|
||||||
@ -153,7 +157,6 @@
|
|||||||
</description>
|
</description>
|
||||||
|
|
||||||
<typedef name="result_type"><type>R</type></typedef>
|
<typedef name="result_type"><type>R</type></typedef>
|
||||||
<typedef name="allocator_type"><type>Allocator</type></typedef>
|
|
||||||
<typedef name="argument_type">
|
<typedef name="argument_type">
|
||||||
<type>T1</type><purpose>If N == 1</purpose>
|
<type>T1</type><purpose>If N == 1</purpose>
|
||||||
</typedef>
|
</typedef>
|
||||||
@ -209,6 +212,19 @@
|
|||||||
<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>
|
<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>
|
||||||
|
|
||||||
|
<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>
|
||||||
|
</constructor>
|
||||||
|
|
||||||
<destructor>
|
<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>
|
||||||
|
|
||||||
@ -317,11 +333,10 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
</template>
|
</template>
|
||||||
<type>void</type>
|
<type>void</type>
|
||||||
<parameter name="f1"><paramtype><classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f1"><paramtype><classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
<parameter name="f2"><paramtype><classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f2"><paramtype><classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
||||||
</function>
|
</function>
|
||||||
</free-function-group>
|
</free-function-group>
|
||||||
@ -334,11 +349,10 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
@ -347,12 +361,11 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
@ -360,11 +373,10 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
@ -373,12 +385,11 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
@ -386,16 +397,14 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator1"/>
|
|
||||||
<template-type-parameter name="U1"/>
|
<template-type-parameter name="U1"/>
|
||||||
<template-type-parameter name="U2"/>
|
<template-type-parameter name="U2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="UN"/>
|
<template-type-parameter name="UN"/>
|
||||||
<template-type-parameter name="Allocator2"/>
|
|
||||||
</template>
|
</template>
|
||||||
<type>void</type>
|
<type>void</type>
|
||||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator1>&</paramtype></parameter>
|
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN, Allocator2>&</paramtype></parameter>
|
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
|
|
||||||
<returns><simpara>True when <code>f</code> stores an object of
|
<returns><simpara>True when <code>f</code> stores an object of
|
||||||
@ -435,11 +444,10 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
@ -448,12 +456,11 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
@ -461,11 +468,10 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
@ -474,12 +480,11 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
@ -487,16 +492,14 @@
|
|||||||
<template-type-parameter name="T2"/>
|
<template-type-parameter name="T2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="TN"/>
|
<template-type-parameter name="TN"/>
|
||||||
<template-type-parameter name="Allocator1"/>
|
|
||||||
<template-type-parameter name="U1"/>
|
<template-type-parameter name="U1"/>
|
||||||
<template-type-parameter name="U2"/>
|
<template-type-parameter name="U2"/>
|
||||||
<template-varargs/>
|
<template-varargs/>
|
||||||
<template-type-parameter name="UN"/>
|
<template-type-parameter name="UN"/>
|
||||||
<template-type-parameter name="Allocator2"/>
|
|
||||||
</template>
|
</template>
|
||||||
<type>void</type>
|
<type>void</type>
|
||||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator1>&</paramtype></parameter>
|
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN, Allocator2>&</paramtype></parameter>
|
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
|
|
||||||
<returns><simpara>True when <code>f</code> does not store an
|
<returns><simpara>True when <code>f</code> does not store an
|
||||||
@ -536,11 +539,8 @@
|
|||||||
<template-type-parameter name="Signature">
|
<template-type-parameter name="Signature">
|
||||||
<purpose>Function type R (T1, T2, ..., TN)</purpose>
|
<purpose>Function type R (T1, T2, ..., TN)</purpose>
|
||||||
</template-type-parameter>
|
</template-type-parameter>
|
||||||
<template-type-parameter name="Allocator">
|
|
||||||
<default><classname>std::allocator</classname><void></default>
|
|
||||||
</template-type-parameter>
|
|
||||||
</template>
|
</template>
|
||||||
<inherit access="public"><classname>functionN</classname><R, T1, T2, ..., TN, Allocator></inherit>
|
<inherit access="public"><classname>functionN</classname><R, T1, T2, ..., TN></inherit>
|
||||||
|
|
||||||
<purpose>A generalized function pointer that can be used for
|
<purpose>A generalized function pointer that can be used for
|
||||||
callbacks or wrapping function objects.</purpose>
|
callbacks or wrapping function objects.</purpose>
|
||||||
@ -562,7 +562,6 @@
|
|||||||
</description>
|
</description>
|
||||||
|
|
||||||
<typedef name="result_type"><type>R</type></typedef>
|
<typedef name="result_type"><type>R</type></typedef>
|
||||||
<typedef name="allocator_type"><type>Allocator</type></typedef>
|
|
||||||
<typedef name="argument_type">
|
<typedef name="argument_type">
|
||||||
<type>T1</type><purpose>If N == 1</purpose>
|
<type>T1</type><purpose>If N == 1</purpose>
|
||||||
</typedef>
|
</typedef>
|
||||||
@ -626,6 +625,19 @@
|
|||||||
<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>
|
<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>
|
||||||
|
|
||||||
|
<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>
|
||||||
|
</constructor>
|
||||||
|
|
||||||
<destructor>
|
<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>
|
||||||
|
|
||||||
@ -738,11 +750,10 @@
|
|||||||
<function name="swap">
|
<function name="swap">
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature"/>
|
<template-type-parameter name="Signature"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
</template>
|
</template>
|
||||||
<type>void</type>
|
<type>void</type>
|
||||||
<parameter name="f1"><paramtype><classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f1"><paramtype><classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
<parameter name="f2"><paramtype><classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f2"><paramtype><classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
||||||
</function>
|
</function>
|
||||||
</free-function-group>
|
</free-function-group>
|
||||||
@ -752,53 +763,47 @@
|
|||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature"/>
|
<template-type-parameter name="Signature"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature"/>
|
<template-type-parameter name="Signature"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature"/>
|
<template-type-parameter name="Signature"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature"/>
|
<template-type-parameter name="Signature"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature1"/>
|
<template-type-parameter name="Signature1"/>
|
||||||
<template-type-parameter name="Allocator1"/>
|
|
||||||
<template-type-parameter name="Signature2"/>
|
<template-type-parameter name="Signature2"/>
|
||||||
<template-type-parameter name="Allocator2"/>
|
|
||||||
</template>
|
</template>
|
||||||
<type>void</type>
|
<type>void</type>
|
||||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1, Allocator1>&</paramtype></parameter>
|
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1>&</paramtype></parameter>
|
||||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2, Allocator2>&</paramtype></parameter>
|
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
|
|
||||||
<returns><simpara>True when <code>f</code> stores an object of
|
<returns><simpara>True when <code>f</code> stores an object of
|
||||||
@ -833,53 +838,47 @@
|
|||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature"/>
|
<template-type-parameter name="Signature"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature"/>
|
<template-type-parameter name="Signature"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature"/>
|
<template-type-parameter name="Signature"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature"/>
|
<template-type-parameter name="Signature"/>
|
||||||
<template-type-parameter name="Allocator"/>
|
|
||||||
<template-type-parameter name="Functor"/>
|
<template-type-parameter name="Functor"/>
|
||||||
</template>
|
</template>
|
||||||
<type>bool</type>
|
<type>bool</type>
|
||||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
<signature>
|
<signature>
|
||||||
<template>
|
<template>
|
||||||
<template-type-parameter name="Signature1"/>
|
<template-type-parameter name="Signature1"/>
|
||||||
<template-type-parameter name="Allocator1"/>
|
|
||||||
<template-type-parameter name="Signature2"/>
|
<template-type-parameter name="Signature2"/>
|
||||||
<template-type-parameter name="Allocator2"/>
|
|
||||||
</template>
|
</template>
|
||||||
<type>void</type>
|
<type>void</type>
|
||||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1, Allocator1>&</paramtype></parameter>
|
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1>&</paramtype></parameter>
|
||||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2, Allocator2>&</paramtype></parameter>
|
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2>&</paramtype></parameter>
|
||||||
</signature>
|
</signature>
|
||||||
|
|
||||||
<returns><simpara>True when <code>f</code> does not store an
|
<returns><simpara>True when <code>f</code> does not store an
|
||||||
|
@ -1,4 +1,11 @@
|
|||||||
<?xml version="1.0" encoding="utf-8"?>
|
<?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"
|
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||||
<testsuite id="function.testsuite" last-revision="$Date$">
|
<testsuite id="function.testsuite" last-revision="$Date$">
|
||||||
|
@ -1,4 +1,11 @@
|
|||||||
<?xml version="1.0" encoding="utf-8"?>
|
<?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"
|
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||||
<section xmlns:xi="http://www.w3.org/2001/XInclude" id="function.tutorial"
|
<section xmlns:xi="http://www.w3.org/2001/XInclude" id="function.tutorial"
|
||||||
|
@ -11,7 +11,7 @@
|
|||||||
#define BOOST_FUNCTION_PROLOGUE_HPP
|
#define BOOST_FUNCTION_PROLOGUE_HPP
|
||||||
# include <cassert>
|
# include <cassert>
|
||||||
# include <algorithm>
|
# include <algorithm>
|
||||||
# include <functional> // unary_function, binary_function
|
# include <boost/config/no_tr1/functional.hpp> // unary_function, binary_function
|
||||||
# include <boost/throw_exception.hpp>
|
# include <boost/throw_exception.hpp>
|
||||||
# include <boost/config.hpp>
|
# include <boost/config.hpp>
|
||||||
# include <boost/function/function_base.hpp>
|
# include <boost/function/function_base.hpp>
|
||||||
@ -22,4 +22,5 @@
|
|||||||
# include <boost/preprocessor/cat.hpp>
|
# include <boost/preprocessor/cat.hpp>
|
||||||
# include <boost/preprocessor/repeat.hpp>
|
# include <boost/preprocessor/repeat.hpp>
|
||||||
# include <boost/preprocessor/inc.hpp>
|
# include <boost/preprocessor/inc.hpp>
|
||||||
|
# include <boost/type_traits/is_void.hpp>
|
||||||
#endif // BOOST_FUNCTION_PROLOGUE_HPP
|
#endif // BOOST_FUNCTION_PROLOGUE_HPP
|
||||||
|
@ -1,8 +1,9 @@
|
|||||||
// Boost.Function library
|
// Boost.Function library
|
||||||
|
|
||||||
// Copyright Douglas Gregor 2001-2006. Use, modification and
|
// Copyright Douglas Gregor 2001-2006
|
||||||
// distribution is subject to the Boost Software License, Version
|
// Copyright Emil Dotchevski 2007
|
||||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
// 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)
|
// http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
|
||||||
// For more information, see http://www.boost.org
|
// For more information, see http://www.boost.org
|
||||||
@ -17,8 +18,11 @@
|
|||||||
#include <typeinfo>
|
#include <typeinfo>
|
||||||
#include <boost/config.hpp>
|
#include <boost/config.hpp>
|
||||||
#include <boost/assert.hpp>
|
#include <boost/assert.hpp>
|
||||||
|
#include <boost/type_traits/is_const.hpp>
|
||||||
#include <boost/type_traits/is_integral.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/composite_traits.hpp>
|
||||||
|
#include <boost/type_traits/ice.hpp>
|
||||||
#include <boost/ref.hpp>
|
#include <boost/ref.hpp>
|
||||||
#include <boost/mpl/if.hpp>
|
#include <boost/mpl/if.hpp>
|
||||||
#include <boost/detail/workaround.hpp>
|
#include <boost/detail/workaround.hpp>
|
||||||
@ -29,9 +33,16 @@
|
|||||||
# include "boost/mpl/bool.hpp"
|
# include "boost/mpl/bool.hpp"
|
||||||
#endif
|
#endif
|
||||||
#include <boost/function_equal.hpp>
|
#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.
|
// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
|
||||||
#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
|
#ifdef BOOST_NO_STD_TYPEINFO
|
||||||
// Embedded VC++ does not have type_info in namespace std
|
// Embedded VC++ does not have type_info in namespace std
|
||||||
# define BOOST_FUNCTION_STD_NS
|
# define BOOST_FUNCTION_STD_NS
|
||||||
#else
|
#else
|
||||||
@ -56,22 +67,7 @@
|
|||||||
# define BOOST_FUNCTION_TARGET_FIX(x)
|
# define BOOST_FUNCTION_TARGET_FIX(x)
|
||||||
#endif // not MSVC
|
#endif // not MSVC
|
||||||
|
|
||||||
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
|
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
|
||||||
// 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
|
|
||||||
|
|
||||||
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
|
|
||||||
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
|
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
|
||||||
typename ::boost::enable_if_c<(::boost::type_traits::ice_not< \
|
typename ::boost::enable_if_c<(::boost::type_traits::ice_not< \
|
||||||
(::boost::is_integral<Functor>::value)>::value), \
|
(::boost::is_integral<Functor>::value)>::value), \
|
||||||
@ -85,31 +81,6 @@ namespace boost { namespace python { namespace objects {
|
|||||||
Type>::type
|
Type>::type
|
||||||
#endif
|
#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 boost {
|
||||||
namespace detail {
|
namespace detail {
|
||||||
namespace function {
|
namespace function {
|
||||||
@ -124,11 +95,18 @@ namespace boost {
|
|||||||
union function_buffer
|
union function_buffer
|
||||||
{
|
{
|
||||||
// For pointers to function objects
|
// For pointers to function objects
|
||||||
void* obj_ptr;
|
mutable void* obj_ptr;
|
||||||
|
|
||||||
// For pointers to std::type_info objects
|
// For pointers to std::type_info objects
|
||||||
// (get_functor_type_tag, check_functor_type_tag).
|
struct type_t {
|
||||||
const void* const_obj_ptr;
|
// (get_functor_type_tag, check_functor_type_tag).
|
||||||
|
const BOOST_FUNCTION_STD_NS::type_info* 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
|
// For function pointers of all kinds
|
||||||
mutable void (*func_ptr)();
|
mutable void (*func_ptr)();
|
||||||
@ -139,6 +117,14 @@ namespace boost {
|
|||||||
void* obj_ptr;
|
void* obj_ptr;
|
||||||
} bound_memfunc_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
|
// To relax aliasing constraints
|
||||||
mutable char data;
|
mutable char data;
|
||||||
};
|
};
|
||||||
@ -170,6 +156,7 @@ namespace boost {
|
|||||||
// The operation type to perform on the given functor/function pointer
|
// The operation type to perform on the given functor/function pointer
|
||||||
enum functor_manager_operation_type {
|
enum functor_manager_operation_type {
|
||||||
clone_functor_tag,
|
clone_functor_tag,
|
||||||
|
move_functor_tag,
|
||||||
destroy_functor_tag,
|
destroy_functor_tag,
|
||||||
check_functor_type_tag,
|
check_functor_type_tag,
|
||||||
get_functor_type_tag
|
get_functor_type_tag
|
||||||
@ -206,34 +193,45 @@ namespace boost {
|
|||||||
struct reference_manager
|
struct reference_manager
|
||||||
{
|
{
|
||||||
static inline void
|
static inline void
|
||||||
get(const function_buffer& in_buffer, function_buffer& out_buffer,
|
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||||
functor_manager_operation_type op)
|
functor_manager_operation_type op)
|
||||||
{
|
{
|
||||||
switch (op) {
|
switch (op) {
|
||||||
case clone_functor_tag:
|
case clone_functor_tag:
|
||||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
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;
|
return;
|
||||||
|
|
||||||
case destroy_functor_tag:
|
case destroy_functor_tag:
|
||||||
out_buffer.obj_ptr = 0;
|
out_buffer.obj_ref.obj_ptr = 0;
|
||||||
return;
|
return;
|
||||||
|
|
||||||
case check_functor_type_tag:
|
case check_functor_type_tag:
|
||||||
{
|
{
|
||||||
// DPG TBD: Since we're only storing a pointer, it's
|
const BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||||
// possible that the user could ask for a base class or
|
= *out_buffer.type.type;
|
||||||
// derived class. Is that okay?
|
|
||||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
// Check whether we have the same type. We can add
|
||||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
// cv-qualifiers, but we can't take them away.
|
||||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
|
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F))
|
||||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
&& (!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
|
else
|
||||||
out_buffer.obj_ptr = 0;
|
out_buffer.obj_ptr = 0;
|
||||||
}
|
}
|
||||||
return;
|
return;
|
||||||
|
|
||||||
case get_functor_type_tag:
|
case get_functor_type_tag:
|
||||||
out_buffer.const_obj_ptr = &typeid(F);
|
out_buffer.type.type = &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;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -253,33 +251,94 @@ namespace boost {
|
|||||||
% alignment_of<F>::value == 0))));
|
% 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)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* The functor_manager class contains a static function "manage" which
|
* The functor_manager class contains a static function "manage" which
|
||||||
* can clone or destroy the given function/function object pointer.
|
* can clone or destroy the given function/function object pointer.
|
||||||
*/
|
*/
|
||||||
template<typename Functor, typename Allocator>
|
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 BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||||
|
= *out_buffer.type.type;
|
||||||
|
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, 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 = &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 ((void*)&out_buffer.data) functor_type(*in_functor);
|
||||||
|
|
||||||
|
if (op == move_functor_tag) {
|
||||||
|
reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
|
||||||
|
}
|
||||||
|
} else if (op == destroy_functor_tag) {
|
||||||
|
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
|
||||||
|
reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
|
||||||
|
} else if (op == check_functor_type_tag) {
|
||||||
|
const BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||||
|
= *out_buffer.type.type;
|
||||||
|
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, 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 = &typeid(Functor);
|
||||||
|
out_buffer.type.const_qualified = false;
|
||||||
|
out_buffer.type.volatile_qualified = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template<typename Functor>
|
||||||
struct functor_manager
|
struct functor_manager
|
||||||
{
|
{
|
||||||
private:
|
private:
|
||||||
typedef Functor functor_type;
|
typedef Functor functor_type;
|
||||||
|
|
||||||
// For function pointers, the manager is trivial
|
// Function pointers
|
||||||
static inline void
|
static inline void
|
||||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||||
functor_manager_operation_type op, function_ptr_tag)
|
functor_manager_operation_type op, function_ptr_tag)
|
||||||
{
|
{
|
||||||
if (op == clone_functor_tag)
|
functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
|
||||||
out_buffer.func_ptr = in_buffer.func_ptr;
|
|
||||||
else if (op == destroy_functor_tag)
|
|
||||||
out_buffer.func_ptr = 0;
|
|
||||||
else /* op == check_functor_type_tag */ {
|
|
||||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
|
||||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
|
||||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
|
||||||
out_buffer.obj_ptr = &in_buffer.func_ptr;
|
|
||||||
else
|
|
||||||
out_buffer.obj_ptr = 0;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Function objects that fit in the small-object buffer.
|
// Function objects that fit in the small-object buffer.
|
||||||
@ -287,21 +346,7 @@ namespace boost {
|
|||||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||||
functor_manager_operation_type op, mpl::true_)
|
functor_manager_operation_type op, mpl::true_)
|
||||||
{
|
{
|
||||||
if (op == clone_functor_tag) {
|
functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
|
||||||
const functor_type* in_functor =
|
|
||||||
reinterpret_cast<const functor_type*>(&in_buffer.data);
|
|
||||||
new ((void*)&out_buffer.data) functor_type(*in_functor);
|
|
||||||
} else if (op == destroy_functor_tag) {
|
|
||||||
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
|
|
||||||
reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
|
|
||||||
} else /* op == check_functor_type_tag */ {
|
|
||||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
|
||||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
|
||||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
|
||||||
out_buffer.obj_ptr = &in_buffer.data;
|
|
||||||
else
|
|
||||||
out_buffer.obj_ptr = 0;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Function objects that require heap allocation
|
// Function objects that require heap allocation
|
||||||
@ -309,59 +354,145 @@ namespace boost {
|
|||||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||||
functor_manager_operation_type op, mpl::false_)
|
functor_manager_operation_type op, mpl::false_)
|
||||||
{
|
{
|
||||||
#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) {
|
if (op == clone_functor_tag) {
|
||||||
|
// Clone the functor
|
||||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||||
// can't do the static_cast that we should do.
|
// can't do the static_cast that we should do.
|
||||||
const functor_type* f =
|
const functor_type* f =
|
||||||
(const functor_type*)(in_buffer.obj_ptr);
|
(const functor_type*)(in_buffer.obj_ptr);
|
||||||
|
|
||||||
// Clone the functor
|
|
||||||
# ifndef BOOST_NO_STD_ALLOCATOR
|
|
||||||
pointer_type copy = allocator.allocate(1);
|
|
||||||
allocator.construct(copy, *f);
|
|
||||||
|
|
||||||
// Get back to the original pointer type
|
|
||||||
functor_type* new_f = static_cast<functor_type*>(copy);
|
|
||||||
# else
|
|
||||||
functor_type* new_f = new functor_type(*f);
|
functor_type* new_f = new functor_type(*f);
|
||||||
# endif // BOOST_NO_STD_ALLOCATOR
|
|
||||||
out_buffer.obj_ptr = new_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) {
|
} else if (op == destroy_functor_tag) {
|
||||||
/* Cast from the void pointer to the functor pointer type */
|
/* Cast from the void pointer to the functor pointer type */
|
||||||
functor_type* f =
|
functor_type* f =
|
||||||
static_cast<functor_type*>(out_buffer.obj_ptr);
|
static_cast<functor_type*>(out_buffer.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;
|
delete f;
|
||||||
# endif // BOOST_NO_STD_ALLOCATOR
|
|
||||||
out_buffer.obj_ptr = 0;
|
out_buffer.obj_ptr = 0;
|
||||||
} else /* op == check_functor_type_tag */ {
|
} else if (op == check_functor_type_tag) {
|
||||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
const BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
= *out_buffer.type.type;
|
||||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||||
else
|
else
|
||||||
out_buffer.obj_ptr = 0;
|
out_buffer.obj_ptr = 0;
|
||||||
|
} else /* op == get_functor_type_tag */ {
|
||||||
|
out_buffer.type.type = &typeid(Functor);
|
||||||
|
out_buffer.type.const_qualified = false;
|
||||||
|
out_buffer.type.volatile_qualified = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 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 = &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 =
|
||||||
|
(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);
|
||||||
|
|
||||||
|
// 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 BOOST_FUNCTION_STD_NS::type_info& check_type
|
||||||
|
= *out_buffer.type.type;
|
||||||
|
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, 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 = &typeid(Functor);
|
||||||
|
out_buffer.type.const_qualified = false;
|
||||||
|
out_buffer.type.volatile_qualified = false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -386,7 +517,9 @@ namespace boost {
|
|||||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||||
switch (op) {
|
switch (op) {
|
||||||
case get_functor_type_tag:
|
case get_functor_type_tag:
|
||||||
out_buffer.const_obj_ptr = &typeid(functor_type);
|
out_buffer.type.type = &typeid(functor_type);
|
||||||
|
out_buffer.type.const_qualified = false;
|
||||||
|
out_buffer.type.volatile_qualified = false;
|
||||||
return;
|
return;
|
||||||
|
|
||||||
default:
|
default:
|
||||||
@ -464,7 +597,6 @@ namespace boost {
|
|||||||
*/
|
*/
|
||||||
struct vtable_base
|
struct vtable_base
|
||||||
{
|
{
|
||||||
vtable_base() : manager(0) { }
|
|
||||||
void (*manager)(const function_buffer& in_buffer,
|
void (*manager)(const function_buffer& in_buffer,
|
||||||
function_buffer& out_buffer,
|
function_buffer& out_buffer,
|
||||||
functor_manager_operation_type op);
|
functor_manager_operation_type op);
|
||||||
@ -494,7 +626,7 @@ public:
|
|||||||
|
|
||||||
detail::function::function_buffer type;
|
detail::function::function_buffer type;
|
||||||
vtable->manager(functor, type, detail::function::get_functor_type_tag);
|
vtable->manager(functor, type, detail::function::get_functor_type_tag);
|
||||||
return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
|
return *type.type.type;
|
||||||
}
|
}
|
||||||
|
|
||||||
template<typename Functor>
|
template<typename Functor>
|
||||||
@ -503,7 +635,9 @@ public:
|
|||||||
if (!vtable) return 0;
|
if (!vtable) return 0;
|
||||||
|
|
||||||
detail::function::function_buffer type_result;
|
detail::function::function_buffer type_result;
|
||||||
type_result.const_obj_ptr = &typeid(Functor);
|
type_result.type.type = &typeid(Functor);
|
||||||
|
type_result.type.const_qualified = is_const<Functor>::value;
|
||||||
|
type_result.type.volatile_qualified = is_volatile<Functor>::value;
|
||||||
vtable->manager(functor, type_result,
|
vtable->manager(functor, type_result,
|
||||||
detail::function::check_functor_type_tag);
|
detail::function::check_functor_type_tag);
|
||||||
return static_cast<Functor*>(type_result.obj_ptr);
|
return static_cast<Functor*>(type_result.obj_ptr);
|
||||||
@ -519,7 +653,9 @@ public:
|
|||||||
if (!vtable) return 0;
|
if (!vtable) return 0;
|
||||||
|
|
||||||
detail::function::function_buffer type_result;
|
detail::function::function_buffer type_result;
|
||||||
type_result.const_obj_ptr = &typeid(Functor);
|
type_result.type.type = &typeid(Functor);
|
||||||
|
type_result.type.const_qualified = true;
|
||||||
|
type_result.type.volatile_qualified = is_volatile<Functor>::value;
|
||||||
vtable->manager(functor, type_result,
|
vtable->manager(functor, type_result,
|
||||||
detail::function::check_functor_type_tag);
|
detail::function::check_functor_type_tag);
|
||||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||||
|
70
include/boost/function/function_fwd.hpp
Normal file
70
include/boost/function/function_fwd.hpp
Normal file
@ -0,0 +1,70 @@
|
|||||||
|
// 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) \
|
||||||
|
|| !(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
|
@ -1,8 +1,9 @@
|
|||||||
// Boost.Function library
|
// Boost.Function library
|
||||||
|
|
||||||
// Copyright Douglas Gregor 2001-2006. Use, modification and
|
// Copyright Douglas Gregor 2001-2006
|
||||||
// distribution is subject to the Boost Software License, Version
|
// Copyright Emil Dotchevski 2007
|
||||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
// 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)
|
// http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
|
||||||
// For more information, see http://www.boost.org
|
// For more information, see http://www.boost.org
|
||||||
@ -11,6 +12,11 @@
|
|||||||
// protection.
|
// protection.
|
||||||
#include <boost/function/detail/prologue.hpp>
|
#include <boost/function/detail/prologue.hpp>
|
||||||
|
|
||||||
|
#if defined(BOOST_MSVC)
|
||||||
|
# pragma warning( push )
|
||||||
|
# pragma warning( disable : 4127 ) // "conditional expression is constant"
|
||||||
|
#endif
|
||||||
|
|
||||||
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
|
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
|
||||||
|
|
||||||
#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
|
#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
|
||||||
@ -26,13 +32,6 @@
|
|||||||
|
|
||||||
#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
|
#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
|
||||||
|
|
||||||
// Type of the default allocator
|
|
||||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
|
||||||
# define BOOST_FUNCTION_DEFAULT_ALLOCATOR std::allocator<function_base>
|
|
||||||
#else
|
|
||||||
# define BOOST_FUNCTION_DEFAULT_ALLOCATOR int
|
|
||||||
#endif // BOOST_NO_STD_ALLOCATOR
|
|
||||||
|
|
||||||
// Comma if nonzero number of arguments
|
// Comma if nonzero number of arguments
|
||||||
#if BOOST_FUNCTION_NUM_ARGS == 0
|
#if BOOST_FUNCTION_NUM_ARGS == 0
|
||||||
# define BOOST_FUNCTION_COMMA
|
# define BOOST_FUNCTION_COMMA
|
||||||
@ -54,12 +53,20 @@
|
|||||||
BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||||
#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
|
#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
|
||||||
BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||||
|
#define BOOST_FUNCTION_MEMBER_INVOKER \
|
||||||
|
BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||||
|
#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
|
||||||
|
BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||||
#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
|
#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
|
||||||
BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
|
BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||||
#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
|
#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
|
||||||
BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||||
#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
|
#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
|
||||||
BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||||
|
#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
|
||||||
|
BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||||
|
#define BOOST_FUNCTION_GET_INVOKER \
|
||||||
|
BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||||
#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
|
#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
|
||||||
|
|
||||||
#ifndef BOOST_NO_VOID_RETURNS
|
#ifndef BOOST_NO_VOID_RETURNS
|
||||||
@ -181,6 +188,44 @@ namespace boost {
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||||
|
/* Handle invocation of member pointers. */
|
||||||
|
template<
|
||||||
|
typename MemberPtr,
|
||||||
|
typename R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||||
|
>
|
||||||
|
struct BOOST_FUNCTION_MEMBER_INVOKER
|
||||||
|
{
|
||||||
|
static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_PARMS)
|
||||||
|
|
||||||
|
{
|
||||||
|
MemberPtr* f =
|
||||||
|
reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
|
||||||
|
return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template<
|
||||||
|
typename MemberPtr,
|
||||||
|
typename R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||||
|
>
|
||||||
|
struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
|
||||||
|
{
|
||||||
|
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||||
|
invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_PARMS)
|
||||||
|
|
||||||
|
{
|
||||||
|
MemberPtr* f =
|
||||||
|
reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
|
||||||
|
BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
#endif
|
||||||
|
|
||||||
template<
|
template<
|
||||||
typename FunctionPtr,
|
typename FunctionPtr,
|
||||||
typename R BOOST_FUNCTION_COMMA
|
typename R BOOST_FUNCTION_COMMA
|
||||||
@ -244,12 +289,190 @@ namespace boost {
|
|||||||
>::type type;
|
>::type type;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||||
|
/* Retrieve the appropriate invoker for a member pointer. */
|
||||||
|
template<
|
||||||
|
typename MemberPtr,
|
||||||
|
typename R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||||
|
>
|
||||||
|
struct BOOST_FUNCTION_GET_MEMBER_INVOKER
|
||||||
|
{
|
||||||
|
typedef typename mpl::if_c<(is_void<R>::value),
|
||||||
|
BOOST_FUNCTION_VOID_MEMBER_INVOKER<
|
||||||
|
MemberPtr,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>,
|
||||||
|
BOOST_FUNCTION_MEMBER_INVOKER<
|
||||||
|
MemberPtr,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>
|
||||||
|
>::type type;
|
||||||
|
};
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Given the tag returned by get_function_tag, retrieve the
|
||||||
|
actual invoker that will be used for the given function
|
||||||
|
object.
|
||||||
|
|
||||||
|
Each specialization contains an "apply" nested class template
|
||||||
|
that accepts the function object, return type, function
|
||||||
|
argument types, and allocator. The resulting "apply" class
|
||||||
|
contains two typedefs, "invoker_type" and "manager_type",
|
||||||
|
which correspond to the invoker and manager types. */
|
||||||
|
template<typename Tag>
|
||||||
|
struct BOOST_FUNCTION_GET_INVOKER { };
|
||||||
|
|
||||||
|
/* Retrieve the invoker for a function pointer. */
|
||||||
|
template<>
|
||||||
|
struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
|
||||||
|
{
|
||||||
|
template<typename FunctionPtr,
|
||||||
|
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
|
struct apply
|
||||||
|
{
|
||||||
|
typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
|
||||||
|
FunctionPtr,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>::type
|
||||||
|
invoker_type;
|
||||||
|
|
||||||
|
typedef functor_manager<FunctionPtr> manager_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template<typename FunctionPtr,
|
||||||
|
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||||
|
typename Allocator>
|
||||||
|
struct apply_a
|
||||||
|
{
|
||||||
|
typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
|
||||||
|
FunctionPtr,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>::type
|
||||||
|
invoker_type;
|
||||||
|
|
||||||
|
typedef functor_manager<FunctionPtr> manager_type;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||||
|
/* Retrieve the invoker for a member pointer. */
|
||||||
|
template<>
|
||||||
|
struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
|
||||||
|
{
|
||||||
|
template<typename MemberPtr,
|
||||||
|
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
|
struct apply
|
||||||
|
{
|
||||||
|
typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
|
||||||
|
MemberPtr,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>::type
|
||||||
|
invoker_type;
|
||||||
|
|
||||||
|
typedef functor_manager<MemberPtr> manager_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template<typename MemberPtr,
|
||||||
|
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||||
|
typename Allocator>
|
||||||
|
struct apply_a
|
||||||
|
{
|
||||||
|
typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
|
||||||
|
MemberPtr,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>::type
|
||||||
|
invoker_type;
|
||||||
|
|
||||||
|
typedef functor_manager<MemberPtr> manager_type;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Retrieve the invoker for a function object. */
|
||||||
|
template<>
|
||||||
|
struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
|
||||||
|
{
|
||||||
|
template<typename FunctionObj,
|
||||||
|
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
|
struct apply
|
||||||
|
{
|
||||||
|
typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
|
||||||
|
FunctionObj,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>::type
|
||||||
|
invoker_type;
|
||||||
|
|
||||||
|
typedef functor_manager<FunctionObj> manager_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template<typename FunctionObj,
|
||||||
|
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||||
|
typename Allocator>
|
||||||
|
struct apply_a
|
||||||
|
{
|
||||||
|
typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
|
||||||
|
FunctionObj,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>::type
|
||||||
|
invoker_type;
|
||||||
|
|
||||||
|
typedef functor_manager_a<FunctionObj, Allocator> manager_type;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
/* Retrieve the invoker for a reference to a function object. */
|
||||||
|
template<>
|
||||||
|
struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
|
||||||
|
{
|
||||||
|
template<typename RefWrapper,
|
||||||
|
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
|
struct apply
|
||||||
|
{
|
||||||
|
typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
|
||||||
|
typename RefWrapper::type,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>::type
|
||||||
|
invoker_type;
|
||||||
|
|
||||||
|
typedef reference_manager<typename RefWrapper::type> manager_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template<typename RefWrapper,
|
||||||
|
typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||||
|
typename Allocator>
|
||||||
|
struct apply_a
|
||||||
|
{
|
||||||
|
typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
|
||||||
|
typename RefWrapper::type,
|
||||||
|
R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
|
>::type
|
||||||
|
invoker_type;
|
||||||
|
|
||||||
|
typedef reference_manager<typename RefWrapper::type> manager_type;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* vtable for a specific boost::function instance.
|
* vtable for a specific boost::function instance. This
|
||||||
|
* structure must be an aggregate so that we can use static
|
||||||
|
* initialization in boost::function's assign_to and assign_to_a
|
||||||
|
* members. It therefore cannot have any constructors,
|
||||||
|
* destructors, base classes, etc.
|
||||||
*/
|
*/
|
||||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
typename Allocator>
|
struct BOOST_FUNCTION_VTABLE
|
||||||
struct BOOST_FUNCTION_VTABLE : vtable_base
|
|
||||||
{
|
{
|
||||||
#ifndef BOOST_NO_VOID_RETURNS
|
#ifndef BOOST_NO_VOID_RETURNS
|
||||||
typedef R result_type;
|
typedef R result_type;
|
||||||
@ -261,48 +484,27 @@ namespace boost {
|
|||||||
BOOST_FUNCTION_COMMA
|
BOOST_FUNCTION_COMMA
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS);
|
BOOST_FUNCTION_TEMPLATE_ARGS);
|
||||||
|
|
||||||
template<typename F>
|
|
||||||
BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
|
|
||||||
{
|
|
||||||
init(f);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename F>
|
template<typename F>
|
||||||
bool assign_to(F f, function_buffer& functor)
|
bool assign_to(F f, function_buffer& functor)
|
||||||
{
|
{
|
||||||
typedef typename get_function_tag<F>::type tag;
|
typedef typename get_function_tag<F>::type tag;
|
||||||
return assign_to(f, functor, tag());
|
return assign_to(f, functor, tag());
|
||||||
}
|
}
|
||||||
|
template<typename F,typename Allocator>
|
||||||
|
bool assign_to_a(F f, function_buffer& functor, Allocator a)
|
||||||
|
{
|
||||||
|
typedef typename get_function_tag<F>::type tag;
|
||||||
|
return assign_to_a(f, functor, a, tag());
|
||||||
|
}
|
||||||
|
|
||||||
void clear(function_buffer& functor)
|
void clear(function_buffer& functor)
|
||||||
{
|
{
|
||||||
if (manager)
|
if (base.manager)
|
||||||
manager(functor, functor, destroy_functor_tag);
|
base.manager(functor, functor, destroy_functor_tag);
|
||||||
}
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
template<typename F>
|
|
||||||
void init(F f)
|
|
||||||
{
|
|
||||||
typedef typename get_function_tag<F>::type tag;
|
|
||||||
init(f, tag());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Function pointers
|
// Function pointers
|
||||||
template<typename FunctionPtr>
|
|
||||||
void init(FunctionPtr /*f*/, function_ptr_tag)
|
|
||||||
{
|
|
||||||
typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
|
|
||||||
FunctionPtr,
|
|
||||||
R BOOST_FUNCTION_COMMA
|
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
||||||
>::type
|
|
||||||
actual_invoker_type;
|
|
||||||
|
|
||||||
invoker = &actual_invoker_type::invoke;
|
|
||||||
manager = &functor_manager<FunctionPtr, Allocator>::manage;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename FunctionPtr>
|
template<typename FunctionPtr>
|
||||||
bool
|
bool
|
||||||
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
|
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
|
||||||
@ -317,18 +519,15 @@ namespace boost {
|
|||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
template<typename FunctionPtr,typename Allocator>
|
||||||
|
bool
|
||||||
|
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
|
||||||
|
{
|
||||||
|
return assign_to(f,functor,function_ptr_tag());
|
||||||
|
}
|
||||||
|
|
||||||
// Member pointers
|
// Member pointers
|
||||||
#if BOOST_FUNCTION_NUM_ARGS > 0
|
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||||
template<typename MemberPtr>
|
|
||||||
void init(MemberPtr f, member_ptr_tag)
|
|
||||||
{
|
|
||||||
// DPG TBD: Add explicit support for member function
|
|
||||||
// objects, so we invoke through mem_fn() but we retain the
|
|
||||||
// right target_type() values.
|
|
||||||
this->init(mem_fn(f));
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename MemberPtr>
|
template<typename MemberPtr>
|
||||||
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
|
bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
|
||||||
{
|
{
|
||||||
@ -342,23 +541,22 @@ namespace boost {
|
|||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
template<typename MemberPtr,typename Allocator>
|
||||||
|
bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
|
||||||
|
{
|
||||||
|
// DPG TBD: Add explicit support for member function
|
||||||
|
// objects, so we invoke through mem_fn() but we retain the
|
||||||
|
// right target_type() values.
|
||||||
|
if (f) {
|
||||||
|
this->assign_to_a(mem_fn(f), functor, a);
|
||||||
|
return true;
|
||||||
|
} else {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
#endif // BOOST_FUNCTION_NUM_ARGS > 0
|
#endif // BOOST_FUNCTION_NUM_ARGS > 0
|
||||||
|
|
||||||
// Function objects
|
// Function objects
|
||||||
template<typename FunctionObj>
|
|
||||||
void init(FunctionObj /*f*/, function_obj_tag)
|
|
||||||
{
|
|
||||||
typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
|
|
||||||
FunctionObj,
|
|
||||||
R BOOST_FUNCTION_COMMA
|
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
||||||
>::type
|
|
||||||
actual_invoker_type;
|
|
||||||
|
|
||||||
invoker = &actual_invoker_type::invoke;
|
|
||||||
manager = &functor_manager<FunctionObj, Allocator>::manage;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Assign to a function object using the small object optimization
|
// Assign to a function object using the small object optimization
|
||||||
template<typename FunctionObj>
|
template<typename FunctionObj>
|
||||||
void
|
void
|
||||||
@ -366,26 +564,33 @@ namespace boost {
|
|||||||
{
|
{
|
||||||
new ((void*)&functor.data) FunctionObj(f);
|
new ((void*)&functor.data) FunctionObj(f);
|
||||||
}
|
}
|
||||||
|
template<typename FunctionObj,typename Allocator>
|
||||||
|
void
|
||||||
|
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
|
||||||
|
{
|
||||||
|
assign_functor(f,functor,mpl::true_());
|
||||||
|
}
|
||||||
|
|
||||||
// Assign to a function object allocated on the heap.
|
// Assign to a function object allocated on the heap.
|
||||||
template<typename FunctionObj>
|
template<typename FunctionObj>
|
||||||
void
|
void
|
||||||
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
|
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
|
||||||
{
|
{
|
||||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
|
||||||
typedef typename Allocator::template rebind<FunctionObj>::other
|
|
||||||
allocator_type;
|
|
||||||
typedef typename allocator_type::pointer pointer_type;
|
|
||||||
|
|
||||||
allocator_type allocator;
|
|
||||||
pointer_type copy = allocator.allocate(1);
|
|
||||||
allocator.construct(copy, f);
|
|
||||||
|
|
||||||
// Get back to the original pointer type
|
|
||||||
functor.obj_ptr = static_cast<FunctionObj*>(copy);
|
|
||||||
# else
|
|
||||||
functor.obj_ptr = new FunctionObj(f);
|
functor.obj_ptr = new FunctionObj(f);
|
||||||
# endif // BOOST_NO_STD_ALLOCATOR
|
}
|
||||||
|
template<typename FunctionObj,typename Allocator>
|
||||||
|
void
|
||||||
|
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
|
||||||
|
{
|
||||||
|
typedef functor_wrapper<FunctionObj,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;
|
||||||
|
wrapper_allocator_type wrapper_allocator(a);
|
||||||
|
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
|
||||||
|
wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
|
||||||
|
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
|
||||||
|
functor.obj_ptr = new_f;
|
||||||
}
|
}
|
||||||
|
|
||||||
template<typename FunctionObj>
|
template<typename FunctionObj>
|
||||||
@ -400,41 +605,44 @@ namespace boost {
|
|||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
template<typename FunctionObj,typename Allocator>
|
||||||
// Reference to a function object
|
|
||||||
template<typename FunctionObj>
|
|
||||||
void
|
|
||||||
init(const reference_wrapper<FunctionObj>& /*f*/, function_obj_ref_tag)
|
|
||||||
{
|
|
||||||
typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
|
|
||||||
FunctionObj,
|
|
||||||
R BOOST_FUNCTION_COMMA
|
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
|
||||||
>::type
|
|
||||||
actual_invoker_type;
|
|
||||||
|
|
||||||
invoker = &actual_invoker_type::invoke;
|
|
||||||
manager = &reference_manager<FunctionObj>::get;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename FunctionObj>
|
|
||||||
bool
|
bool
|
||||||
assign_to(const reference_wrapper<FunctionObj>& f,
|
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
|
||||||
function_buffer& functor, function_obj_ref_tag)
|
|
||||||
{
|
{
|
||||||
if (!boost::detail::function::has_empty_target(f.get_pointer())) {
|
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
|
||||||
// DPG TBD: We might need to detect constness of
|
assign_functor_a(f, functor, a,
|
||||||
// FunctionObj to assign into obj_ptr or const_obj_ptr to
|
mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
|
||||||
// be truly legit, but no platform in existence makes
|
|
||||||
// const void* different from void*.
|
|
||||||
functor.const_obj_ptr = f.get_pointer();
|
|
||||||
return true;
|
return true;
|
||||||
} else {
|
} else {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Reference to a function object
|
||||||
|
template<typename FunctionObj>
|
||||||
|
bool
|
||||||
|
assign_to(const reference_wrapper<FunctionObj>& f,
|
||||||
|
function_buffer& functor, function_obj_ref_tag)
|
||||||
|
{
|
||||||
|
if (!boost::detail::function::has_empty_target(f.get_pointer())) {
|
||||||
|
functor.obj_ref.obj_ptr = (void *)f.get_pointer();
|
||||||
|
functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
|
||||||
|
functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
|
||||||
|
return true;
|
||||||
|
} else {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
template<typename FunctionObj,typename Allocator>
|
||||||
|
bool
|
||||||
|
assign_to_a(const reference_wrapper<FunctionObj>& f,
|
||||||
|
function_buffer& functor, Allocator, function_obj_ref_tag)
|
||||||
|
{
|
||||||
|
return assign_to(f,functor,function_obj_ref_tag());
|
||||||
|
}
|
||||||
|
|
||||||
public:
|
public:
|
||||||
|
vtable_base base;
|
||||||
invoker_type invoker;
|
invoker_type invoker;
|
||||||
};
|
};
|
||||||
} // end namespace function
|
} // end namespace function
|
||||||
@ -442,8 +650,7 @@ namespace boost {
|
|||||||
|
|
||||||
template<
|
template<
|
||||||
typename R BOOST_FUNCTION_COMMA
|
typename R BOOST_FUNCTION_COMMA
|
||||||
BOOST_FUNCTION_TEMPLATE_PARMS,
|
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||||
typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
|
|
||||||
>
|
>
|
||||||
class BOOST_FUNCTION_FUNCTION : public function_base
|
class BOOST_FUNCTION_FUNCTION : public function_base
|
||||||
|
|
||||||
@ -468,7 +675,7 @@ namespace boost {
|
|||||||
|
|
||||||
private:
|
private:
|
||||||
typedef boost::detail::function::BOOST_FUNCTION_VTABLE<
|
typedef boost::detail::function::BOOST_FUNCTION_VTABLE<
|
||||||
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
|
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
||||||
vtable_type;
|
vtable_type;
|
||||||
|
|
||||||
struct clear_type {};
|
struct clear_type {};
|
||||||
@ -493,7 +700,6 @@ namespace boost {
|
|||||||
BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
|
BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
|
||||||
BOOST_FUNCTION_ARG_TYPES
|
BOOST_FUNCTION_ARG_TYPES
|
||||||
|
|
||||||
typedef Allocator allocator_type;
|
|
||||||
typedef BOOST_FUNCTION_FUNCTION self_type;
|
typedef BOOST_FUNCTION_FUNCTION self_type;
|
||||||
|
|
||||||
BOOST_FUNCTION_FUNCTION() : function_base() { }
|
BOOST_FUNCTION_FUNCTION() : function_base() { }
|
||||||
@ -513,6 +719,19 @@ namespace boost {
|
|||||||
{
|
{
|
||||||
this->assign_to(f);
|
this->assign_to(f);
|
||||||
}
|
}
|
||||||
|
template<typename Functor,typename Allocator>
|
||||||
|
BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
|
||||||
|
#ifndef BOOST_NO_SFINAE
|
||||||
|
,typename enable_if_c<
|
||||||
|
(boost::type_traits::ice_not<
|
||||||
|
(is_integral<Functor>::value)>::value),
|
||||||
|
int>::type = 0
|
||||||
|
#endif // BOOST_NO_SFINAE
|
||||||
|
) :
|
||||||
|
function_base()
|
||||||
|
{
|
||||||
|
this->assign_to_a(f,a);
|
||||||
|
}
|
||||||
|
|
||||||
#ifndef BOOST_NO_SFINAE
|
#ifndef BOOST_NO_SFINAE
|
||||||
BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
|
BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
|
||||||
@ -570,6 +789,17 @@ namespace boost {
|
|||||||
}
|
}
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
template<typename Functor,typename Allocator>
|
||||||
|
void assign(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
|
||||||
|
{
|
||||||
|
this->clear();
|
||||||
|
try {
|
||||||
|
this->assign_to_a(f,a);
|
||||||
|
} catch (...) {
|
||||||
|
vtable = 0;
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
#ifndef BOOST_NO_SFINAE
|
#ifndef BOOST_NO_SFINAE
|
||||||
BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
|
BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
|
||||||
@ -607,16 +837,17 @@ namespace boost {
|
|||||||
if (&other == this)
|
if (&other == this)
|
||||||
return;
|
return;
|
||||||
|
|
||||||
BOOST_FUNCTION_FUNCTION tmp = *this;
|
BOOST_FUNCTION_FUNCTION tmp;
|
||||||
*this = other;
|
tmp.move_assign(*this);
|
||||||
other = tmp;
|
this->move_assign(other);
|
||||||
|
other.move_assign(tmp);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Clear out a target, if there is one
|
// Clear out a target, if there is one
|
||||||
void clear()
|
void clear()
|
||||||
{
|
{
|
||||||
if (vtable) {
|
if (vtable) {
|
||||||
static_cast<vtable_type*>(vtable)->clear(this->functor);
|
reinterpret_cast<vtable_type*>(vtable)->clear(this->functor);
|
||||||
vtable = 0;
|
vtable = 0;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -653,68 +884,127 @@ namespace boost {
|
|||||||
template<typename Functor>
|
template<typename Functor>
|
||||||
void assign_to(Functor f)
|
void assign_to(Functor f)
|
||||||
{
|
{
|
||||||
static vtable_type stored_vtable(f);
|
using detail::function::vtable_base;
|
||||||
if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
|
|
||||||
|
typedef typename detail::function::get_function_tag<Functor>::type tag;
|
||||||
|
typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
|
||||||
|
typedef typename get_invoker::
|
||||||
|
template apply<Functor, R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS>
|
||||||
|
handler_type;
|
||||||
|
|
||||||
|
typedef typename handler_type::invoker_type invoker_type;
|
||||||
|
typedef typename handler_type::manager_type manager_type;
|
||||||
|
|
||||||
|
// Note: it is extremely important that this initialization use
|
||||||
|
// static initialization. Otherwise, we will have a race
|
||||||
|
// condition here in multi-threaded code. See
|
||||||
|
// http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
|
||||||
|
static vtable_type stored_vtable =
|
||||||
|
{ { &manager_type::manage }, &invoker_type::invoke };
|
||||||
|
|
||||||
|
if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base;
|
||||||
else vtable = 0;
|
else vtable = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
template<typename Functor,typename Allocator>
|
||||||
|
void assign_to_a(Functor f,Allocator a)
|
||||||
|
{
|
||||||
|
using detail::function::vtable_base;
|
||||||
|
|
||||||
|
typedef typename detail::function::get_function_tag<Functor>::type tag;
|
||||||
|
typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
|
||||||
|
typedef typename get_invoker::
|
||||||
|
template apply_a<Functor, R BOOST_FUNCTION_COMMA
|
||||||
|
BOOST_FUNCTION_TEMPLATE_ARGS,
|
||||||
|
Allocator>
|
||||||
|
handler_type;
|
||||||
|
|
||||||
|
typedef typename handler_type::invoker_type invoker_type;
|
||||||
|
typedef typename handler_type::manager_type manager_type;
|
||||||
|
|
||||||
|
// Note: it is extremely important that this initialization use
|
||||||
|
// static initialization. Otherwise, we will have a race
|
||||||
|
// condition here in multi-threaded code. See
|
||||||
|
// http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
|
||||||
|
static vtable_type stored_vtable =
|
||||||
|
{ { &manager_type::manage }, &invoker_type::invoke };
|
||||||
|
|
||||||
|
if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable.base;
|
||||||
|
else vtable = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Moves the value from the specified argument to *this. If the argument
|
||||||
|
// has its function object allocated on the heap, move_assign will pass
|
||||||
|
// its buffer to *this, and set the argument's buffer pointer to NULL.
|
||||||
|
void move_assign(BOOST_FUNCTION_FUNCTION& f)
|
||||||
|
{
|
||||||
|
if (&f == this)
|
||||||
|
return;
|
||||||
|
|
||||||
|
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||||
|
try {
|
||||||
|
#endif
|
||||||
|
if (!f.empty()) {
|
||||||
|
this->vtable = f.vtable;
|
||||||
|
f.vtable->manager(f.functor, this->functor,
|
||||||
|
boost::detail::function::move_functor_tag);
|
||||||
|
f.vtable = 0;
|
||||||
|
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||||
|
} else {
|
||||||
|
clear();
|
||||||
|
}
|
||||||
|
} catch (...) {
|
||||||
|
vtable = 0;
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
typename Allocator>
|
|
||||||
inline void swap(BOOST_FUNCTION_FUNCTION<
|
inline void swap(BOOST_FUNCTION_FUNCTION<
|
||||||
R BOOST_FUNCTION_COMMA
|
R BOOST_FUNCTION_COMMA
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
Allocator
|
|
||||||
>& f1,
|
>& f1,
|
||||||
BOOST_FUNCTION_FUNCTION<
|
BOOST_FUNCTION_FUNCTION<
|
||||||
R BOOST_FUNCTION_COMMA
|
R BOOST_FUNCTION_COMMA
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS,
|
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
Allocator
|
|
||||||
>& f2)
|
>& f2)
|
||||||
{
|
{
|
||||||
f1.swap(f2);
|
f1.swap(f2);
|
||||||
}
|
}
|
||||||
|
|
||||||
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
typename Allocator>
|
|
||||||
typename BOOST_FUNCTION_FUNCTION<
|
typename BOOST_FUNCTION_FUNCTION<
|
||||||
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
|
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>::result_type
|
||||||
Allocator>::result_type
|
BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
||||||
BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
|
|
||||||
|
|
||||||
Allocator>
|
|
||||||
::operator()(BOOST_FUNCTION_PARMS) const
|
::operator()(BOOST_FUNCTION_PARMS) const
|
||||||
{
|
{
|
||||||
if (this->empty())
|
if (this->empty())
|
||||||
boost::throw_exception(bad_function_call());
|
boost::throw_exception(bad_function_call());
|
||||||
|
|
||||||
return static_cast<vtable_type*>(vtable)->invoker
|
return reinterpret_cast<const vtable_type*>(vtable)->invoker
|
||||||
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
|
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// Poison comparisons between boost::function objects of the same type.
|
// Poison comparisons between boost::function objects of the same type.
|
||||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
typename Allocator>
|
|
||||||
void operator==(const BOOST_FUNCTION_FUNCTION<
|
void operator==(const BOOST_FUNCTION_FUNCTION<
|
||||||
R BOOST_FUNCTION_COMMA
|
R BOOST_FUNCTION_COMMA
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
BOOST_FUNCTION_TEMPLATE_ARGS>&,
|
||||||
Allocator>&,
|
|
||||||
const BOOST_FUNCTION_FUNCTION<
|
const BOOST_FUNCTION_FUNCTION<
|
||||||
R BOOST_FUNCTION_COMMA
|
R BOOST_FUNCTION_COMMA
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
BOOST_FUNCTION_TEMPLATE_ARGS>&);
|
||||||
Allocator>&);
|
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
|
||||||
typename Allocator>
|
|
||||||
void operator!=(const BOOST_FUNCTION_FUNCTION<
|
void operator!=(const BOOST_FUNCTION_FUNCTION<
|
||||||
R BOOST_FUNCTION_COMMA
|
R BOOST_FUNCTION_COMMA
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
BOOST_FUNCTION_TEMPLATE_ARGS>&,
|
||||||
Allocator>&,
|
|
||||||
const BOOST_FUNCTION_FUNCTION<
|
const BOOST_FUNCTION_FUNCTION<
|
||||||
R BOOST_FUNCTION_COMMA
|
R BOOST_FUNCTION_COMMA
|
||||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
BOOST_FUNCTION_TEMPLATE_ARGS>& );
|
||||||
Allocator>&);
|
|
||||||
|
|
||||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||||
|
|
||||||
@ -725,20 +1015,16 @@ template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
template<typename R BOOST_FUNCTION_COMMA
|
template<typename R BOOST_FUNCTION_COMMA
|
||||||
BOOST_FUNCTION_TEMPLATE_PARMS,
|
BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||||
typename Allocator>
|
class function<BOOST_FUNCTION_PARTIAL_SPEC>
|
||||||
class function<BOOST_FUNCTION_PARTIAL_SPEC, Allocator>
|
: public BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
||||||
: public BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS
|
|
||||||
BOOST_FUNCTION_COMMA Allocator>
|
|
||||||
{
|
{
|
||||||
typedef BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS
|
typedef BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> base_type;
|
||||||
BOOST_FUNCTION_COMMA Allocator> base_type;
|
|
||||||
typedef function self_type;
|
typedef function self_type;
|
||||||
|
|
||||||
struct clear_type {};
|
struct clear_type {};
|
||||||
|
|
||||||
public:
|
public:
|
||||||
typedef typename base_type::allocator_type allocator_type;
|
|
||||||
|
|
||||||
function() : base_type() {}
|
function() : base_type() {}
|
||||||
|
|
||||||
@ -754,6 +1040,18 @@ public:
|
|||||||
base_type(f)
|
base_type(f)
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
template<typename Functor,typename Allocator>
|
||||||
|
function(Functor f, Allocator a
|
||||||
|
#ifndef BOOST_NO_SFINAE
|
||||||
|
,typename enable_if_c<
|
||||||
|
(boost::type_traits::ice_not<
|
||||||
|
(is_integral<Functor>::value)>::value),
|
||||||
|
int>::type = 0
|
||||||
|
#endif
|
||||||
|
) :
|
||||||
|
base_type(f,a)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
#ifndef BOOST_NO_SFINAE
|
#ifndef BOOST_NO_SFINAE
|
||||||
function(clear_type*) : base_type() {}
|
function(clear_type*) : base_type() {}
|
||||||
@ -806,7 +1104,6 @@ public:
|
|||||||
|
|
||||||
// Cleanup after ourselves...
|
// Cleanup after ourselves...
|
||||||
#undef BOOST_FUNCTION_VTABLE
|
#undef BOOST_FUNCTION_VTABLE
|
||||||
#undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
|
|
||||||
#undef BOOST_FUNCTION_COMMA
|
#undef BOOST_FUNCTION_COMMA
|
||||||
#undef BOOST_FUNCTION_FUNCTION
|
#undef BOOST_FUNCTION_FUNCTION
|
||||||
#undef BOOST_FUNCTION_FUNCTION_INVOKER
|
#undef BOOST_FUNCTION_FUNCTION_INVOKER
|
||||||
@ -815,10 +1112,13 @@ public:
|
|||||||
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
|
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
|
||||||
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
|
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
|
||||||
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
|
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
|
||||||
|
#undef BOOST_FUNCTION_MEMBER_INVOKER
|
||||||
|
#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
|
||||||
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
|
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
|
||||||
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
|
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
|
||||||
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
|
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
|
||||||
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
|
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
|
||||||
|
#undef BOOST_FUNCTION_GET_INVOKER
|
||||||
#undef BOOST_FUNCTION_TEMPLATE_PARMS
|
#undef BOOST_FUNCTION_TEMPLATE_PARMS
|
||||||
#undef BOOST_FUNCTION_TEMPLATE_ARGS
|
#undef BOOST_FUNCTION_TEMPLATE_ARGS
|
||||||
#undef BOOST_FUNCTION_PARMS
|
#undef BOOST_FUNCTION_PARMS
|
||||||
@ -828,3 +1128,7 @@ public:
|
|||||||
#undef BOOST_FUNCTION_ARG_TYPES
|
#undef BOOST_FUNCTION_ARG_TYPES
|
||||||
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
|
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||||
#undef BOOST_FUNCTION_RETURN
|
#undef BOOST_FUNCTION_RETURN
|
||||||
|
|
||||||
|
#if defined(BOOST_MSVC)
|
||||||
|
# pragma warning( pop )
|
||||||
|
#endif
|
||||||
|
45
include/boost/function/function_typeof.hpp
Normal file
45
include/boost/function/function_typeof.hpp
Normal file
@ -0,0 +1,45 @@
|
|||||||
|
// 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
|
@ -1,4 +1,11 @@
|
|||||||
<html>
|
<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>
|
<head>
|
||||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/function.html">
|
<meta http-equiv="refresh" content="0; URL=../../doc/html/function.html">
|
||||||
</head>
|
</head>
|
||||||
|
20
test/CMakeLists.txt
Normal file
20
test/CMakeLists.txt
Normal file
@ -0,0 +1,20 @@
|
|||||||
|
boost_test_run(lib_function_test function_test.cpp)
|
||||||
|
boost_test_run(function_n_test)
|
||||||
|
boost_test_run(allocator_test)
|
||||||
|
boost_test_run(stateless_test)
|
||||||
|
boost_test_run(lambda_test)
|
||||||
|
boost_test_compile_fail(function_test_fail1)
|
||||||
|
boost_test_compile_fail(function_test_fail2)
|
||||||
|
boost_test_compile(function_30)
|
||||||
|
boost_test_run(function_arith_cxx98)
|
||||||
|
boost_test_run(function_arith_portable)
|
||||||
|
boost_test_run(sum_avg_cxx98)
|
||||||
|
boost_test_run(sum_avg_portable)
|
||||||
|
boost_test_run(mem_fun_cxx98)
|
||||||
|
boost_test_run(mem_fun_portable)
|
||||||
|
boost_test_run(std_bind_cxx98)
|
||||||
|
boost_test_run(std_bind_portable)
|
||||||
|
boost_test_run(function_ref_cxx98)
|
||||||
|
boost_test_run(function_ref_portable)
|
||||||
|
boost_test_run(contains_test)
|
||||||
|
boost_test_run(contains2_test)
|
@ -58,6 +58,9 @@ import testing ;
|
|||||||
|
|
||||||
[ run libs/function/test/contains2_test.cpp : : : : ]
|
[ run libs/function/test/contains2_test.cpp : : : : ]
|
||||||
|
|
||||||
|
[ run libs/function/test/nothrow_swap.cpp : : : : ]
|
||||||
|
|
||||||
|
[ compile libs/function/test/function_typeof_test.cpp ]
|
||||||
;
|
;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -27,6 +27,14 @@ struct counting_allocator : public std::allocator<T>
|
|||||||
typedef counting_allocator<U> other;
|
typedef counting_allocator<U> other;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
counting_allocator()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename U>
|
||||||
|
counting_allocator( counting_allocator<U> )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
T* allocate(std::size_t n)
|
T* allocate(std::size_t n)
|
||||||
{
|
{
|
||||||
@ -41,20 +49,27 @@ struct counting_allocator : public std::allocator<T>
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
struct plus_int
|
struct enable_small_object_optimization
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
struct disable_small_object_optimization
|
||||||
|
{
|
||||||
|
int unused_state_data[32];
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename base>
|
||||||
|
struct plus_int: base
|
||||||
{
|
{
|
||||||
int operator()(int x, int y) const { return x + y; }
|
int operator()(int x, int y) const { return x + y; }
|
||||||
|
|
||||||
int unused_state_data[32];
|
|
||||||
};
|
};
|
||||||
|
|
||||||
static int do_minus(int x, int y) { return x-y; }
|
static int do_minus(int x, int y) { return x-y; }
|
||||||
|
|
||||||
struct DoNothing
|
template <typename base>
|
||||||
|
struct DoNothing: base
|
||||||
{
|
{
|
||||||
void operator()() const {}
|
void operator()() const {}
|
||||||
|
|
||||||
int unused_state_data[32];
|
|
||||||
};
|
};
|
||||||
|
|
||||||
static void do_nothing() {}
|
static void do_nothing() {}
|
||||||
@ -62,33 +77,57 @@ static void do_nothing() {}
|
|||||||
int
|
int
|
||||||
test_main(int, char*[])
|
test_main(int, char*[])
|
||||||
{
|
{
|
||||||
function2<int, int, int, counting_allocator<int> > f;
|
function2<int, int, int> f;
|
||||||
f = plus_int();
|
f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
|
||||||
f.clear();
|
f.clear();
|
||||||
BOOST_CHECK(alloc_count == 1);
|
BOOST_CHECK(alloc_count == 1);
|
||||||
BOOST_CHECK(dealloc_count == 1);
|
BOOST_CHECK(dealloc_count == 1);
|
||||||
|
|
||||||
alloc_count = 0;
|
alloc_count = 0;
|
||||||
dealloc_count = 0;
|
dealloc_count = 0;
|
||||||
f = &do_minus;
|
f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||||
f.clear();
|
f.clear();
|
||||||
BOOST_CHECK(alloc_count == 0);
|
BOOST_CHECK(alloc_count == 0);
|
||||||
BOOST_CHECK(dealloc_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();
|
||||||
|
|
||||||
function0<void, counting_allocator<int> > fv;
|
|
||||||
alloc_count = 0;
|
alloc_count = 0;
|
||||||
dealloc_count = 0;
|
dealloc_count = 0;
|
||||||
fv = DoNothing();
|
f.assign( &do_minus, counting_allocator<int>() );
|
||||||
|
f.clear();
|
||||||
|
BOOST_CHECK(alloc_count == 0);
|
||||||
|
BOOST_CHECK(dealloc_count == 0);
|
||||||
|
f.assign( &do_minus, std::allocator<int>() );
|
||||||
|
f.clear();
|
||||||
|
|
||||||
|
function0<void> fv;
|
||||||
|
alloc_count = 0;
|
||||||
|
dealloc_count = 0;
|
||||||
|
fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
|
||||||
fv.clear();
|
fv.clear();
|
||||||
BOOST_CHECK(alloc_count == 1);
|
BOOST_CHECK(alloc_count == 1);
|
||||||
BOOST_CHECK(dealloc_count == 1);
|
BOOST_CHECK(dealloc_count == 1);
|
||||||
|
|
||||||
alloc_count = 0;
|
alloc_count = 0;
|
||||||
dealloc_count = 0;
|
dealloc_count = 0;
|
||||||
fv = &do_nothing;
|
fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||||
fv.clear();
|
fv.clear();
|
||||||
BOOST_CHECK(alloc_count == 0);
|
BOOST_CHECK(alloc_count == 0);
|
||||||
BOOST_CHECK(dealloc_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.clear();
|
||||||
|
BOOST_CHECK(alloc_count == 0);
|
||||||
|
BOOST_CHECK(dealloc_count == 0);
|
||||||
|
fv.assign( &do_nothing, std::allocator<int>() );
|
||||||
|
fv.clear();
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -88,6 +88,15 @@ static void target_test()
|
|||||||
BOOST_CHECK(!f.target<int (*)()>());
|
BOOST_CHECK(!f.target<int (*)()>());
|
||||||
BOOST_CHECK(f.target<Seventeen>());
|
BOOST_CHECK(f.target<Seventeen>());
|
||||||
BOOST_CHECK(f.target<Seventeen>() == &this_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()
|
static void equal_test()
|
||||||
|
@ -636,6 +636,54 @@ 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* [])
|
int test_main(int, char* [])
|
||||||
{
|
{
|
||||||
test_zero_args();
|
test_zero_args();
|
||||||
@ -644,5 +692,6 @@ int test_main(int, char* [])
|
|||||||
test_emptiness();
|
test_emptiness();
|
||||||
test_member_functions();
|
test_member_functions();
|
||||||
test_ref();
|
test_ref();
|
||||||
|
test_construct_destroy_count();
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
18
test/function_typeof_test.cpp
Normal file
18
test/function_typeof_test.cpp
Normal file
@ -0,0 +1,18 @@
|
|||||||
|
// 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));
|
||||||
|
}
|
60
test/nothrow_swap.cpp
Normal file
60
test/nothrow_swap.cpp
Normal file
@ -0,0 +1,60 @@
|
|||||||
|
// 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;
|
||||||
|
}
|
Reference in New Issue
Block a user