mirror of
https://github.com/boostorg/function.git
synced 2025-06-26 20:41:32 +02:00
Compare commits
1 Commits
svn-branch
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| cded2c28f5 |
@ -1,10 +0,0 @@
|
||||
# Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
project boost/doc ;
|
||||
import boostbook : boostbook ;
|
||||
|
||||
boostbook function-doc : function.xml ;
|
||||
|
||||
163
doc/faq.xml
163
doc/faq.xml
@ -1,163 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section id="function.faq" last-revision="$Date$">
|
||||
<title>Frequently Asked Questions</title>
|
||||
|
||||
<qandaset>
|
||||
<qandaentry>
|
||||
<question><para>Why can't I compare
|
||||
<classname>boost::function</classname> objects with
|
||||
<code>operator==</code> or
|
||||
<code>operator!=</code>?</para></question>
|
||||
|
||||
<answer>
|
||||
<para>Comparison between <classname>boost::function</classname>
|
||||
objects cannot be implemented "well", and therefore will not be
|
||||
implemented. The typical semantics requested for <code>f ==
|
||||
g</code> given <classname>boost::function</classname> objects
|
||||
<code>f</code> and <code>g</code> are:</para>
|
||||
<itemizedlist>
|
||||
<listitem><simpara>If <code>f</code> and <code>g</code>
|
||||
store function objects of the same type, use that type's
|
||||
<code>operator==</code> to compare
|
||||
them.</simpara></listitem>
|
||||
|
||||
<listitem><simpara>If <code>f</code> and <code>g</code>
|
||||
store function objects of different types, return
|
||||
<code>false</code>.</simpara></listitem>
|
||||
</itemizedlist>
|
||||
<para>The problem occurs when the type of the function objects
|
||||
stored by both <code>f</code> and <code>g</code> doesn't have an
|
||||
<code>operator==</code>: we would like the expression <code>f ==
|
||||
g</code> to fail to compile, as occurs with, e.g., the standard
|
||||
containers. However, this is not implementable for
|
||||
<classname>boost::function</classname> because it necessarily
|
||||
"erases" some type information after it has been assigned a
|
||||
function object, so it cannot try to call
|
||||
<code>operator==</code> later: it must either find a way to call
|
||||
<code>operator==</code> now, or it will never be able to call it
|
||||
later. Note, for instance, what happens if you try to put a
|
||||
<code>float</code> value into a
|
||||
<classname>boost::function</classname> object: you will get an
|
||||
error at the assignment operator or constructor, not in
|
||||
<code>operator()</code>, because the function-call expression
|
||||
must be bound in the constructor or assignment operator.</para>
|
||||
|
||||
<para>The most promising approach is to find a method of
|
||||
determining if <code>operator==</code> can be called for a
|
||||
particular type, and then supporting it only when it is
|
||||
available; in other situations, an exception would be
|
||||
thrown. However, to date there is no known way to detect if an
|
||||
arbitrary operator expression <code>f == g</code> is suitably
|
||||
defined. The best solution known has the following undesirable
|
||||
qualities:</para>
|
||||
|
||||
<orderedlist>
|
||||
<listitem><simpara>Fails at compile-time for objects where
|
||||
<code>operator==</code> is not accessible (e.g., because it is
|
||||
<code>private</code>).</simpara></listitem>
|
||||
|
||||
<listitem><simpara>Fails at compile-time if calling
|
||||
<code>operator==</code> is ambiguous.</simpara></listitem>
|
||||
|
||||
<listitem><simpara>Appears to be correct if the
|
||||
<code>operator==</code> declaration is correct, even though
|
||||
<code>operator==</code> may not compile.</simpara></listitem>
|
||||
</orderedlist>
|
||||
|
||||
<para>All of these problems translate into failures in the
|
||||
<classname>boost::function</classname> constructors or
|
||||
assignment operator, <emphasis>even if the user never invokes
|
||||
operator==</emphasis>. We can't do that to users.</para>
|
||||
|
||||
<para>The other option is to place the burden on users that want
|
||||
to use <code>operator==</code>, e.g., by providing an
|
||||
<code>is_equality_comparable</code> trait they may
|
||||
specialize. This is a workable solution, but is dangerous in
|
||||
practice, because forgetting to specialize the trait will result
|
||||
in unexpected exceptions being thrown from
|
||||
<classname>boost::function</classname>'s
|
||||
<code>operator==</code>. This essentially negates the usefulness
|
||||
of <code>operator==</code> in the context in which it is most
|
||||
desired: multitarget callbacks. The
|
||||
<libraryname>Signals</libraryname> library has a way around
|
||||
this.</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
|
||||
<qandaentry>
|
||||
<question><para>I see void pointers; is this [mess] type safe?</para></question>
|
||||
<answer>
|
||||
<para>Yes, <computeroutput>boost::function</computeroutput> is type
|
||||
safe even though it uses void pointers and pointers to functions
|
||||
returning void and taking no arguments. Essentially, all type
|
||||
information is encoded in the functions that manage and invoke
|
||||
function pointers and function objects. Only these functions are
|
||||
instantiated with the exact type that is pointed to by the void
|
||||
pointer or pointer to void function. The reason that both are required
|
||||
is that one may cast between void pointers and object pointers safely
|
||||
or between different types of function pointers (provided you don't
|
||||
invoke a function pointer with the wrong type). </para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
|
||||
<qandaentry>
|
||||
<question><para>Why are there workarounds for void returns? C++ allows them!</para></question>
|
||||
<answer><para>Void returns are permitted by the C++ standard, as in this code snippet:
|
||||
<programlisting>void f();
|
||||
void g() { return f(); }</programlisting>
|
||||
</para>
|
||||
|
||||
<para> This is a valid usage of <computeroutput>boost::function</computeroutput> because void returns are not used. With void returns, we would attempting to compile ill-formed code similar to:
|
||||
<programlisting>int f();
|
||||
void g() { return f(); }</programlisting>
|
||||
</para>
|
||||
|
||||
<para> In essence, not using void returns allows
|
||||
<computeroutput>boost::function</computeroutput> to swallow a return value. This is
|
||||
consistent with allowing the user to assign and invoke functions and
|
||||
function objects with parameters that don't exactly match.</para>
|
||||
|
||||
</answer>
|
||||
</qandaentry>
|
||||
|
||||
<qandaentry>
|
||||
<question><para>Why (function) cloning?</para></question>
|
||||
<answer>
|
||||
<para>In November and December of 2000, the issue of cloning
|
||||
vs. reference counting was debated at length and it was decided
|
||||
that cloning gave more predictable semantics. I won't rehash the
|
||||
discussion here, but if it cloning is incorrect for a particular
|
||||
application a reference-counting allocator could be used.</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
|
||||
<qandaentry>
|
||||
<question><para>How much overhead does a call through <code><classname>boost::function</classname></code> incur?</para></question>
|
||||
<answer>
|
||||
<para>The cost of <code>boost::function</code> can be reasonably
|
||||
consistently measured at around 20ns +/- 10 ns on a modern >2GHz
|
||||
platform versus directly inlining the code.</para>
|
||||
|
||||
<para>However, the performance of your application may benefit
|
||||
from or be disadvantaged by <code>boost::function</code>
|
||||
depending on how your C++ optimiser optimises. Similar to a
|
||||
standard function pointer, differences of order of 10% have been
|
||||
noted to the benefit or disadvantage of using
|
||||
<code>boost::function</code> to call a function that contains a
|
||||
tight loop depending on your compilation circumstances.</para>
|
||||
|
||||
<para>[Answer provided by Matt Hurd. See <ulink url="http://article.gmane.org/gmane.comp.lib.boost.devel/33278"/>]</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
</qandaset>
|
||||
|
||||
</section>
|
||||
@ -1,61 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<library name="Function" dirname="function" id="function"
|
||||
last-revision="$Date$"
|
||||
xmlns:xi="http://www.w3.org/2001/XInclude">
|
||||
<libraryinfo>
|
||||
<author>
|
||||
<firstname>Douglas</firstname>
|
||||
<surname>Gregor</surname>
|
||||
<email>dgregor -at- cs.indiana.edu</email>
|
||||
</author>
|
||||
|
||||
<copyright>
|
||||
<year>2001</year>
|
||||
<year>2002</year>
|
||||
<year>2003</year>
|
||||
<year>2004</year>
|
||||
<holder>Douglas Gregor</holder>
|
||||
</copyright>
|
||||
|
||||
<legalnotice>
|
||||
<para>Use, modification and distribution is subject to the Boost
|
||||
Software License, Version 1.0. (See accompanying file
|
||||
<filename>LICENSE_1_0.txt</filename> or copy at <ulink
|
||||
url="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</ulink>)</para>
|
||||
</legalnotice>
|
||||
|
||||
<librarypurpose>Function object wrappers for deferred calls or callbacks</librarypurpose>
|
||||
<librarycategory name="category:higher-order"/>
|
||||
</libraryinfo>
|
||||
|
||||
<title>Boost.Function</title>
|
||||
|
||||
<section id="function.intro">
|
||||
<title>Introduction</title>
|
||||
<para>The Boost.Function library contains a family of class templates
|
||||
that are function object wrappers. The notion is similar to a
|
||||
generalized callback. It shares features with function pointers in
|
||||
that both define a call interface (e.g., a function taking two integer
|
||||
arguments and returning a floating-point value) through which some
|
||||
implementation can be called, and the implementation that is invoked
|
||||
may change throughout the course of the program.</para>
|
||||
|
||||
<para> Generally, any place in which a function pointer would be used
|
||||
to defer a call or make a callback, Boost.Function can be used instead
|
||||
to allow the user greater flexibility in the implementation of the
|
||||
target. Targets can be any 'compatible' function object (or function
|
||||
pointer), meaning that the arguments to the interface designated by
|
||||
Boost.Function can be converted to the arguments of the target
|
||||
function object.</para>
|
||||
</section>
|
||||
|
||||
<xi:include href="history.xml"/>
|
||||
<xi:include href="tutorial.xml"/>
|
||||
<xi:include href="reference.xml"/>
|
||||
<xi:include href="faq.xml"/>
|
||||
<xi:include href="misc.xml"/>
|
||||
<xi:include href="tests.xml"/>
|
||||
|
||||
</library>
|
||||
117
doc/history.xml
117
doc/history.xml
@ -1,117 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section id="function.history" last-revision="$Date$">
|
||||
<title>History & Compatibility Notes</title>
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
|
||||
<listitem><para><bold>Version 1.36.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Boost.Function now implements allocator support
|
||||
in the same way that is is provided in C++0x, based on C++
|
||||
committee
|
||||
proposal <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2308.html">N2308</ulink>. This
|
||||
change removes the <computeroutput>Allocator</computeroutput>
|
||||
template parameter of <classname>boost::function</classname> in
|
||||
favor of a constructor that takes an argument. While this is a
|
||||
backward-incompatible change, it is likely to affect only a few
|
||||
users. This change to Function was contributed by Emil
|
||||
Dotchevski, which also authored the corresponding C++ committee
|
||||
proposal.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.34.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Boost.Function now implements a small buffer optimization, which can drastically improve the performance when copying or construction Boost.Function objects storing small function objects. For instance, <code>bind(&X:foo, &x, _1, _2)</code> requires no heap allocation when placed into a Boost.Function object. Note that some exception-safety guarantees have changed: assignment provides the basic exception guarantee and <code>swap()</code> may throw.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.30.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>All features deprecated in version 1.29.0 have
|
||||
been removed from Boost.Function.</para></listitem>
|
||||
|
||||
<listitem><para><code><classname>boost::function</classname></code>
|
||||
and <code><classname>boost::functionN</classname></code> objects
|
||||
can be assigned to 0 (semantically equivalent to calling
|
||||
<code><methodname
|
||||
alt="boost::function::clear">clear</methodname>()</code>) and
|
||||
compared against 0 (semantically equivalent to calling
|
||||
<code><methodname
|
||||
alt="boost::function::empty">empty</methodname>()</code>).</para></listitem>
|
||||
|
||||
<listitem><para>The Boost.Function code is now generated
|
||||
entirely by the <libraryname>Preprocessor</libraryname> library,
|
||||
so it is now possible to generate
|
||||
<code><classname>boost::function</classname></code> and
|
||||
<code><classname>boost::functionN</classname></code> class
|
||||
templates for any number of arguments.</para></listitem>
|
||||
|
||||
<listitem><para>The
|
||||
<classname>boost::bad_function_call</classname> exception class
|
||||
was introduced.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.29.0</bold>:
|
||||
Boost.Function has been partially redesigned to minimize the
|
||||
interface and make it cleaner. Several seldom- or never-used
|
||||
features of the older Boost.Function have been deprecated and will
|
||||
be removed in the near future. Here is a list of features that have
|
||||
been deprecated, the likely impact of the deprecations, and how to
|
||||
adjust your code:
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>The <computeroutput>boost::function</computeroutput> class template syntax has
|
||||
changed. The old syntax, e.g., <computeroutput>boost::function<int, float,
|
||||
double, std::string></computeroutput>, has been changed to a more natural
|
||||
syntax <computeroutput>boost::function<int (float, double,
|
||||
std::string)></computeroutput>, where all return and argument types are
|
||||
encoded in a single function type parameter. Any other template
|
||||
parameters (e.g., the <computeroutput>Allocator</computeroutput>) follow this single
|
||||
parameter.</para>
|
||||
|
||||
<para> The resolution to this change depends on the
|
||||
abilities of your compiler: if your compiler supports template
|
||||
partial specialization and can parse function types (most do), modify
|
||||
your code to use the newer
|
||||
syntax (preferable) or directly use one of the
|
||||
<computeroutput>functionN</computeroutput> classes whose syntax has not
|
||||
changed. If your compiler does not support template partial
|
||||
specialization or function types, you must take the latter option and
|
||||
use the numbered Boost.Function classes. This option merely requires
|
||||
changing types such as <computeroutput>boost::function<void, int, int></computeroutput>
|
||||
to <computeroutput>boost::function2<void, int, int></computeroutput> (adding the number of
|
||||
function arguments to the end of the class name).</para>
|
||||
|
||||
<para> Support for the old syntax with the
|
||||
<computeroutput>boost::function</computeroutput> class template will persist for a short
|
||||
while, but will eventually be removed so that we can provide better
|
||||
error messages and link compatibility. </para></listitem>
|
||||
|
||||
<listitem><para>The invocation
|
||||
policy template parameter (<computeroutput>Policy</computeroutput>) has been deprecated
|
||||
and will be removed. There is no direct equivalent to this rarely
|
||||
used feature.</para></listitem>
|
||||
|
||||
<listitem><para>The mixin template parameter
|
||||
(<computeroutput>Mixin</computeroutput>) has been deprecated and will be removed. There
|
||||
is not direct equivalent to this rarely used feature.</para></listitem>
|
||||
|
||||
<listitem><para>The
|
||||
<computeroutput>set</computeroutput> methods have been deprecated and will be
|
||||
removed. Use the assignment operator instead.</para></listitem>
|
||||
</itemizedlist>
|
||||
</para>
|
||||
</listitem>
|
||||
</itemizedlist>
|
||||
</section>
|
||||
72
doc/misc.xml
72
doc/misc.xml
@ -1,72 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section id="function.misc" last-revision="$Date$">
|
||||
<title>Miscellaneous Notes</title>
|
||||
|
||||
<section>
|
||||
<title>Boost.Function vs. Function Pointers</title>
|
||||
<para>Boost.Function has several advantages over function pointers, namely:
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Boost.Function allows arbitrary compatible function objects to be targets (instead of requiring an exact function signature).</para></listitem>
|
||||
<listitem><para>Boost.Function may be used with argument-binding and other function object construction libraries.</para></listitem>
|
||||
<listitem><para>Boost.Function has predictible behavior when an empty function object is called. </para></listitem>
|
||||
</itemizedlist></para>
|
||||
|
||||
<para> And, of course, function pointers have several advantages over Boost.Function:
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para> Function pointers are smaller (the size of one pointer instead of four or more) </para></listitem>
|
||||
<listitem><para> Function pointers are faster (Boost.Function may require two calls through function pointers) </para></listitem>
|
||||
<listitem><para> Function pointers are backward-compatible with C libraries.</para></listitem>
|
||||
<listitem><para> More readable error messages. </para></listitem>
|
||||
</itemizedlist>
|
||||
</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Performance</title>
|
||||
|
||||
<section>
|
||||
<title>Function object wrapper size</title>
|
||||
<para> Function object wrappers will be the size of a struct containing a member function pointer and two data pointers. The actual size can vary significantly depending on the underlying platform; on 32-bit Mac OS X with GCC, this amounts to 16 bytes, while it is 32 bytes Windows with Visual C++. Additionally, the function object target may be allocated on the heap, if it cannot be placed into the small-object buffer in the <code>boost::function</code> object.</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Copying efficiency</title>
|
||||
<para> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <computeroutput>ref</computeroutput>) if the cost of this cloning becomes prohibitive. Small function objects can be stored within the <code>boost::function</code> object itself, improving copying efficiency.</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Invocation efficiency</title>
|
||||
<para> With a properly inlining compiler, an invocation of a function object requires one call through a function pointer. If the call is to a free function pointer, an additional call must be made to that function pointer (unless the compiler has very powerful interprocedural analysis).</para>
|
||||
</section>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Combatting virtual function "bloat"</title>
|
||||
<para> The use of virtual functions tends to cause 'code bloat' on many compilers. When a class contains a virtual function, it is necessary to emit an additional function that classifies the type of the object. It has been our experience that these auxiliary functions increase the size of the executable significantly when many <computeroutput>boost::function</computeroutput> objects are used. </para>
|
||||
|
||||
<para> In Boost.Function, an alternative but equivalent approach was taken using free functions instead of virtual functions. The Boost.Function object essentially holds two pointers to make a valid target call: a void pointer to the function object it contains and a void pointer to an "invoker" that can call the function object, given the function pointer. This invoker function performs the argument and return value conversions Boost.Function provides. A third pointer points to a free function called the "manager", which handles the cloning and destruction of function objects. The scheme is typesafe because the only functions that actually handle the function object, the invoker and the manager, are instantiated given the type of the function object, so they can safely cast the incoming void pointer (the function object pointer) to the appropriate type.</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Acknowledgements</title>
|
||||
|
||||
<para> Many people were involved in the construction of this
|
||||
library. William Kempf, Jesse Jones and Karl Nelson were all
|
||||
extremely helpful in isolating an interface and scope for the
|
||||
library. John Maddock managed the formal review, and many
|
||||
reviewers gave excellent comments on interface, implementation,
|
||||
and documentation. Peter Dimov led us to the function
|
||||
declarator-based syntax.</para>
|
||||
</section>
|
||||
</section>
|
||||
@ -1,938 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
|
||||
<library-reference id="function.reference" last-revision="$Date$">
|
||||
|
||||
<section id="function.definitions">
|
||||
<title>Definitions</title>
|
||||
<para>
|
||||
<itemizedlist>
|
||||
<listitem>
|
||||
<para>A function object <computeroutput>f</computeroutput> is
|
||||
<emphasis>compatible</emphasis> if for the given set of argument
|
||||
types <computeroutput>Arg1</computeroutput>,
|
||||
<computeroutput>Arg2</computeroutput>, ...,
|
||||
<computeroutput>ArgN</computeroutput> and a
|
||||
return type <computeroutput>ResultType</computeroutput>, the
|
||||
appropriate following function is well-formed:
|
||||
<programlisting>
|
||||
<emphasis>// if ResultType is not <emphasis role="bold">void</emphasis></emphasis>
|
||||
ResultType foo(Arg1 arg1, Arg2 arg2, ..., Arg<emphasis>N</emphasis> arg<emphasis>N</emphasis>)
|
||||
{
|
||||
<emphasis role="bold">return</emphasis> f(arg1, arg2, ..., arg<emphasis>N</emphasis>);
|
||||
}
|
||||
|
||||
<emphasis>// if ResultType is <emphasis role="bold">void</emphasis></emphasis>
|
||||
ResultType foo(Arg1 arg1, Arg2 arg2, ..., Arg<emphasis>N</emphasis> arg<emphasis>N</emphasis>)
|
||||
{
|
||||
f(arg1, arg2, ..., arg<emphasis>N</emphasis>);
|
||||
}
|
||||
</programlisting></para>
|
||||
|
||||
<para> A special provision is made for pointers to member
|
||||
functions. Though they are not function objects, Boost.Function
|
||||
will adapt them internally to function objects. This requires
|
||||
that a pointer to member function of the form <code>R
|
||||
(X::*mf)(Arg1, Arg2, ..., ArgN)
|
||||
cv-quals</code> be adapted to a
|
||||
function object with the following function call operator
|
||||
overloads:
|
||||
<programlisting>
|
||||
<emphasis role="bold">template</emphasis><<emphasis role="bold">typename P</emphasis>>
|
||||
R <emphasis role="bold">operator</emphasis>()(<emphasis>cv-quals</emphasis> P& x, Arg1 arg1, Arg2 arg2, ..., Arg<emphasis>N</emphasis> arg<emphasis>N</emphasis>) <emphasis role="bold">const</emphasis>
|
||||
{
|
||||
<emphasis role="bold">return</emphasis> (*x).*mf(arg1, arg2, ..., arg<emphasis>N</emphasis>);
|
||||
}
|
||||
</programlisting>
|
||||
</para>
|
||||
</listitem>
|
||||
<listitem>
|
||||
<para>A function object <code>f</code> of
|
||||
type <code>F</code> is
|
||||
<emphasis>stateless</emphasis> if it is a function pointer or if
|
||||
<code><classname>boost::is_stateless</classname><T></code>
|
||||
is true. The construction of or copy to a Boost.Function object
|
||||
from a stateless function object will not cause exceptions to be
|
||||
thrown and will not allocate any storage.
|
||||
</para>
|
||||
</listitem>
|
||||
</itemizedlist>
|
||||
</para>
|
||||
</section>
|
||||
|
||||
<header name="boost/function.hpp">
|
||||
<namespace name="boost">
|
||||
<class name="bad_function_call">
|
||||
<inherit access="public"><classname>std::runtime_error</classname></inherit>
|
||||
<purpose>An exception type thrown when an instance of a <code>function</code> object is empty when invoked.</purpose>
|
||||
<constructor>
|
||||
<effects><simpara>Constructs a <code><classname>bad_function_call</classname></code> exception object.</simpara></effects>
|
||||
</constructor>
|
||||
</class>
|
||||
|
||||
<class name="function_base">
|
||||
<purpose>The common base class for all Boost.Function
|
||||
objects. Objects of type function_base may not be created
|
||||
directly.</purpose>
|
||||
|
||||
<method-group name="capacity">
|
||||
<method name="empty" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="target access">
|
||||
<overloaded-method name="target">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>Functor*</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>const Functor*</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>If <code>this</code> stores a target of type
|
||||
<code>Functor</code>, returns the address of the
|
||||
target. Otherwise, returns the NULL
|
||||
pointer.</simpara></returns>
|
||||
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="contains" cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const Functor&</paramtype>
|
||||
</parameter>
|
||||
<returns><simpara><code>true</code> if <code>this-><methodname>target</methodname><Functor>()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this->target<Functor>()), f)</code></simpara></returns>
|
||||
|
||||
</method>
|
||||
|
||||
<method name="target_type" cv="const">
|
||||
<type>const std::type_info&</type>
|
||||
<returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-><methodname>empty</methodname>()</code>.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
</class>
|
||||
|
||||
<class name="functionN">
|
||||
<template>
|
||||
<template-type-parameter name="R"/>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
</template>
|
||||
|
||||
<inherit access="public"><classname>function_base</classname></inherit>
|
||||
|
||||
<purpose>A set of generalized function pointers that can be used for callbacks or wrapping function objects.</purpose>
|
||||
|
||||
<description>
|
||||
<para>Class template <classname>functionN</classname> is
|
||||
actually a family of related classes <classname
|
||||
alt="functionN">function0</classname>, <classname
|
||||
alt="functionN">function1</classname>, etc., up to some
|
||||
implementation-defined maximum. In this context, <code>N</code>
|
||||
refers to the number of parameters.</para>
|
||||
</description>
|
||||
|
||||
<typedef name="result_type"><type>R</type></typedef>
|
||||
<typedef name="argument_type">
|
||||
<type>T1</type><purpose>If N == 1</purpose>
|
||||
</typedef>
|
||||
<typedef name="first_argument_type">
|
||||
<type>T1</type>
|
||||
<purpose>If N == 2</purpose>
|
||||
</typedef>
|
||||
<typedef name="second_argument_type">
|
||||
<type>T2</type>
|
||||
<purpose>If N == 2</purpose>
|
||||
</typedef>
|
||||
<typedef name="arg1_type"><type>T1</type></typedef>
|
||||
<typedef name="arg2_type"><type>T2</type></typedef>
|
||||
<typedef name="..."><type/></typedef>
|
||||
<typedef name="argN_type"><type>TN</type></typedef>
|
||||
|
||||
<static-constant name="arity">
|
||||
<type>int</type>
|
||||
<default>N</default>
|
||||
</static-constant>
|
||||
|
||||
<struct name="sig">
|
||||
<template>
|
||||
<template-type-parameter name="Args"/>
|
||||
</template>
|
||||
|
||||
<purpose>
|
||||
<simpara><libraryname>Lambda</libraryname> library support</simpara>
|
||||
</purpose>
|
||||
|
||||
<typedef name="type"><type>result_type</type></typedef>
|
||||
</struct>
|
||||
|
||||
<constructor>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>functionN</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>Contains a copy of the <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
</template>
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
|
||||
<effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
|
||||
</constructor>
|
||||
|
||||
<destructor>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
|
||||
|
||||
</destructor>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>functionN</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
<method name="swap">
|
||||
<type>void</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname>&</paramtype></parameter>
|
||||
<effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
|
||||
</method>
|
||||
|
||||
<method name="clear">
|
||||
<type>void</type>
|
||||
<postconditions><simpara>this-><methodname>empty</methodname>()</simpara></postconditions>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="capacity">
|
||||
<method name="empty" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="conversion-operator" cv="const">
|
||||
<type>safe_bool</type>
|
||||
<returns><simpara>A <code>safe_bool</code> that evaluates <code>false</code> in a boolean context when <code>this-><methodname>empty</methodname>()</code>, and <code>true</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="operator!" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>this-><methodname>empty</methodname>()</code></simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="target access">
|
||||
<overloaded-method name="target">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>Functor*</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>const Functor*</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>If <code>this</code> stores a target of type
|
||||
<code>Functor</code>, returns the address of the
|
||||
target. Otherwise, returns the NULL
|
||||
pointer.</simpara></returns>
|
||||
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="contains" cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const Functor&</paramtype>
|
||||
</parameter>
|
||||
<returns><simpara><code>true</code> if <code>this-><methodname>target</methodname><Functor>()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this->target<Functor>()), f)</code></simpara></returns>
|
||||
|
||||
</method>
|
||||
|
||||
<method name="target_type" cv="const">
|
||||
<type>const std::type_info&</type>
|
||||
<returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-><methodname>empty</methodname>()</code>.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
</method-group>
|
||||
|
||||
<method-group name="invocation">
|
||||
<method name="operator()" cv="const">
|
||||
<type>result_type</type>
|
||||
<parameter name="a1"><paramtype>arg1_type</paramtype></parameter>
|
||||
<parameter name="a2"><paramtype>arg2_type</paramtype></parameter>
|
||||
<parameter><paramtype>...</paramtype></parameter>
|
||||
<parameter name="aN"><paramtype>argN_type</paramtype></parameter>
|
||||
<effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
|
||||
<returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<free-function-group name="specialized algorithms">
|
||||
<function name="swap">
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype><classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
||||
</function>
|
||||
</free-function-group>
|
||||
|
||||
<free-function-group name="comparison operators">
|
||||
<overloaded-function name="operator==">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN>&</paramtype></parameter>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>True when <code>f</code> stores an object of
|
||||
type <code>Functor</code> and one of the following conditions applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() == g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and
|
||||
<code><functionname>function_equal</functionname>(*(f.target<Functor>()),
|
||||
g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>functionN</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>functionN</code>
|
||||
instances can be compared via <code>==</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator==</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
|
||||
<overloaded-function name="operator!=">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN>&</paramtype></parameter>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>True when <code>f</code> does not store an
|
||||
object of type <code>Functor</code> or it stores an object of
|
||||
type <code>Functor</code> and one of the following conditions
|
||||
applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() != g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>!<functionname>function_equal</functionname>(*(f.target<Functor>()), g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>functionN</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>functionN</code>
|
||||
instances can be compared via <code>!=</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator!=</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
|
||||
<class name="function">
|
||||
<template>
|
||||
<template-type-parameter name="Signature">
|
||||
<purpose>Function type R (T1, T2, ..., TN)</purpose>
|
||||
</template-type-parameter>
|
||||
</template>
|
||||
<inherit access="public"><classname>functionN</classname><R, T1, T2, ..., TN></inherit>
|
||||
|
||||
<purpose>A generalized function pointer that can be used for
|
||||
callbacks or wrapping function objects.</purpose>
|
||||
|
||||
<description>
|
||||
<para>Class template <classname>function</classname> is a thin
|
||||
wrapper around the numbered class templates <classname
|
||||
alt="functionN">function0</classname>, <classname
|
||||
alt="functionN">function1</classname>, etc. It accepts a
|
||||
function type with N arguments and will will derive from
|
||||
<classname>functionN</classname> instantiated with the arguments
|
||||
it receives.</para>
|
||||
|
||||
<para>The semantics of all operations in class template
|
||||
<classname>function</classname> are equivalent to that of the
|
||||
underlying <classname>functionN</classname> object, although
|
||||
additional member functions are required to allow proper copy
|
||||
construction and copy assignment of function objects.</para>
|
||||
</description>
|
||||
|
||||
<typedef name="result_type"><type>R</type></typedef>
|
||||
<typedef name="argument_type">
|
||||
<type>T1</type><purpose>If N == 1</purpose>
|
||||
</typedef>
|
||||
<typedef name="first_argument_type">
|
||||
<type>T1</type>
|
||||
<purpose>If N == 2</purpose>
|
||||
</typedef>
|
||||
<typedef name="second_argument_type">
|
||||
<type>T2</type>
|
||||
<purpose>If N == 2</purpose>
|
||||
</typedef>
|
||||
<typedef name="arg1_type"><type>T1</type></typedef>
|
||||
<typedef name="arg2_type"><type>T2</type></typedef>
|
||||
<typedef name="..."><type/></typedef>
|
||||
<typedef name="argN_type"><type>TN</type></typedef>
|
||||
|
||||
<static-constant name="arity">
|
||||
<type>int</type>
|
||||
<default>N</default>
|
||||
</static-constant>
|
||||
|
||||
<struct name="sig">
|
||||
<template>
|
||||
<template-type-parameter name="Args"/>
|
||||
</template>
|
||||
|
||||
<purpose>
|
||||
<simpara><libraryname>Lambda</libraryname> library support</simpara>
|
||||
</purpose>
|
||||
|
||||
<typedef name="type"><type>result_type</type></typedef>
|
||||
</struct>
|
||||
|
||||
<constructor>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>functionN</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>Contains a copy of the <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>Contains a copy of the <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
</template>
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
|
||||
<effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
|
||||
</constructor>
|
||||
|
||||
<destructor>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
|
||||
|
||||
</destructor>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
|
||||
<throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
<method name="swap">
|
||||
<type>void</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname>&</paramtype></parameter>
|
||||
<effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
|
||||
</method>
|
||||
|
||||
<method name="clear">
|
||||
<type>void</type>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="capacity">
|
||||
<method name="empty" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="conversion-operator" cv="const">
|
||||
<type>safe_bool</type>
|
||||
<returns><simpara>A <code>safe_bool</code> that evaluates <code>false</code> in a boolean context when <code>this-><methodname>empty</methodname>()</code>, and <code>true</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="operator!" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>this-><methodname>empty</methodname>()</code></simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="target access">
|
||||
<overloaded-method name="target">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>Functor*</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>const Functor*</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>If <code>this</code> stores a target of type
|
||||
<code>Functor</code>, returns the address of the
|
||||
target. Otherwise, returns the NULL
|
||||
pointer.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="contains" cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const Functor&</paramtype>
|
||||
</parameter>
|
||||
<returns><simpara><code>true</code> if <code>this-><methodname>target</methodname><Functor>()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this->target<Functor>()), f)</code></simpara></returns>
|
||||
|
||||
</method>
|
||||
|
||||
<method name="target_type" cv="const">
|
||||
<type>const std::type_info&</type>
|
||||
<returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-><methodname>empty</methodname>()</code>.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="invocation">
|
||||
<method name="operator()" cv="const">
|
||||
<type>result_type</type>
|
||||
<parameter name="a1"><paramtype>arg1_type</paramtype></parameter>
|
||||
<parameter name="a2"><paramtype>arg2_type</paramtype></parameter>
|
||||
<parameter><paramtype>...</paramtype></parameter>
|
||||
<parameter name="aN"><paramtype>argN_type</paramtype></parameter>
|
||||
<effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
|
||||
<returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<free-function-group name="specialized algorithms">
|
||||
<function name="swap">
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype><classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
||||
</function>
|
||||
</free-function-group>
|
||||
|
||||
<free-function-group name="comparison operators">
|
||||
<overloaded-function name="operator==">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2>&</paramtype></parameter>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>True when <code>f</code> stores an object of
|
||||
type <code>Functor</code> and one of the following conditions applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() == g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code><functionname>function_equals</functionname>(*(f.target<Functor>()), g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>function</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>function</code>
|
||||
instances can be compared via <code>==</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator==</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
|
||||
<overloaded-function name="operator!=">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2>&</paramtype></parameter>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>True when <code>f</code> does not store an
|
||||
object of type <code>Functor</code> or it stores an object of
|
||||
type <code>Functor</code> and one of the following conditions
|
||||
applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() != g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>!<functionname>function_equals</functionname>(*(f.target<Functor>()), g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>function</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>function</code>
|
||||
instances can be compared via <code>!=</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator!=</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
</namespace>
|
||||
</header>
|
||||
|
||||
<header name="boost/function_equal.hpp">
|
||||
<namespace name="boost">
|
||||
<function name="function_equal">
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
<template-type-parameter name="G"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const F&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="g">
|
||||
<paramtype>const G&</paramtype>
|
||||
</parameter>
|
||||
<purpose><simpara>Compare two function objects for equality.</simpara></purpose>
|
||||
<returns><simpara><code>f == g</code>.</simpara></returns>
|
||||
<throws><simpara>Only if <code>f == g</code> throws.</simpara></throws>
|
||||
</function>
|
||||
</namespace>
|
||||
</header>
|
||||
</library-reference>
|
||||
258
doc/tests.xml
258
doc/tests.xml
@ -1,258 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<testsuite id="function.testsuite" last-revision="$Date$">
|
||||
<run-test filename="function_test.cpp" name="lib_function_test">
|
||||
<purpose><para>Test the capabilities of the <classname>boost::function</classname> class template.</para></purpose>
|
||||
<if-fails><para>The <classname>boost::function</classname> class template may not be usable on your compiler. However, the library may still be usable via the <classname>boost::functionN</classname> class templates.</para></if-fails>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="function_n_test.cpp">
|
||||
<purpose><para>Test the capabilities of the <classname>boost::functionN</classname> class templates.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="allocator_test.cpp">
|
||||
<purpose><para>Test the use of custom allocators.</para></purpose>
|
||||
<if-fails><para>Allocators are ignored by the implementation.</para></if-fails>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="stateless_test.cpp">
|
||||
<purpose><para>Test the optimization of stateless function objects in the Boost.Function library.</para></purpose>
|
||||
<if-fails><para>The exception-safety and performance guarantees given for stateless function objects may not be met by the implementation.</para></if-fails>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="lambda_test.cpp">
|
||||
<purpose><para>Test the interaction between Boost.Function and Boost.Lambda.</para></purpose>
|
||||
<if-fails><para>Either Boost.Lambda does not work on the platform, or Boost.Function cannot safely be applied without the use of <functionname>boost::unlambda</functionname>.</para></if-fails>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="contains_test.cpp">
|
||||
<purpose><para>Test the operation of the
|
||||
<code><methodname>target</methodname></code> member function and the
|
||||
equality operators.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<compile-fail-test filename="function_test_fail1.cpp">
|
||||
<purpose><para>Test the (incorrect!) use of comparisons between Boost.Function function objects.</para></purpose>
|
||||
<if-fails><para>Intuitive (but incorrect!) code may compile and will give meaningless results.</para></if-fails>
|
||||
</compile-fail-test>
|
||||
|
||||
<compile-fail-test filename="function_test_fail2.cpp">
|
||||
<purpose><para>Test the use of an incompatible function object with Boost.Function</para></purpose>
|
||||
<if-fails><para>Incorrect code may compile (with potentially unexpected results).</para></if-fails>
|
||||
</compile-fail-test>
|
||||
|
||||
<compile-test filename="function_30.cpp">
|
||||
<purpose><para>Test the generation of a Boost.Function function object adaptor accepting 30 arguments.</para></purpose>
|
||||
<if-fails><para>The Boost.Function library may work for function object adaptors of up to 10 parameters, but will be unable to generate adaptors for an arbitrary number of parameters. Failure often indicates an error in the compiler's preprocessor.</para></if-fails>
|
||||
</compile-test>
|
||||
|
||||
<run-test filename="function_arith_cxx98.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
]]>
|
||||
|
||||
<snippet name="function.tutorial.mul_ints"/>
|
||||
<snippet name="function.tutorial.int_div"/>
|
||||
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.arith.cxx98"/>
|
||||
<snippet name="function.tutorial.use_int_div"/>
|
||||
<snippet name="function.tutorial.call_int_div"/>
|
||||
<snippet name="function.tutorial.check_empty"/>
|
||||
<snippet name="function.tutorial.clear"/>
|
||||
<snippet name="function.tutorial.use_mul_ints"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test the first tutorial example.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="function_arith_portable.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
]]>
|
||||
<snippet name="function.tutorial.mul_ints"/>
|
||||
<snippet name="function.tutorial.int_div"/>
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.arith.portable"/>
|
||||
<snippet name="function.tutorial.use_int_div"/>
|
||||
<snippet name="function.tutorial.call_int_div"/>
|
||||
<snippet name="function.tutorial.check_empty"/>
|
||||
<snippet name="function.tutorial.clear"/>
|
||||
<snippet name="function.tutorial.use_mul_ints"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test the first tutorial example.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="sum_avg_cxx98.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
]]>
|
||||
<snippet name="function.tutorial.sum_avg"/>
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.sum_avg_decl.cxx98"/>
|
||||
<snippet name="function.tutorial.use_sum_avg"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test the second tutorial example.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="sum_avg_portable.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
]]>
|
||||
<snippet name="function.tutorial.sum_avg"/>
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.sum_avg_decl.portable"/>
|
||||
<snippet name="function.tutorial.use_sum_avg"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test the second tutorial example.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="mem_fun_cxx98.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
]]>
|
||||
<snippet name="function.tutorial.X"/>
|
||||
int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.mem_fun.cxx98"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test member function example from tutorial.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="mem_fun_portable.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
]]>
|
||||
<snippet name="function.tutorial.X"/>
|
||||
int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.mem_fun.portable"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test member function example from tutorial.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="std_bind_cxx98.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
]]>
|
||||
<snippet name="function.tutorial.X"/>
|
||||
int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.std_bind.cxx98"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test standard binders example from tutorial.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="std_bind_portable.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
]]>
|
||||
<snippet name="function.tutorial.X"/>
|
||||
int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.std_bind.portable"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test standard binders example from tutorial.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="function_ref_cxx98.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
]]>
|
||||
|
||||
struct stateful_type { int operator()(int) const { return 0; } };
|
||||
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.ref.cxx98"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test <functionname>boost::ref</functionname> example from tutorial.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="function_ref_portable.cpp">
|
||||
<source>
|
||||
<![CDATA[
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
]]>
|
||||
|
||||
struct stateful_type { int operator()(int) const { return 0; } };
|
||||
|
||||
int main()
|
||||
{
|
||||
<snippet name="function.tutorial.ref.portable"/>
|
||||
|
||||
return 0;
|
||||
}
|
||||
</source>
|
||||
<purpose><para>Test <functionname>boost::ref</functionname> example from tutorial.</para></purpose>
|
||||
</run-test>
|
||||
</testsuite>
|
||||
364
doc/tutorial.xml
364
doc/tutorial.xml
@ -1,364 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section xmlns:xi="http://www.w3.org/2001/XInclude" id="function.tutorial"
|
||||
last-revision="$Date$">
|
||||
<title>Tutorial</title>
|
||||
|
||||
<using-namespace name="boost"/>
|
||||
|
||||
<para> Boost.Function has two syntactical forms: the preferred form
|
||||
and the portable form. The preferred form fits more closely with the
|
||||
C++ language and reduces the number of separate template parameters
|
||||
that need to be considered, often improving readability; however, the
|
||||
preferred form is not supported on all platforms due to compiler
|
||||
bugs. The compatible form will work on all compilers supported by
|
||||
Boost.Function. Consult the table below to determine which syntactic
|
||||
form to use for your compiler.
|
||||
|
||||
<informaltable>
|
||||
<tgroup cols="2" align="left">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>Preferred syntax</entry>
|
||||
<entry>Portable syntax</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
|
||||
<listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
|
||||
<listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
|
||||
<listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
|
||||
<listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
|
||||
<listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
|
||||
</itemizedlist>
|
||||
</entry>
|
||||
<entry>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara><emphasis>Any compiler supporting the preferred syntax</emphasis></simpara></listitem>
|
||||
<listitem><simpara>Microsoft Visual C++ 6.0, 7.0</simpara></listitem>
|
||||
<listitem><simpara>Borland C++ 5.5.1</simpara></listitem>
|
||||
<listitem><simpara>Sun WorkShop 6 update 2 C++ 5.3</simpara></listitem>
|
||||
<listitem><simpara>Metrowerks CodeWarrior 8.1</simpara></listitem>
|
||||
</itemizedlist>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
|
||||
</para>
|
||||
|
||||
<para> If your compiler does not appear in this list, please try the preferred syntax and report your results to the Boost list so that we can keep this table up-to-date.</para>
|
||||
|
||||
<using-class name="boost::function"/>
|
||||
|
||||
<section>
|
||||
<title>Basic Usage</title> <para> A function wrapper is defined simply
|
||||
by instantiating the <computeroutput>function</computeroutput> class
|
||||
template with the desired return type and argument types, formulated
|
||||
as a C++ function type. Any number of arguments may be supplied, up to
|
||||
some implementation-defined limit (10 is the default maximum). The
|
||||
following declares a function object wrapper
|
||||
<computeroutput>f</computeroutput> that takes two
|
||||
<computeroutput>int</computeroutput> parameters and returns a
|
||||
<computeroutput>float</computeroutput>:
|
||||
|
||||
<informaltable>
|
||||
<tgroup cols="2" align="left">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>Preferred syntax</entry>
|
||||
<entry>Portable syntax</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.arith.cxx98"><classname>boost::function</classname><float (int x, int y)> f;</programlisting>
|
||||
</entry>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.arith.portable"><classname alt="functionN">boost::function2</classname><float, int, int> f;</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
</para>
|
||||
|
||||
<para> By default, function object wrappers are empty, so we can create a
|
||||
function object to assign to <computeroutput>f</computeroutput>:
|
||||
|
||||
<programlisting name="function.tutorial.int_div">struct int_div {
|
||||
float operator()(int x, int y) const { return ((float)x)/y; };
|
||||
};</programlisting>
|
||||
<programlisting name="function.tutorial.use_int_div">f = int_div();</programlisting>
|
||||
</para>
|
||||
|
||||
<para> Now we can use <computeroutput>f</computeroutput> to execute
|
||||
the underlying function object
|
||||
<computeroutput>int_div</computeroutput>:
|
||||
|
||||
<programlisting name="function.tutorial.call_int_div">std::cout << f(5, 3) << std::endl;</programlisting>
|
||||
</para>
|
||||
|
||||
<para> We are free to assign any compatible function object to
|
||||
<computeroutput>f</computeroutput>. If
|
||||
<computeroutput>int_div</computeroutput> had been declared to take two
|
||||
<computeroutput>long</computeroutput> operands, the implicit
|
||||
conversions would have been applied to the arguments without any user
|
||||
interference. The only limit on the types of arguments is that they be
|
||||
CopyConstructible, so we can even use references and arrays:
|
||||
|
||||
<informaltable>
|
||||
<tgroup cols="1" align="left">
|
||||
<thead><row><entry>Preferred syntax</entry></row></thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.sum_avg_decl.cxx98"><classname>boost::function</classname><void (int values[], int n, int& sum, float& avg)> sum_avg;</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
<informaltable>
|
||||
<tgroup cols="1" align="left">
|
||||
<thead><row><entry>Portable syntax</entry></row></thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.sum_avg_decl.portable"><classname alt="functionN">boost::function4</classname><void, int*, int, int&, float&> sum_avg;</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
|
||||
<programlisting name="function.tutorial.sum_avg">void do_sum_avg(int values[], int n, int& sum, float& avg)
|
||||
{
|
||||
sum = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
sum += values[i];
|
||||
avg = (float)sum / n;
|
||||
}</programlisting>
|
||||
|
||||
|
||||
<programlisting name="function.tutorial.use_sum_avg">sum_avg = &do_sum_avg;</programlisting>
|
||||
</para>
|
||||
|
||||
<para> Invoking a function object wrapper that does not actually
|
||||
contain a function object is a precondition violation, much like
|
||||
trying to call through a null function pointer, and will throw a <classname>bad_function_call</classname> exception). We can check for an
|
||||
empty function object wrapper by using it in a boolean context (it evaluates <computeroutput>true</computeroutput> if the wrapper is not empty) or compare it against <computeroutput>0</computeroutput>. For instance:
|
||||
<programlisting name="function.tutorial.check_empty">if (f)
|
||||
std::cout << f(5, 3) << std::endl;
|
||||
else
|
||||
std::cout << "f has no target, so it is unsafe to call" << std::endl;</programlisting>
|
||||
</para>
|
||||
|
||||
<para> Alternatively,
|
||||
<computeroutput><methodname>empty</methodname>()</computeroutput>
|
||||
method will return whether or not the wrapper is empty. </para>
|
||||
|
||||
<para> Finally, we can clear out a function target by assigning it to <computeroutput>0</computeroutput> or by calling the <computeroutput><methodname>clear</methodname>()</computeroutput> member function, e.g.,
|
||||
<programlisting name="function.tutorial.clear">f = 0;</programlisting>
|
||||
</para>
|
||||
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Free functions</title>
|
||||
<para> Free function pointers can be considered singleton function objects with const function call operators, and can therefore be directly used with the function object wrappers:
|
||||
<programlisting name="function.tutorial.mul_ints">float mul_ints(int x, int y) { return ((float)x) * y; }</programlisting>
|
||||
<programlisting name="function.tutorial.use_mul_ints">f = &mul_ints;</programlisting>
|
||||
</para>
|
||||
|
||||
<para> Note that the <computeroutput>&</computeroutput> isn't really necessary unless you happen to be using Microsoft Visual C++ version 6. </para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Member functions</title>
|
||||
|
||||
<para> In many systems, callbacks often call to member functions of a
|
||||
particular object. This is often referred to as "argument binding",
|
||||
and is beyond the scope of Boost.Function. The use of member functions
|
||||
directly, however, is supported, so the following code is valid:
|
||||
|
||||
<programlisting name="function.tutorial.X">struct X {
|
||||
int foo(int);
|
||||
};</programlisting>
|
||||
|
||||
<informaltable>
|
||||
<tgroup cols="2" align="left">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>Preferred syntax</entry>
|
||||
<entry>Portable syntax</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.mem_fun.cxx98"><classname>boost::function</classname><int (X*, int)> f;
|
||||
|
||||
f = &X::foo;
|
||||
|
||||
X x;
|
||||
f(&x, 5);</programlisting>
|
||||
</entry>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.mem_fun.portable"><classname alt="functionN">boost::function2</classname><int, X*, int> f;
|
||||
|
||||
f = &X::foo;
|
||||
|
||||
X x;
|
||||
f(&x, 5);</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
</para>
|
||||
|
||||
<para> Several libraries exist that support argument binding. Three such libraries are summarized below:
|
||||
<itemizedlist>
|
||||
<listitem> <para><libraryname>Bind</libraryname>. This library allows binding of
|
||||
arguments for any function object. It is lightweight and very
|
||||
portable.</para></listitem>
|
||||
|
||||
<listitem> <para>The C++ Standard library. Using
|
||||
<computeroutput>std::bind1st</computeroutput> and
|
||||
<computeroutput>std::mem_fun</computeroutput> together one can bind
|
||||
the object of a pointer-to-member function for use with
|
||||
Boost.Function:
|
||||
|
||||
<informaltable>
|
||||
<tgroup cols="2" align="left">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>Preferred syntax</entry>
|
||||
<entry>Portable syntax</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.std_bind.cxx98"> <classname>boost::function</classname><int (int)> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
</entry>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.std_bind.portable"> <classname alt="functionN">boost::function1</classname><int, int> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
</para>
|
||||
</listitem>
|
||||
|
||||
<listitem><para>The <libraryname>Lambda</libraryname> library. This library provides a powerful composition mechanism to construct function objects that uses very natural C++ syntax. Lambda requires a compiler that is reasonably conformant to the C++ standard. </para></listitem>
|
||||
</itemizedlist>
|
||||
</para>
|
||||
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>References to Function Objects</title> <para> In some cases it is
|
||||
expensive (or semantically incorrect) to have Boost.Function clone a
|
||||
function object. In such cases, it is possible to request that
|
||||
Boost.Function keep only a reference to the actual function
|
||||
object. This is done using the <computeroutput>ref</computeroutput>
|
||||
and <computeroutput>cref</computeroutput> functions to wrap a
|
||||
reference to a function object:
|
||||
|
||||
<informaltable>
|
||||
<tgroup cols="2" align="left">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>Preferred syntax</entry>
|
||||
<entry>Portable syntax</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.ref.cxx98">stateful_type a_function_object;
|
||||
<classname>boost::function</classname><int (int)> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
|
||||
<classname>boost::function</classname><int (int)> f2(f);</programlisting>
|
||||
</entry>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.ref.portable">stateful_type a_function_object;
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f2(f);</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
</para>
|
||||
|
||||
<para> Here, <computeroutput>f</computeroutput> will not make a copy
|
||||
of <computeroutput>a_function_object</computeroutput>, nor will
|
||||
<computeroutput>f2</computeroutput> when it is targeted to
|
||||
<computeroutput>f</computeroutput>'s reference to
|
||||
<computeroutput>a_function_object</computeroutput>. Additionally, when
|
||||
using references to function objects, Boost.Function will not throw
|
||||
exceptions during assignment or construction.
|
||||
</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Comparing Boost.Function function objects</title>
|
||||
|
||||
<para>Function object wrappers can be compared via <code>==</code>
|
||||
or <code>!=</code> against any function object that can be stored
|
||||
within the wrapper. If the function object wrapper contains a
|
||||
function object of that type, it will be compared against the given
|
||||
function object (which must be either be
|
||||
<conceptname>EqualityComparable</conceptname> or have an overloaded <functionname>boost::function_equal</functionname>). For instance:</para>
|
||||
|
||||
<programlisting name="function.tutorial.compare">int compute_with_X(X*, int);
|
||||
|
||||
f = &X::foo;
|
||||
assert(f == &X::foo);
|
||||
assert(&compute_with_X != f);</programlisting>
|
||||
|
||||
<para>When comparing against an instance of
|
||||
<code><classname>reference_wrapper</classname></code>, the address
|
||||
of the object in the
|
||||
<code><classname>reference_wrapper</classname></code> is compared
|
||||
against the address of the object stored by the function object
|
||||
wrapper:</para>
|
||||
|
||||
<programlisting name="function.tutorial.compare-ref">a_stateful_object so1, so2;
|
||||
f = <functionname>boost::ref</functionname>(so1);
|
||||
assert(f == <functionname>boost::ref</functionname>(so1));
|
||||
assert(f == so1); <emphasis>// Only if a_stateful_object is <conceptname>EqualityComparable</conceptname></emphasis>
|
||||
assert(f != <functionname>boost::ref</functionname>(so2));</programlisting>
|
||||
|
||||
</section>
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,32 +0,0 @@
|
||||
// Boost.Function library examples
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/function.hpp>
|
||||
#include <functional>
|
||||
|
||||
struct X {
|
||||
X(int val) : value(val) {}
|
||||
|
||||
int foo(int x) { return x * value; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
boost::function<int (int)> f;
|
||||
X x(7);
|
||||
f = std::bind1st(std::mem_fun(&X::foo), &x);
|
||||
|
||||
std::cout << f(5) << std::endl; // Call x.foo(5)
|
||||
return 0;
|
||||
}
|
||||
@ -1,26 +0,0 @@
|
||||
// Boost.Function library examples
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
struct int_div {
|
||||
float operator()(int x, int y) const { return ((float)x)/y; };
|
||||
};
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
boost::function<float (int, int)> f;
|
||||
f = int_div();
|
||||
|
||||
std::cout << f(5, 3) << std::endl; // 1.66667
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,38 +0,0 @@
|
||||
// Boost.Function library examples
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
void do_sum_avg(int values[], int n, int& sum, float& avg)
|
||||
{
|
||||
sum = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
sum += values[i];
|
||||
avg = (float)sum / n;
|
||||
}
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
// The second parameter should be int[], but some compilers (e.g., GCC)
|
||||
// complain about this
|
||||
boost::function<void (int*, int, int&, float&)> sum_avg;
|
||||
|
||||
sum_avg = &do_sum_avg;
|
||||
|
||||
int values[5] = { 1, 1, 2, 3, 5 };
|
||||
int sum;
|
||||
float avg;
|
||||
sum_avg(values, 5, sum, avg);
|
||||
|
||||
std::cout << "sum = " << sum << std::endl;
|
||||
std::cout << "avg = " << avg << std::endl;
|
||||
return 0;
|
||||
}
|
||||
@ -1,17 +1,21 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
// Copyright (C) 2001, 2002 Doug Gregor (gregod@cs.rpi.edu)
|
||||
//
|
||||
// Permission to copy, use, sell and distribute this software is granted
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
|
||||
// For more information, see http://www.boost.org/libs/function
|
||||
|
||||
// William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
|
||||
// design of this library.
|
||||
|
||||
#include <functional> // unary_function, binary_function
|
||||
|
||||
#include <boost/preprocessor/iterate.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
@ -24,7 +28,7 @@
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
// Visual Age C++ doesn't handle the file iteration well
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, <= 600)
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 0
|
||||
# include <boost/function/function0.hpp>
|
||||
# endif
|
||||
|
||||
@ -1,16 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
#if !defined(BOOST_PP_IS_ITERATING)
|
||||
# error Boost.Function - do not include this file!
|
||||
#endif
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
|
||||
@ -1,37 +0,0 @@
|
||||
#!/usr/bin/perl -w
|
||||
#
|
||||
# Boost.Function library
|
||||
#
|
||||
# Copyright (C) 2001-2003 Douglas Gregor (gregod@cs.rpi.edu)
|
||||
#
|
||||
# Permission to copy, use, sell and distribute this software is granted
|
||||
# provided this copyright notice appears in all copies.
|
||||
# Permission to modify the code and to distribute modified code is granted
|
||||
# provided this copyright notice appears in all copies, and a notice
|
||||
# that the code was modified is included with the copyright notice.
|
||||
#
|
||||
# This software is provided "as is" without express or implied warranty,
|
||||
# and with no claim as to its suitability for any purpose.
|
||||
#
|
||||
# For more information, see http://www.boost.org
|
||||
use English;
|
||||
|
||||
$max_args = $ARGV[0];
|
||||
|
||||
open (OUT, ">maybe_include.hpp") or die("Cannot write to maybe_include.hpp");
|
||||
for($on_arg = 0; $on_arg <= $max_args; ++$on_arg) {
|
||||
if ($on_arg == 0) {
|
||||
print OUT "#if";
|
||||
}
|
||||
else {
|
||||
print OUT "#elif";
|
||||
}
|
||||
print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n";
|
||||
print OUT "# ifndef BOOST_FUNCTION_$on_arg\n";
|
||||
print OUT "# define BOOST_FUNCTION_$on_arg\n";
|
||||
print OUT "# include <boost/function/function_template.hpp>\n";
|
||||
print OUT "# endif\n";
|
||||
}
|
||||
print OUT "#else\n";
|
||||
print OUT "# error Cannot handle Boost.Function objects that accept more than $max_args arguments!\n";
|
||||
print OUT "#endif\n";
|
||||
@ -1,267 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS == 0
|
||||
# ifndef BOOST_FUNCTION_0
|
||||
# define BOOST_FUNCTION_0
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 1
|
||||
# ifndef BOOST_FUNCTION_1
|
||||
# define BOOST_FUNCTION_1
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 2
|
||||
# ifndef BOOST_FUNCTION_2
|
||||
# define BOOST_FUNCTION_2
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 3
|
||||
# ifndef BOOST_FUNCTION_3
|
||||
# define BOOST_FUNCTION_3
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 4
|
||||
# ifndef BOOST_FUNCTION_4
|
||||
# define BOOST_FUNCTION_4
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 5
|
||||
# ifndef BOOST_FUNCTION_5
|
||||
# define BOOST_FUNCTION_5
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 6
|
||||
# ifndef BOOST_FUNCTION_6
|
||||
# define BOOST_FUNCTION_6
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 7
|
||||
# ifndef BOOST_FUNCTION_7
|
||||
# define BOOST_FUNCTION_7
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 8
|
||||
# ifndef BOOST_FUNCTION_8
|
||||
# define BOOST_FUNCTION_8
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 9
|
||||
# ifndef BOOST_FUNCTION_9
|
||||
# define BOOST_FUNCTION_9
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 10
|
||||
# ifndef BOOST_FUNCTION_10
|
||||
# define BOOST_FUNCTION_10
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 11
|
||||
# ifndef BOOST_FUNCTION_11
|
||||
# define BOOST_FUNCTION_11
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 12
|
||||
# ifndef BOOST_FUNCTION_12
|
||||
# define BOOST_FUNCTION_12
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 13
|
||||
# ifndef BOOST_FUNCTION_13
|
||||
# define BOOST_FUNCTION_13
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 14
|
||||
# ifndef BOOST_FUNCTION_14
|
||||
# define BOOST_FUNCTION_14
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 15
|
||||
# ifndef BOOST_FUNCTION_15
|
||||
# define BOOST_FUNCTION_15
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 16
|
||||
# ifndef BOOST_FUNCTION_16
|
||||
# define BOOST_FUNCTION_16
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 17
|
||||
# ifndef BOOST_FUNCTION_17
|
||||
# define BOOST_FUNCTION_17
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 18
|
||||
# ifndef BOOST_FUNCTION_18
|
||||
# define BOOST_FUNCTION_18
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 19
|
||||
# ifndef BOOST_FUNCTION_19
|
||||
# define BOOST_FUNCTION_19
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 20
|
||||
# ifndef BOOST_FUNCTION_20
|
||||
# define BOOST_FUNCTION_20
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 21
|
||||
# ifndef BOOST_FUNCTION_21
|
||||
# define BOOST_FUNCTION_21
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 22
|
||||
# ifndef BOOST_FUNCTION_22
|
||||
# define BOOST_FUNCTION_22
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 23
|
||||
# ifndef BOOST_FUNCTION_23
|
||||
# define BOOST_FUNCTION_23
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 24
|
||||
# ifndef BOOST_FUNCTION_24
|
||||
# define BOOST_FUNCTION_24
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 25
|
||||
# ifndef BOOST_FUNCTION_25
|
||||
# define BOOST_FUNCTION_25
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 26
|
||||
# ifndef BOOST_FUNCTION_26
|
||||
# define BOOST_FUNCTION_26
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 27
|
||||
# ifndef BOOST_FUNCTION_27
|
||||
# define BOOST_FUNCTION_27
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 28
|
||||
# ifndef BOOST_FUNCTION_28
|
||||
# define BOOST_FUNCTION_28
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 29
|
||||
# ifndef BOOST_FUNCTION_29
|
||||
# define BOOST_FUNCTION_29
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 30
|
||||
# ifndef BOOST_FUNCTION_30
|
||||
# define BOOST_FUNCTION_30
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 31
|
||||
# ifndef BOOST_FUNCTION_31
|
||||
# define BOOST_FUNCTION_31
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 32
|
||||
# ifndef BOOST_FUNCTION_32
|
||||
# define BOOST_FUNCTION_32
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 33
|
||||
# ifndef BOOST_FUNCTION_33
|
||||
# define BOOST_FUNCTION_33
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 34
|
||||
# ifndef BOOST_FUNCTION_34
|
||||
# define BOOST_FUNCTION_34
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 35
|
||||
# ifndef BOOST_FUNCTION_35
|
||||
# define BOOST_FUNCTION_35
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 36
|
||||
# ifndef BOOST_FUNCTION_36
|
||||
# define BOOST_FUNCTION_36
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 37
|
||||
# ifndef BOOST_FUNCTION_37
|
||||
# define BOOST_FUNCTION_37
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 38
|
||||
# ifndef BOOST_FUNCTION_38
|
||||
# define BOOST_FUNCTION_38
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 39
|
||||
# ifndef BOOST_FUNCTION_39
|
||||
# define BOOST_FUNCTION_39
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 40
|
||||
# ifndef BOOST_FUNCTION_40
|
||||
# define BOOST_FUNCTION_40
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 41
|
||||
# ifndef BOOST_FUNCTION_41
|
||||
# define BOOST_FUNCTION_41
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 42
|
||||
# ifndef BOOST_FUNCTION_42
|
||||
# define BOOST_FUNCTION_42
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 43
|
||||
# ifndef BOOST_FUNCTION_43
|
||||
# define BOOST_FUNCTION_43
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 44
|
||||
# ifndef BOOST_FUNCTION_44
|
||||
# define BOOST_FUNCTION_44
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 45
|
||||
# ifndef BOOST_FUNCTION_45
|
||||
# define BOOST_FUNCTION_45
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 46
|
||||
# ifndef BOOST_FUNCTION_46
|
||||
# define BOOST_FUNCTION_46
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 47
|
||||
# ifndef BOOST_FUNCTION_47
|
||||
# define BOOST_FUNCTION_47
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 48
|
||||
# ifndef BOOST_FUNCTION_48
|
||||
# define BOOST_FUNCTION_48
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 49
|
||||
# ifndef BOOST_FUNCTION_49
|
||||
# define BOOST_FUNCTION_49
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 50
|
||||
# ifndef BOOST_FUNCTION_50
|
||||
# define BOOST_FUNCTION_50
|
||||
# include <boost/function/function_template.hpp>
|
||||
# endif
|
||||
#else
|
||||
# error Cannot handle Boost.Function objects that accept more than 50 arguments!
|
||||
#endif
|
||||
@ -1,26 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#ifndef BOOST_FUNCTION_PROLOGUE_HPP
|
||||
#define BOOST_FUNCTION_PROLOGUE_HPP
|
||||
# include <cassert>
|
||||
# include <algorithm>
|
||||
# include <boost/config/no_tr1/functional.hpp> // unary_function, binary_function
|
||||
# include <boost/throw_exception.hpp>
|
||||
# include <boost/config.hpp>
|
||||
# include <boost/function/function_base.hpp>
|
||||
# include <boost/mem_fn.hpp>
|
||||
# include <boost/type_traits/is_integral.hpp>
|
||||
# include <boost/preprocessor/enum.hpp>
|
||||
# include <boost/preprocessor/enum_params.hpp>
|
||||
# include <boost/preprocessor/cat.hpp>
|
||||
# include <boost/preprocessor/repeat.hpp>
|
||||
# include <boost/preprocessor/inc.hpp>
|
||||
# include <boost/type_traits/is_void.hpp>
|
||||
#endif // BOOST_FUNCTION_PROLOGUE_HPP
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 0
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 1
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 10
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 2
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 3
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 4
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 5
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 6
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 7
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 8
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,12 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 9
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@ -1,836 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2006
|
||||
// Copyright Emil Dotchevski 2007
|
||||
// Use, modification and distribution is subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#ifndef BOOST_FUNCTION_BASE_HEADER
|
||||
#define BOOST_FUNCTION_BASE_HEADER
|
||||
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <new>
|
||||
#include <typeinfo>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/type_traits/is_integral.hpp>
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/type_traits/alignment_of.hpp>
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
# include "boost/utility/enable_if.hpp"
|
||||
#else
|
||||
# include "boost/mpl/bool.hpp"
|
||||
#endif
|
||||
#include <boost/function_equal.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( push )
|
||||
# pragma warning( disable : 4793 ) // complaint about native code generation
|
||||
# pragma warning( disable : 4127 ) // "conditional expression is constant"
|
||||
#endif
|
||||
|
||||
// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
|
||||
#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
|
||||
// Embedded VC++ does not have type_info in namespace std
|
||||
# define BOOST_FUNCTION_STD_NS
|
||||
#else
|
||||
# define BOOST_FUNCTION_STD_NS std
|
||||
#endif
|
||||
|
||||
// Borrowed from Boost.Python library: determines the cases where we
|
||||
// need to use std::type_info::name to compare instead of operator==.
|
||||
# if (defined(__GNUC__) && __GNUC__ >= 3) \
|
||||
|| defined(_AIX) \
|
||||
|| ( defined(__sgi) && defined(__host_mips))
|
||||
# include <cstring>
|
||||
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
|
||||
(std::strcmp((X).name(),(Y).name()) == 0)
|
||||
# else
|
||||
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
|
||||
# define BOOST_FUNCTION_TARGET_FIX(x) x
|
||||
#else
|
||||
# define BOOST_FUNCTION_TARGET_FIX(x)
|
||||
#endif // not MSVC
|
||||
|
||||
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
|
||||
// Work around a compiler bug.
|
||||
// boost::python::objects::function has to be seen by the compiler before the
|
||||
// boost::function class template.
|
||||
namespace boost { namespace python { namespace objects {
|
||||
class function;
|
||||
}}}
|
||||
#endif
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|
||||
|| defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
|
||||
|| !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
|
||||
# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
|
||||
#endif
|
||||
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
|
||||
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
|
||||
typename ::boost::enable_if_c<(::boost::type_traits::ice_not< \
|
||||
(::boost::is_integral<Functor>::value)>::value), \
|
||||
Type>::type
|
||||
#else
|
||||
// BCC doesn't recognize this depends on a template argument and complains
|
||||
// about the use of 'typename'
|
||||
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
|
||||
::boost::enable_if_c<(::boost::type_traits::ice_not< \
|
||||
(::boost::is_integral<Functor>::value)>::value), \
|
||||
Type>::type
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
namespace boost {
|
||||
|
||||
template<typename Signature>
|
||||
class function;
|
||||
|
||||
template<typename Signature>
|
||||
inline void swap(function<Signature>& f1,
|
||||
function<Signature>& f2)
|
||||
{
|
||||
f1.swap(f2);
|
||||
}
|
||||
|
||||
} // end namespace boost
|
||||
#endif // have partial specialization
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
namespace function {
|
||||
class X;
|
||||
|
||||
/**
|
||||
* A buffer used to store small function objects in
|
||||
* boost::function. It is a union containing function pointers,
|
||||
* object pointers, and a structure that resembles a bound
|
||||
* member function pointer.
|
||||
*/
|
||||
union function_buffer
|
||||
{
|
||||
// For pointers to function objects
|
||||
void* obj_ptr;
|
||||
|
||||
// For pointers to std::type_info objects
|
||||
// (get_functor_type_tag, check_functor_type_tag).
|
||||
const void* const_obj_ptr;
|
||||
|
||||
// For function pointers of all kinds
|
||||
mutable void (*func_ptr)();
|
||||
|
||||
// For bound member pointers
|
||||
struct bound_memfunc_ptr_t {
|
||||
void (X::*memfunc_ptr)(int);
|
||||
void* obj_ptr;
|
||||
} bound_memfunc_ptr;
|
||||
|
||||
// To relax aliasing constraints
|
||||
mutable char data;
|
||||
};
|
||||
|
||||
/**
|
||||
* The unusable class is a placeholder for unused function arguments
|
||||
* It is also completely unusable except that it constructable from
|
||||
* anything. This helps compilers without partial specialization to
|
||||
* handle Boost.Function objects returning void.
|
||||
*/
|
||||
struct unusable
|
||||
{
|
||||
unusable() {}
|
||||
template<typename T> unusable(const T&) {}
|
||||
};
|
||||
|
||||
/* Determine the return type. This supports compilers that do not support
|
||||
* void returns or partial specialization by silently changing the return
|
||||
* type to "unusable".
|
||||
*/
|
||||
template<typename T> struct function_return_type { typedef T type; };
|
||||
|
||||
template<>
|
||||
struct function_return_type<void>
|
||||
{
|
||||
typedef unusable type;
|
||||
};
|
||||
|
||||
// The operation type to perform on the given functor/function pointer
|
||||
enum functor_manager_operation_type {
|
||||
clone_functor_tag,
|
||||
destroy_functor_tag,
|
||||
check_functor_type_tag,
|
||||
get_functor_type_tag
|
||||
};
|
||||
|
||||
// Tags used to decide between different types of functions
|
||||
struct function_ptr_tag {};
|
||||
struct function_obj_tag {};
|
||||
struct member_ptr_tag {};
|
||||
struct function_obj_ref_tag {};
|
||||
|
||||
template<typename F>
|
||||
class get_function_tag
|
||||
{
|
||||
typedef typename mpl::if_c<(is_pointer<F>::value),
|
||||
function_ptr_tag,
|
||||
function_obj_tag>::type ptr_or_obj_tag;
|
||||
|
||||
typedef typename mpl::if_c<(is_member_pointer<F>::value),
|
||||
member_ptr_tag,
|
||||
ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
|
||||
|
||||
typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
|
||||
function_obj_ref_tag,
|
||||
ptr_or_obj_or_mem_tag>::type or_ref_tag;
|
||||
|
||||
public:
|
||||
typedef or_ref_tag type;
|
||||
};
|
||||
|
||||
// The trivial manager does nothing but return the same pointer (if we
|
||||
// are cloning) or return the null pointer (if we are deleting).
|
||||
template<typename F>
|
||||
struct reference_manager
|
||||
{
|
||||
static inline void
|
||||
get(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
switch (op) {
|
||||
case clone_functor_tag:
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
return;
|
||||
|
||||
case destroy_functor_tag:
|
||||
out_buffer.obj_ptr = 0;
|
||||
return;
|
||||
|
||||
case check_functor_type_tag:
|
||||
{
|
||||
// DPG TBD: Since we're only storing a pointer, it's
|
||||
// possible that the user could ask for a base class or
|
||||
// derived class. Is that okay?
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
return;
|
||||
|
||||
case get_functor_type_tag:
|
||||
out_buffer.const_obj_ptr = &typeid(F);
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Determine if boost::function can use the small-object
|
||||
* optimization with the function object type F.
|
||||
*/
|
||||
template<typename F>
|
||||
struct function_allows_small_object_optimization
|
||||
{
|
||||
BOOST_STATIC_CONSTANT
|
||||
(bool,
|
||||
value = ((sizeof(F) <= sizeof(function_buffer) &&
|
||||
(alignment_of<function_buffer>::value
|
||||
% alignment_of<F>::value == 0))));
|
||||
};
|
||||
|
||||
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
|
||||
* can clone or destroy the given function/function object pointer.
|
||||
*/
|
||||
template<typename Functor>
|
||||
struct functor_manager_common
|
||||
{
|
||||
typedef Functor functor_type;
|
||||
|
||||
// Function pointers
|
||||
static inline void
|
||||
manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
if (op == clone_functor_tag)
|
||||
out_buffer.func_ptr = in_buffer.func_ptr;
|
||||
else if (op == 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.
|
||||
static inline void
|
||||
manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
if (op == clone_functor_tag) {
|
||||
const functor_type* in_functor =
|
||||
reinterpret_cast<const functor_type*>(&in_buffer.data);
|
||||
new ((void*)&out_buffer.data) functor_type(*in_functor);
|
||||
} else if (op == destroy_functor_tag) {
|
||||
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
|
||||
reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
|
||||
} else /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = &in_buffer.data;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Functor>
|
||||
struct functor_manager
|
||||
{
|
||||
private:
|
||||
typedef Functor functor_type;
|
||||
|
||||
// Function pointers
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_ptr_tag)
|
||||
{
|
||||
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_)
|
||||
{
|
||||
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_type* f =
|
||||
(const functor_type*)(in_buffer.obj_ptr);
|
||||
functor_type* new_f = new functor_type(*f);
|
||||
out_buffer.obj_ptr = new_f;
|
||||
} else if (op == destroy_functor_tag) {
|
||||
/* Cast from the void pointer to the functor pointer type */
|
||||
functor_type* f =
|
||||
static_cast<functor_type*>(out_buffer.obj_ptr);
|
||||
delete f;
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// For function objects, we determine whether the function
|
||||
// object can use the small-object optimization buffer or
|
||||
// whether we need to allocate it on the heap.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_obj_tag)
|
||||
{
|
||||
manager(in_buffer, out_buffer, op,
|
||||
mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
|
||||
}
|
||||
|
||||
public:
|
||||
/* Dispatch to an appropriate manager based on whether we have a
|
||||
function pointer or a function object pointer. */
|
||||
static inline void
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
switch (op) {
|
||||
case get_functor_type_tag:
|
||||
out_buffer.const_obj_ptr = &typeid(functor_type);
|
||||
return;
|
||||
|
||||
default:
|
||||
manager(in_buffer, out_buffer, op, tag_type());
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
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 == 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 /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// For function objects, we determine whether the function
|
||||
// object can use the small-object optimization buffer or
|
||||
// whether we need to allocate it on the heap.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_obj_tag)
|
||||
{
|
||||
manager(in_buffer, out_buffer, op,
|
||||
mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
|
||||
}
|
||||
|
||||
public:
|
||||
/* Dispatch to an appropriate manager based on whether we have a
|
||||
function pointer or a function object pointer. */
|
||||
static inline void
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
switch (op) {
|
||||
case get_functor_type_tag:
|
||||
out_buffer.const_obj_ptr = &typeid(functor_type);
|
||||
return;
|
||||
|
||||
default:
|
||||
manager(in_buffer, out_buffer, op, tag_type());
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// A type that is only used for comparisons against zero
|
||||
struct useless_clear_type {};
|
||||
|
||||
#ifdef BOOST_NO_SFINAE
|
||||
// These routines perform comparisons between a Boost.Function
|
||||
// object and an arbitrary function object (when the last
|
||||
// parameter is mpl::bool_<false>) or against zero (when the
|
||||
// last parameter is mpl::bool_<true>). They are only necessary
|
||||
// for compilers that don't support SFINAE.
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
|
||||
{ return f.empty(); }
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_not_equal(const Function& f, const Functor&, int,
|
||||
mpl::bool_<true>)
|
||||
{ return !f.empty(); }
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_equal(const Function& f, const Functor& g, long,
|
||||
mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return function_equal(*fp, g);
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_equal(const Function& f, const reference_wrapper<Functor>& g,
|
||||
int, mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp == g.get_pointer();
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_not_equal(const Function& f, const Functor& g, long,
|
||||
mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return !function_equal(*fp, g);
|
||||
else return true;
|
||||
}
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_not_equal(const Function& f,
|
||||
const reference_wrapper<Functor>& g, int,
|
||||
mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp != g.get_pointer();
|
||||
else return true;
|
||||
}
|
||||
#endif // BOOST_NO_SFINAE
|
||||
|
||||
/**
|
||||
* Stores the "manager" portion of the vtable for a
|
||||
* boost::function object.
|
||||
*/
|
||||
struct vtable_base
|
||||
{
|
||||
vtable_base() : manager(0) { }
|
||||
void (*manager)(const function_buffer& in_buffer,
|
||||
function_buffer& out_buffer,
|
||||
functor_manager_operation_type op);
|
||||
};
|
||||
} // end namespace function
|
||||
} // end namespace detail
|
||||
|
||||
/**
|
||||
* The function_base class contains the basic elements needed for the
|
||||
* function1, function2, function3, etc. classes. It is common to all
|
||||
* functions (and as such can be used to tell if we have one of the
|
||||
* functionN objects).
|
||||
*/
|
||||
class function_base
|
||||
{
|
||||
public:
|
||||
function_base() : vtable(0) { }
|
||||
|
||||
/** Determine if the function is empty (i.e., has no target). */
|
||||
bool empty() const { return !vtable; }
|
||||
|
||||
/** Retrieve the type of the stored function object, or typeid(void)
|
||||
if this is empty. */
|
||||
const BOOST_FUNCTION_STD_NS::type_info& target_type() const
|
||||
{
|
||||
if (!vtable) return typeid(void);
|
||||
|
||||
detail::function::function_buffer type;
|
||||
vtable->manager(functor, type, detail::function::get_functor_type_tag);
|
||||
return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
Functor* target()
|
||||
{
|
||||
if (!vtable) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.const_obj_ptr = &typeid(Functor);
|
||||
vtable->manager(functor, type_result,
|
||||
detail::function::check_functor_type_tag);
|
||||
return static_cast<Functor*>(type_result.obj_ptr);
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
const Functor* target( Functor * = 0 ) const
|
||||
#else
|
||||
const Functor* target() const
|
||||
#endif
|
||||
{
|
||||
if (!vtable) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.const_obj_ptr = &typeid(Functor);
|
||||
vtable->manager(functor, type_result,
|
||||
detail::function::check_functor_type_tag);
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
return (const Functor*)(type_result.obj_ptr);
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
bool contains(const F& f) const
|
||||
{
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
if (const F* fp = this->target( (F*)0 ))
|
||||
#else
|
||||
if (const F* fp = this->template target<F>())
|
||||
#endif
|
||||
{
|
||||
return function_equal(*fp, f);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
|
||||
// GCC 3.3 and newer cannot copy with the global operator==, due to
|
||||
// problems with instantiation of function return types before it
|
||||
// has been verified that the argument types match up.
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(Functor g) const
|
||||
{
|
||||
if (const Functor* fp = target<Functor>())
|
||||
return function_equal(*fp, g);
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(Functor g) const
|
||||
{
|
||||
if (const Functor* fp = target<Functor>())
|
||||
return !function_equal(*fp, g);
|
||||
else return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
public: // should be protected, but GCC 2.95.3 will fail to allow access
|
||||
detail::function::vtable_base* vtable;
|
||||
mutable detail::function::function_buffer functor;
|
||||
};
|
||||
|
||||
/**
|
||||
* The bad_function_call exception class is thrown when a boost::function
|
||||
* object is invoked
|
||||
*/
|
||||
class bad_function_call : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
bad_function_call() : std::runtime_error("call to empty boost::function") {}
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
inline bool operator==(const function_base& f,
|
||||
detail::function::useless_clear_type*)
|
||||
{
|
||||
return f.empty();
|
||||
}
|
||||
|
||||
inline bool operator!=(const function_base& f,
|
||||
detail::function::useless_clear_type*)
|
||||
{
|
||||
return !f.empty();
|
||||
}
|
||||
|
||||
inline bool operator==(detail::function::useless_clear_type*,
|
||||
const function_base& f)
|
||||
{
|
||||
return f.empty();
|
||||
}
|
||||
|
||||
inline bool operator!=(detail::function::useless_clear_type*,
|
||||
const function_base& f)
|
||||
{
|
||||
return !f.empty();
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NO_SFINAE
|
||||
// Comparisons between boost::function objects and arbitrary function objects
|
||||
template<typename Functor>
|
||||
inline bool operator==(const function_base& f, Functor g)
|
||||
{
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_equal(f, g, 0, integral());
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
inline bool operator==(Functor g, const function_base& f)
|
||||
{
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_equal(f, g, 0, integral());
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
inline bool operator!=(const function_base& f, Functor g)
|
||||
{
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_not_equal(f, g, 0, integral());
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
inline bool operator!=(Functor g, const function_base& f)
|
||||
{
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_not_equal(f, g, 0, integral());
|
||||
}
|
||||
#else
|
||||
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
// Comparisons between boost::function objects and arbitrary function
|
||||
// objects. GCC 3.3 and before has an obnoxious bug that prevents this
|
||||
// from working.
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(const function_base& f, Functor g)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return function_equal(*fp, g);
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(Functor g, const function_base& f)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return function_equal(g, *fp);
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(const function_base& f, Functor g)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return !function_equal(*fp, g);
|
||||
else return true;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(Functor g, const function_base& f)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return !function_equal(g, *fp);
|
||||
else return true;
|
||||
}
|
||||
# endif
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(const function_base& f, reference_wrapper<Functor> g)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp == g.get_pointer();
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator==(reference_wrapper<Functor> g, const function_base& f)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return g.get_pointer() == fp;
|
||||
else return false;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(const function_base& f, reference_wrapper<Functor> g)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp != g.get_pointer();
|
||||
else return true;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
|
||||
operator!=(reference_wrapper<Functor> g, const function_base& f)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return g.get_pointer() != fp;
|
||||
else return true;
|
||||
}
|
||||
|
||||
#endif // Compiler supporting SFINAE
|
||||
|
||||
namespace detail {
|
||||
namespace function {
|
||||
inline bool has_empty_target(const function_base* f)
|
||||
{
|
||||
return f->empty();
|
||||
}
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
|
||||
inline bool has_empty_target(const void*)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
#else
|
||||
inline bool has_empty_target(...)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
} // end namespace function
|
||||
} // end namespace detail
|
||||
} // end namespace boost
|
||||
|
||||
#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
|
||||
#undef BOOST_FUNCTION_COMPARE_TYPE_ID
|
||||
|
||||
#endif // BOOST_FUNCTION_BASE_HEADER
|
||||
@ -1,957 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2006
|
||||
// Copyright Emil Dotchevski 2007
|
||||
// Use, modification and distribution is subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
// Note: this header is a header template and must NOT have multiple-inclusion
|
||||
// protection.
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( push )
|
||||
# pragma warning( disable : 4127 ) // "conditional expression is constant"
|
||||
#endif
|
||||
|
||||
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
|
||||
|
||||
#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
|
||||
|
||||
#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
|
||||
|
||||
#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
|
||||
|
||||
#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
|
||||
|
||||
#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
|
||||
typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
|
||||
|
||||
#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
|
||||
|
||||
// Comma if nonzero number of arguments
|
||||
#if BOOST_FUNCTION_NUM_ARGS == 0
|
||||
# define BOOST_FUNCTION_COMMA
|
||||
#else
|
||||
# define BOOST_FUNCTION_COMMA ,
|
||||
#endif // BOOST_FUNCTION_NUM_ARGS > 0
|
||||
|
||||
// Class names used in this version of the code
|
||||
#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_FUNCTION_INVOKER \
|
||||
BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \
|
||||
BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_FUNCTION_REF_INVOKER \
|
||||
BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
|
||||
BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
|
||||
BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
|
||||
BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
|
||||
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
# define BOOST_FUNCTION_VOID_RETURN_TYPE void
|
||||
# define BOOST_FUNCTION_RETURN(X) X
|
||||
#else
|
||||
# define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable
|
||||
# define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
namespace function {
|
||||
template<
|
||||
typename FunctionPtr,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_FUNCTION_INVOKER
|
||||
{
|
||||
static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
{
|
||||
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
|
||||
return f(BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionPtr,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
|
||||
{
|
||||
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
|
||||
BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f;
|
||||
if (function_allows_small_object_optimization<FunctionObj>::value)
|
||||
f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
|
||||
else
|
||||
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
return (*f)(BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f;
|
||||
if (function_allows_small_object_optimization<FunctionObj>::value)
|
||||
f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
|
||||
else
|
||||
f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
|
||||
{
|
||||
static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f =
|
||||
reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
return (*f)(BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
|
||||
{
|
||||
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f =
|
||||
reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
|
||||
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionPtr,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
|
||||
{
|
||||
typedef typename mpl::if_c<(is_void<R>::value),
|
||||
BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
|
||||
FunctionPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>,
|
||||
BOOST_FUNCTION_FUNCTION_INVOKER<
|
||||
FunctionPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
typedef typename mpl::if_c<(is_void<R>::value),
|
||||
BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>,
|
||||
BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
|
||||
{
|
||||
typedef typename mpl::if_c<(is_void<R>::value),
|
||||
BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>,
|
||||
BOOST_FUNCTION_FUNCTION_REF_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>
|
||||
>::type type;
|
||||
};
|
||||
|
||||
/**
|
||||
* vtable for a specific boost::function instance.
|
||||
*/
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||
struct BOOST_FUNCTION_VTABLE : vtable_base
|
||||
{
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
typedef R result_type;
|
||||
#else
|
||||
typedef typename function_return_type<R>::type result_type;
|
||||
#endif // BOOST_NO_VOID_RETURNS
|
||||
|
||||
typedef result_type (*invoker_type)(function_buffer&
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS);
|
||||
|
||||
template<typename F>
|
||||
BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
|
||||
{
|
||||
init(f);
|
||||
}
|
||||
template<typename F,typename Allocator>
|
||||
BOOST_FUNCTION_VTABLE(F f, Allocator) : vtable_base(), invoker(0)
|
||||
{
|
||||
init_a<Allocator>(f);
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
bool assign_to(F f, function_buffer& functor)
|
||||
{
|
||||
typedef typename get_function_tag<F>::type 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)
|
||||
{
|
||||
if (manager)
|
||||
manager(functor, functor, destroy_functor_tag);
|
||||
}
|
||||
|
||||
private:
|
||||
template<typename F>
|
||||
void init(F f)
|
||||
{
|
||||
typedef typename get_function_tag<F>::type tag;
|
||||
init(f, tag());
|
||||
}
|
||||
template<typename Allocator,typename F>
|
||||
void init_a(F f)
|
||||
{
|
||||
typedef typename get_function_tag<F>::type tag;
|
||||
init_a<Allocator>(f, tag());
|
||||
}
|
||||
|
||||
// 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>::manage;
|
||||
}
|
||||
template<typename Allocator,typename FunctionPtr>
|
||||
void init_a(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_a<FunctionPtr, Allocator>::manage;
|
||||
}
|
||||
|
||||
template<typename FunctionPtr>
|
||||
bool
|
||||
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
|
||||
{
|
||||
this->clear(functor);
|
||||
if (f) {
|
||||
// should be a reinterpret cast, but some compilers insist
|
||||
// on giving cv-qualifiers to free functions
|
||||
functor.func_ptr = (void (*)())(f);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
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
|
||||
#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 Allocator,typename MemberPtr>
|
||||
void init_a(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_a<Allocator>(mem_fn(f));
|
||||
}
|
||||
|
||||
template<typename MemberPtr>
|
||||
bool assign_to(MemberPtr f, function_buffer& functor, 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(mem_fn(f), functor);
|
||||
return true;
|
||||
} else {
|
||||
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
|
||||
|
||||
// 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>::manage;
|
||||
}
|
||||
template<typename Allocator,typename FunctionObj>
|
||||
void init_a(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_a<FunctionObj, Allocator>::manage;
|
||||
}
|
||||
|
||||
// Assign to a function object using the small object optimization
|
||||
template<typename FunctionObj>
|
||||
void
|
||||
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
|
||||
{
|
||||
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.
|
||||
template<typename FunctionObj>
|
||||
void
|
||||
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
|
||||
{
|
||||
functor.obj_ptr = new FunctionObj(f);
|
||||
}
|
||||
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>
|
||||
bool
|
||||
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
|
||||
{
|
||||
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
|
||||
assign_functor(f, functor,
|
||||
mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
template<typename FunctionObj,typename Allocator>
|
||||
bool
|
||||
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
|
||||
{
|
||||
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
|
||||
assign_functor_a(f, functor, a,
|
||||
mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// 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 Allocator,typename FunctionObj>
|
||||
void
|
||||
init_a(const reference_wrapper<FunctionObj>& f, function_obj_ref_tag)
|
||||
{
|
||||
init(f,function_obj_ref_tag());
|
||||
}
|
||||
|
||||
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())) {
|
||||
// DPG TBD: We might need to detect constness of
|
||||
// FunctionObj to assign into obj_ptr or const_obj_ptr to
|
||||
// be truly legit, but no platform in existence makes
|
||||
// const void* different from void*.
|
||||
functor.const_obj_ptr = f.get_pointer();
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
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:
|
||||
invoker_type invoker;
|
||||
};
|
||||
} // end namespace function
|
||||
} // end namespace detail
|
||||
|
||||
template<
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
class BOOST_FUNCTION_FUNCTION : public function_base
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS == 1
|
||||
|
||||
, public std::unary_function<T0,R>
|
||||
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 2
|
||||
|
||||
, public std::binary_function<T0,T1,R>
|
||||
|
||||
#endif
|
||||
|
||||
{
|
||||
public:
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
typedef R result_type;
|
||||
#else
|
||||
typedef typename boost::detail::function::function_return_type<R>::type
|
||||
result_type;
|
||||
#endif // BOOST_NO_VOID_RETURNS
|
||||
|
||||
private:
|
||||
typedef boost::detail::function::BOOST_FUNCTION_VTABLE<
|
||||
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
||||
vtable_type;
|
||||
|
||||
struct clear_type {};
|
||||
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
|
||||
|
||||
// add signature for boost::lambda
|
||||
template<typename Args>
|
||||
struct sig
|
||||
{
|
||||
typedef result_type type;
|
||||
};
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS == 1
|
||||
typedef T0 argument_type;
|
||||
#elif BOOST_FUNCTION_NUM_ARGS == 2
|
||||
typedef T0 first_argument_type;
|
||||
typedef T1 second_argument_type;
|
||||
#endif
|
||||
|
||||
BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
|
||||
BOOST_FUNCTION_ARG_TYPES
|
||||
|
||||
typedef BOOST_FUNCTION_FUNCTION self_type;
|
||||
|
||||
BOOST_FUNCTION_FUNCTION() : function_base() { }
|
||||
|
||||
// MSVC chokes if the following two constructors are collapsed into
|
||||
// one with a default parameter.
|
||||
template<typename Functor>
|
||||
BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
|
||||
#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(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
|
||||
BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
|
||||
#else
|
||||
BOOST_FUNCTION_FUNCTION(int zero) : function_base()
|
||||
{
|
||||
BOOST_ASSERT(zero == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()
|
||||
{
|
||||
this->assign_to_own(f);
|
||||
}
|
||||
|
||||
~BOOST_FUNCTION_FUNCTION() { clear(); }
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
// MSVC 6.0 and prior require all definitions to be inline, but
|
||||
// these definitions can become very costly.
|
||||
result_type operator()(BOOST_FUNCTION_PARMS) const
|
||||
{
|
||||
if (this->empty())
|
||||
boost::throw_exception(bad_function_call());
|
||||
|
||||
return static_cast<vtable_type*>(vtable)->invoker
|
||||
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
#else
|
||||
result_type operator()(BOOST_FUNCTION_PARMS) const;
|
||||
#endif
|
||||
|
||||
// The distinction between when to use BOOST_FUNCTION_FUNCTION and
|
||||
// when to use self_type is obnoxious. MSVC cannot handle self_type as
|
||||
// the return type of these assignment operators, but Borland C++ cannot
|
||||
// handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
|
||||
// construct.
|
||||
template<typename Functor>
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
typename enable_if_c<
|
||||
(boost::type_traits::ice_not<
|
||||
(is_integral<Functor>::value)>::value),
|
||||
BOOST_FUNCTION_FUNCTION&>::type
|
||||
#else
|
||||
BOOST_FUNCTION_FUNCTION&
|
||||
#endif
|
||||
operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
|
||||
{
|
||||
this->clear();
|
||||
try {
|
||||
this->assign_to(f);
|
||||
} catch (...) {
|
||||
vtable = 0;
|
||||
throw;
|
||||
}
|
||||
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
|
||||
BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
|
||||
{
|
||||
this->clear();
|
||||
return *this;
|
||||
}
|
||||
#else
|
||||
BOOST_FUNCTION_FUNCTION& operator=(int zero)
|
||||
{
|
||||
BOOST_ASSERT(zero == 0);
|
||||
this->clear();
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Assignment from another BOOST_FUNCTION_FUNCTION
|
||||
BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
|
||||
{
|
||||
if (&f == this)
|
||||
return *this;
|
||||
|
||||
this->clear();
|
||||
try {
|
||||
this->assign_to_own(f);
|
||||
} catch (...) {
|
||||
vtable = 0;
|
||||
throw;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
void swap(BOOST_FUNCTION_FUNCTION& other)
|
||||
{
|
||||
if (&other == this)
|
||||
return;
|
||||
|
||||
BOOST_FUNCTION_FUNCTION tmp = *this;
|
||||
*this = other;
|
||||
other = tmp;
|
||||
}
|
||||
|
||||
// Clear out a target, if there is one
|
||||
void clear()
|
||||
{
|
||||
if (vtable) {
|
||||
static_cast<vtable_type*>(vtable)->clear(this->functor);
|
||||
vtable = 0;
|
||||
}
|
||||
}
|
||||
|
||||
#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
|
||||
// Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
|
||||
operator bool () const { return !this->empty(); }
|
||||
#else
|
||||
private:
|
||||
struct dummy {
|
||||
void nonnull() {};
|
||||
};
|
||||
|
||||
typedef void (dummy::*safe_bool)();
|
||||
|
||||
public:
|
||||
operator safe_bool () const
|
||||
{ return (this->empty())? 0 : &dummy::nonnull; }
|
||||
|
||||
bool operator!() const
|
||||
{ return this->empty(); }
|
||||
#endif
|
||||
|
||||
private:
|
||||
void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
|
||||
{
|
||||
if (!f.empty()) {
|
||||
this->vtable = f.vtable;
|
||||
f.vtable->manager(f.functor, this->functor,
|
||||
boost::detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
void assign_to(Functor f)
|
||||
{
|
||||
static vtable_type stored_vtable(f);
|
||||
if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
|
||||
else vtable = 0;
|
||||
}
|
||||
template<typename Functor,typename Allocator>
|
||||
void assign_to_a(Functor f,Allocator a)
|
||||
{
|
||||
static vtable_type stored_vtable(f,a);
|
||||
if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable;
|
||||
else vtable = 0;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||
inline void swap(BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>& f1,
|
||||
BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>& f2)
|
||||
{
|
||||
f1.swap(f2);
|
||||
}
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||
typename BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>::result_type
|
||||
BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
||||
::operator()(BOOST_FUNCTION_PARMS) const
|
||||
{
|
||||
if (this->empty())
|
||||
boost::throw_exception(bad_function_call());
|
||||
|
||||
return static_cast<vtable_type*>(vtable)->invoker
|
||||
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Poison comparisons between boost::function objects of the same type.
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||
void operator==(const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS>&,
|
||||
const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS>&);
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||
void operator!=(const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS>&,
|
||||
const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS>& );
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS == 0
|
||||
#define BOOST_FUNCTION_PARTIAL_SPEC R (void)
|
||||
#else
|
||||
#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
|
||||
#endif
|
||||
|
||||
template<typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS>
|
||||
class function<BOOST_FUNCTION_PARTIAL_SPEC>
|
||||
: public BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
|
||||
{
|
||||
typedef BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> base_type;
|
||||
typedef function self_type;
|
||||
|
||||
struct clear_type {};
|
||||
|
||||
public:
|
||||
|
||||
function() : base_type() {}
|
||||
|
||||
template<typename Functor>
|
||||
function(Functor f
|
||||
#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)
|
||||
{
|
||||
}
|
||||
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
|
||||
function(clear_type*) : base_type() {}
|
||||
#endif
|
||||
|
||||
function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
|
||||
|
||||
function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
|
||||
|
||||
self_type& operator=(const self_type& f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
typename enable_if_c<
|
||||
(boost::type_traits::ice_not<
|
||||
(is_integral<Functor>::value)>::value),
|
||||
self_type&>::type
|
||||
#else
|
||||
self_type&
|
||||
#endif
|
||||
operator=(Functor f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
self_type& operator=(clear_type*)
|
||||
{
|
||||
this->clear();
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
|
||||
self_type& operator=(const base_type& f)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
#undef BOOST_FUNCTION_PARTIAL_SPEC
|
||||
#endif // have partial specialization
|
||||
|
||||
} // end namespace boost
|
||||
|
||||
// Cleanup after ourselves...
|
||||
#undef BOOST_FUNCTION_VTABLE
|
||||
#undef BOOST_FUNCTION_COMMA
|
||||
#undef BOOST_FUNCTION_FUNCTION
|
||||
#undef BOOST_FUNCTION_FUNCTION_INVOKER
|
||||
#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
|
||||
#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
|
||||
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
|
||||
#undef BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
#undef BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
#undef BOOST_FUNCTION_PARMS
|
||||
#undef BOOST_FUNCTION_PARM
|
||||
#undef BOOST_FUNCTION_ARGS
|
||||
#undef BOOST_FUNCTION_ARG_TYPE
|
||||
#undef BOOST_FUNCTION_ARG_TYPES
|
||||
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
#undef BOOST_FUNCTION_RETURN
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( pop )
|
||||
#endif
|
||||
@ -1,26 +0,0 @@
|
||||
#!/usr/bin/perl -w
|
||||
#
|
||||
# Boost.Function library
|
||||
#
|
||||
# Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
# distribution is subject to the Boost Software License, Version
|
||||
# 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
#
|
||||
# For more information, see http://www.boost.org
|
||||
use English;
|
||||
|
||||
if ($#ARGV < 0) {
|
||||
print "Usage: perl gen_function_N <number of arguments>\n";
|
||||
exit;
|
||||
}
|
||||
|
||||
|
||||
$totalNumArgs = $ARGV[0];
|
||||
for ($numArgs = 0; $numArgs <= $totalNumArgs; ++$numArgs) {
|
||||
open OUT, ">function$numArgs.hpp";
|
||||
print OUT "#define BOOST_FUNCTION_NUM_ARGS $numArgs\n";
|
||||
print OUT "#include <boost/function/detail/maybe_include.hpp>\n";
|
||||
print OUT "#undef BOOST_FUNCTION_NUM_ARGS\n";
|
||||
close OUT;
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
// Copyright Douglas Gregor 2004.
|
||||
// Copyright 2005 Peter Dimov
|
||||
|
||||
// Use, modification and distribution is subject to
|
||||
// the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
#ifndef BOOST_FUNCTION_EQUAL_HPP
|
||||
#define BOOST_FUNCTION_EQUAL_HPP
|
||||
|
||||
namespace boost {
|
||||
|
||||
template<typename F, typename G>
|
||||
bool function_equal_impl(const F& f, const G& g, long)
|
||||
{ return f == g; }
|
||||
|
||||
// function_equal_impl needs to be unqualified to pick
|
||||
// user overloads on two-phase compilers
|
||||
|
||||
template<typename F, typename G>
|
||||
bool function_equal(const F& f, const G& g)
|
||||
{ return function_equal_impl(f, g, 0); }
|
||||
|
||||
} // end namespace boost
|
||||
|
||||
#endif // BOOST_FUNCTION_EQUAL_HPP
|
||||
20
index.html
20
index.html
@ -1,20 +0,0 @@
|
||||
<html>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/function.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/function.html">../../doc/html/function.html</a> <hr>
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
||||
</body>
|
||||
</html>
|
||||
@ -1,63 +0,0 @@
|
||||
# Function library
|
||||
|
||||
# Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
# distribution is subject to the Boost Software License, Version
|
||||
# 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
project
|
||||
: source-location $(BOOST_ROOT)
|
||||
;
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
|
||||
{
|
||||
|
||||
test-suite function
|
||||
:
|
||||
[ run libs/function/test/function_test.cpp : : : : lib_function_test ]
|
||||
|
||||
[ run libs/function/test/function_n_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/allocator_test.cpp ../../../libs/test/build//boost_test_exec_monitor : : : : ]
|
||||
|
||||
[ run libs/function/test/stateless_test.cpp ../../../libs/test/build//boost_test_exec_monitor : : : : ]
|
||||
|
||||
[ run libs/function/test/lambda_test.cpp ../../../libs/test/build//boost_test_exec_monitor : : : : ]
|
||||
|
||||
[ compile-fail libs/function/test/function_test_fail1.cpp : : : : ]
|
||||
|
||||
[ compile-fail libs/function/test/function_test_fail2.cpp : : : : ]
|
||||
|
||||
[ compile libs/function/test/function_30.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_arith_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_arith_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/sum_avg_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/sum_avg_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/mem_fun_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/mem_fun_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/std_bind_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/std_bind_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains2_test.cpp : : : : ]
|
||||
|
||||
;
|
||||
}
|
||||
|
||||
@ -1,133 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <cassert>
|
||||
#include <functional>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
static int alloc_count = 0;
|
||||
static int dealloc_count = 0;
|
||||
|
||||
template<typename T>
|
||||
struct counting_allocator : public std::allocator<T>
|
||||
{
|
||||
template<typename U>
|
||||
struct rebind
|
||||
{
|
||||
typedef counting_allocator<U> other;
|
||||
};
|
||||
|
||||
counting_allocator()
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
counting_allocator( counting_allocator<U> )
|
||||
{
|
||||
}
|
||||
|
||||
T* allocate(std::size_t n)
|
||||
{
|
||||
alloc_count++;
|
||||
return std::allocator<T>::allocate(n);
|
||||
}
|
||||
|
||||
void deallocate(T* p, std::size_t n)
|
||||
{
|
||||
dealloc_count++;
|
||||
std::allocator<T>::deallocate(p, n);
|
||||
}
|
||||
};
|
||||
|
||||
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; }
|
||||
};
|
||||
|
||||
static int do_minus(int x, int y) { return x-y; }
|
||||
|
||||
template <typename base>
|
||||
struct DoNothing: base
|
||||
{
|
||||
void operator()() const {}
|
||||
};
|
||||
|
||||
static void do_nothing() {}
|
||||
|
||||
int
|
||||
test_main(int, char*[])
|
||||
{
|
||||
function2<int, int, int> f;
|
||||
f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
|
||||
f.clear();
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||
f.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
f.assign( plus_int<disable_small_object_optimization>(), std::allocator<int>() );
|
||||
f.clear();
|
||||
f.assign( plus_int<enable_small_object_optimization>(), std::allocator<int>() );
|
||||
f.clear();
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f.assign( &do_minus, counting_allocator<int>() );
|
||||
f.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();
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||
fv.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
fv.assign( DoNothing<disable_small_object_optimization>(), std::allocator<int>() );
|
||||
fv.clear();
|
||||
fv.assign( DoNothing<enable_small_object_optimization>(), std::allocator<int>() );
|
||||
fv.clear();
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv.assign( &do_nothing, counting_allocator<int>() );
|
||||
fv.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
fv.assign( &do_nothing, std::allocator<int>() );
|
||||
fv.clear();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,88 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2004.
|
||||
// Copyright 2005 Peter Dimov
|
||||
|
||||
// Use, modification and distribution is subject to
|
||||
// the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
static int forty_two()
|
||||
{
|
||||
return 42;
|
||||
}
|
||||
|
||||
struct Seventeen
|
||||
{
|
||||
int operator()() const
|
||||
{
|
||||
return 17;
|
||||
}
|
||||
};
|
||||
|
||||
bool operator==(const Seventeen&, const Seventeen&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
struct ReturnInt
|
||||
{
|
||||
explicit ReturnInt(int value) : value(value)
|
||||
{
|
||||
}
|
||||
|
||||
int operator()() const
|
||||
{
|
||||
return value;
|
||||
}
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
bool operator==(const ReturnInt& x, const ReturnInt& y)
|
||||
{
|
||||
return x.value == y.value;
|
||||
}
|
||||
|
||||
bool operator!=(const ReturnInt& x, const ReturnInt& y)
|
||||
{
|
||||
return x.value != y.value;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function0<int> fn;
|
||||
|
||||
fn = &forty_two;
|
||||
|
||||
BOOST_TEST( fn() == 42 );
|
||||
|
||||
BOOST_TEST( fn.contains(&forty_two) );
|
||||
BOOST_TEST( !fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(12) ) );
|
||||
|
||||
fn = Seventeen();
|
||||
|
||||
BOOST_TEST( fn() == 17 );
|
||||
|
||||
BOOST_TEST( !fn.contains( &forty_two ) );
|
||||
BOOST_TEST( fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(12) ) );
|
||||
|
||||
fn = ReturnInt(12);
|
||||
|
||||
BOOST_TEST( fn() == 12 );
|
||||
|
||||
BOOST_TEST( !fn.contains( &forty_two ) );
|
||||
BOOST_TEST( !fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( fn.contains( ReturnInt(12) ) );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,226 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2004. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
static int forty_two() { return 42; }
|
||||
|
||||
struct Seventeen
|
||||
{
|
||||
int operator()() const { return 17; }
|
||||
};
|
||||
|
||||
struct ReturnInt
|
||||
{
|
||||
explicit ReturnInt(int value) : value(value) {}
|
||||
|
||||
int operator()() const { return value; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
bool operator==(const ReturnInt& x, const ReturnInt& y)
|
||||
{ return x.value == y.value; }
|
||||
|
||||
bool operator!=(const ReturnInt& x, const ReturnInt& y)
|
||||
{ return x.value != y.value; }
|
||||
|
||||
namespace contain_test {
|
||||
|
||||
struct ReturnIntFE
|
||||
{
|
||||
explicit ReturnIntFE(int value) : value(value) {}
|
||||
|
||||
int operator()() const { return value; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
|
||||
namespace contain_test {
|
||||
# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
|
||||
{ return x.value == y.value; }
|
||||
# else
|
||||
bool function_equal_impl(const ReturnIntFE& x, const ReturnIntFE& y, int)
|
||||
{ return x.value == y.value; }
|
||||
# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
}
|
||||
#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
namespace boost {
|
||||
# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
bool
|
||||
function_equal(const contain_test::ReturnIntFE& x,
|
||||
const contain_test::ReturnIntFE& y)
|
||||
{ return x.value == y.value; }
|
||||
# else
|
||||
bool
|
||||
function_equal_impl(const contain_test::ReturnIntFE& x,
|
||||
const contain_test::ReturnIntFE& y, int)
|
||||
{ return x.value == y.value; }
|
||||
# endif
|
||||
}
|
||||
#endif
|
||||
|
||||
static void target_test()
|
||||
{
|
||||
boost::function0<int> f;
|
||||
|
||||
f = &forty_two;
|
||||
BOOST_CHECK(*f.target<int (*)()>() == &forty_two);
|
||||
BOOST_CHECK(!f.target<Seventeen>());
|
||||
|
||||
f = Seventeen();
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<Seventeen>());
|
||||
|
||||
Seventeen this_seventeen;
|
||||
f = boost::ref(this_seventeen);
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<Seventeen>());
|
||||
BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
|
||||
}
|
||||
|
||||
static void equal_test()
|
||||
{
|
||||
boost::function0<int> f;
|
||||
|
||||
f = &forty_two;
|
||||
BOOST_CHECK(f == &forty_two);
|
||||
BOOST_CHECK(f != ReturnInt(17));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two == f);
|
||||
BOOST_CHECK(ReturnInt(17) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(&forty_two));
|
||||
|
||||
f = ReturnInt(17);
|
||||
BOOST_CHECK(f != &forty_two);
|
||||
BOOST_CHECK(f == ReturnInt(17));
|
||||
BOOST_CHECK(f != ReturnInt(16));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two != f);
|
||||
BOOST_CHECK(ReturnInt(17) == f);
|
||||
BOOST_CHECK(ReturnInt(16) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(ReturnInt(17)));
|
||||
|
||||
f = contain_test::ReturnIntFE(17);
|
||||
BOOST_CHECK(f != &forty_two);
|
||||
BOOST_CHECK(f == contain_test::ReturnIntFE(17));
|
||||
BOOST_CHECK(f != contain_test::ReturnIntFE(16));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two != f);
|
||||
BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
|
||||
BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
boost::function<int(void)> g;
|
||||
|
||||
g = &forty_two;
|
||||
BOOST_CHECK(g == &forty_two);
|
||||
BOOST_CHECK(g != ReturnInt(17));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two == g);
|
||||
BOOST_CHECK(ReturnInt(17) != g);
|
||||
# endif
|
||||
|
||||
g = ReturnInt(17);
|
||||
BOOST_CHECK(g != &forty_two);
|
||||
BOOST_CHECK(g == ReturnInt(17));
|
||||
BOOST_CHECK(g != ReturnInt(16));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two != g);
|
||||
BOOST_CHECK(ReturnInt(17) == g);
|
||||
BOOST_CHECK(ReturnInt(16) != g);
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
static void ref_equal_test()
|
||||
{
|
||||
{
|
||||
ReturnInt ri(17);
|
||||
boost::function0<int> f = boost::ref(ri);
|
||||
|
||||
// References and values are equal
|
||||
BOOST_CHECK(f == boost::ref(ri));
|
||||
BOOST_CHECK(f == ri);
|
||||
BOOST_CHECK(boost::ref(ri) == f);
|
||||
BOOST_CHECK(!(f != boost::ref(ri)));
|
||||
BOOST_CHECK(!(f != ri));
|
||||
BOOST_CHECK(!(boost::ref(ri) != f));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri == f);
|
||||
BOOST_CHECK(!(ri != f));
|
||||
#endif
|
||||
|
||||
// Values equal, references inequal
|
||||
ReturnInt ri2(17);
|
||||
BOOST_CHECK(f == ri2);
|
||||
BOOST_CHECK(f != boost::ref(ri2));
|
||||
BOOST_CHECK(boost::ref(ri2) != f);
|
||||
BOOST_CHECK(!(f != ri2));
|
||||
BOOST_CHECK(!(f == boost::ref(ri2)));
|
||||
BOOST_CHECK(!(boost::ref(ri2) == f));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri2 == f);
|
||||
BOOST_CHECK(!(ri2 != f));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
{
|
||||
ReturnInt ri(17);
|
||||
boost::function<int(void)> f = boost::ref(ri);
|
||||
|
||||
// References and values are equal
|
||||
BOOST_CHECK(f == boost::ref(ri));
|
||||
BOOST_CHECK(f == ri);
|
||||
BOOST_CHECK(boost::ref(ri) == f);
|
||||
BOOST_CHECK(!(f != boost::ref(ri)));
|
||||
BOOST_CHECK(!(f != ri));
|
||||
BOOST_CHECK(!(boost::ref(ri) != f));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri == f);
|
||||
BOOST_CHECK(!(ri != f));
|
||||
# endif
|
||||
|
||||
// Values equal, references inequal
|
||||
ReturnInt ri2(17);
|
||||
BOOST_CHECK(f == ri2);
|
||||
BOOST_CHECK(f != boost::ref(ri2));
|
||||
BOOST_CHECK(boost::ref(ri2) != f);
|
||||
BOOST_CHECK(!(f != ri2));
|
||||
BOOST_CHECK(!(f == boost::ref(ri2)));
|
||||
BOOST_CHECK(!(boost::ref(ri2) == f));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri2 == f);
|
||||
BOOST_CHECK(!(ri2 != f));
|
||||
# endif
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
target_test();
|
||||
equal_test();
|
||||
ref_equal_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,25 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
// Make sure we don't try to redefine function2
|
||||
#include <boost/function/function2.hpp>
|
||||
|
||||
// Define all Boost.Function class templates up to 30 arguments
|
||||
#define BOOST_FUNCTION_MAX_ARGS 30
|
||||
#include <boost/function.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function0<float> f0;
|
||||
|
||||
boost::function30<float, int, int, int, int, int, int, int, int, int, int,
|
||||
int, int, int, int, int, int, int, int, int, int,
|
||||
int, int, int, int, int, int, int, int, int, int> f30;
|
||||
return 0;
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
|
||||
|
||||
float mul_ints(int x, int y) { return ((float)x) * y; }
|
||||
struct int_div {
|
||||
float operator()(int x, int y) const { return ((float)x)/y; };
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function<float (int x, int y)> f;
|
||||
f = int_div();
|
||||
std::cout << f(5, 3) << std::endl;
|
||||
if (f)
|
||||
std::cout << f(5, 3) << std::endl;
|
||||
else
|
||||
std::cout << "f has no target, so it is unsafe to call" << std::endl;
|
||||
f = 0;
|
||||
f = &mul_ints;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,32 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
|
||||
float mul_ints(int x, int y) { return ((float)x) * y; }
|
||||
struct int_div {
|
||||
float operator()(int x, int y) const { return ((float)x)/y; };
|
||||
};
|
||||
int main()
|
||||
{
|
||||
boost::function2<float, int, int> f;
|
||||
f = int_div();
|
||||
std::cout << f(5, 3) << std::endl;
|
||||
if (f)
|
||||
std::cout << f(5, 3) << std::endl;
|
||||
else
|
||||
std::cout << "f has no target, so it is unsafe to call" << std::endl;
|
||||
f = 0;
|
||||
f = &mul_ints;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,648 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <functional>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
|
||||
using namespace boost;
|
||||
using std::string;
|
||||
using std::negate;
|
||||
|
||||
int global_int;
|
||||
|
||||
struct write_five_obj { void operator()() const { global_int = 5; } };
|
||||
struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
|
||||
static void write_five() { global_int = 5; }
|
||||
static void write_three() { global_int = 3; }
|
||||
struct generate_five_obj { int operator()() const { return 5; } };
|
||||
struct generate_three_obj { int operator()() const { return 3; } };
|
||||
static int generate_five() { return 5; }
|
||||
static int generate_three() { return 3; }
|
||||
static string identity_str(const string& s) { return s; }
|
||||
static string string_cat(const string& s1, const string& s2) { return s1+s2; }
|
||||
static int sum_ints(int x, int y) { return x+y; }
|
||||
|
||||
struct write_const_1_nonconst_2
|
||||
{
|
||||
void operator()() { global_int = 2; }
|
||||
void operator()() const { global_int = 1; }
|
||||
};
|
||||
|
||||
struct add_to_obj
|
||||
{
|
||||
add_to_obj(int v) : value(v) {}
|
||||
|
||||
int operator()(int x) const { return value + x; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
static void
|
||||
test_zero_args()
|
||||
{
|
||||
typedef function0<void> func_void_type;
|
||||
|
||||
write_five_obj five = write_five_obj(); // Initialization for Borland C++ 5.5
|
||||
write_three_obj three = write_three_obj(); // Ditto
|
||||
|
||||
// Default construction
|
||||
func_void_type v1;
|
||||
BOOST_CHECK(v1.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v1.clear();
|
||||
BOOST_CHECK(!v1);
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = v1;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v1 = five;
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = (v1);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear
|
||||
v1 = 0;
|
||||
BOOST_CHECK(v1.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = &write_five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = &write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Construction from another function (that is empty)
|
||||
v1.clear();
|
||||
func_void_type v2(v1);
|
||||
BOOST_CHECK(!v2? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v2 = three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v2 = (five);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
v2.clear();
|
||||
BOOST_CHECK(v2.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v2 = (&write_five);
|
||||
BOOST_CHECK(v2? true : false);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Swapping
|
||||
v1 = five;
|
||||
swap(v1, v2);
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
swap(v1, v2);
|
||||
v1.clear();
|
||||
|
||||
// Assignment
|
||||
v2 = five;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a function from an empty function
|
||||
v2 = v1;
|
||||
BOOST_CHECK(v2.empty());
|
||||
|
||||
// Assignment to a function from a function with a functor
|
||||
v1 = three;
|
||||
v2 = v1;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assign to a function from a function with a function
|
||||
v2 = &write_five;
|
||||
v1 = v2;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Construct a function given another function containing a function
|
||||
func_void_type v3(v1);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v3.clear();
|
||||
BOOST_CHECK(!v3? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v3 = three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v3 = five;
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v3.clear();
|
||||
BOOST_CHECK(v3.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v3 = &write_five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v3 = &write_three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v3 = five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Construction of a function from a function containing a functor
|
||||
func_void_type v4(v3);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v4 = three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v4 = five;
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v4 = &write_five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v4 = &write_three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v4 = five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Construction of a function from a functor
|
||||
func_void_type v5(five);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v5 = three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v5 = five;
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v5 = &write_five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v5 = &write_three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v5 = five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Construction of a function from a function
|
||||
func_void_type v6(&write_five);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v6 = three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v6 = five;
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v6 = &write_five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v6 = &write_three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v6 = five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Const vs. non-const
|
||||
// Initialization for Borland C++ 5.5
|
||||
write_const_1_nonconst_2 one_or_two = write_const_1_nonconst_2();
|
||||
const function0<void> v7(one_or_two);
|
||||
function0<void> v8(one_or_two);
|
||||
|
||||
global_int = 0;
|
||||
v7();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
|
||||
global_int = 0;
|
||||
v8();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
|
||||
// Test construction from 0 and comparison to 0
|
||||
func_void_type v9(0);
|
||||
BOOST_CHECK(v9 == 0);
|
||||
# if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540 || defined(BOOST_STRICT_CONFIG)
|
||||
BOOST_CHECK(0 == v9);
|
||||
#else
|
||||
BOOST_CHECK(v9.empty());
|
||||
#endif
|
||||
|
||||
// Test return values
|
||||
typedef function0<int> func_int_type;
|
||||
// Initialization for Borland C++ 5.5
|
||||
generate_five_obj gen_five = generate_five_obj();
|
||||
generate_three_obj gen_three = generate_three_obj();
|
||||
func_int_type i0(gen_five);
|
||||
|
||||
BOOST_CHECK(i0() == 5);
|
||||
i0 = gen_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
i0 = &generate_five;
|
||||
BOOST_CHECK(i0() == 5);
|
||||
i0 = &generate_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_CHECK(i0? true : false);
|
||||
i0.clear();
|
||||
BOOST_CHECK(!i0? true : false);
|
||||
|
||||
// Test return values with compatible types
|
||||
typedef function0<long> func_long_type;
|
||||
func_long_type i1(gen_five);
|
||||
|
||||
BOOST_CHECK(i1() == 5);
|
||||
i1 = gen_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
i1 = &generate_five;
|
||||
BOOST_CHECK(i1() == 5);
|
||||
i1 = &generate_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_CHECK(i1? true : false);
|
||||
i1.clear();
|
||||
BOOST_CHECK(!i1? true : false);
|
||||
}
|
||||
|
||||
static void
|
||||
test_one_arg()
|
||||
{
|
||||
negate<int> neg = negate<int>(); // Initialization for Borland C++ 5.5
|
||||
|
||||
function1<int, int> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
|
||||
function1<string, string> id(&identity_str);
|
||||
BOOST_CHECK(id("str") == "str");
|
||||
|
||||
function1<std::string, const char*> id2(&identity_str);
|
||||
BOOST_CHECK(id2("foo") == "foo");
|
||||
|
||||
add_to_obj add_to(5);
|
||||
function1<int, int> f2(add_to);
|
||||
BOOST_CHECK(f2(3) == 8);
|
||||
|
||||
const function1<int, int> cf2(add_to);
|
||||
BOOST_CHECK(cf2(3) == 8);
|
||||
}
|
||||
|
||||
static void
|
||||
test_two_args()
|
||||
{
|
||||
function2<string, const string&, const string&> cat(&string_cat);
|
||||
BOOST_CHECK(cat("str", "ing") == "string");
|
||||
|
||||
function2<int, short, short> sum(&sum_ints);
|
||||
BOOST_CHECK(sum(2, 3) == 5);
|
||||
}
|
||||
|
||||
static void
|
||||
test_emptiness()
|
||||
{
|
||||
function0<float> f1;
|
||||
BOOST_CHECK(f1.empty());
|
||||
|
||||
function0<float> f2;
|
||||
f2 = f1;
|
||||
BOOST_CHECK(f2.empty());
|
||||
|
||||
function0<double> f3;
|
||||
f3 = f2;
|
||||
BOOST_CHECK(f3.empty());
|
||||
}
|
||||
|
||||
struct X {
|
||||
X(int v) : value(v) {}
|
||||
|
||||
int twice() const { return 2*value; }
|
||||
int plus(int v) { return value + v; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
static void
|
||||
test_member_functions()
|
||||
{
|
||||
|
||||
boost::function1<int, X*> f1(&X::twice);
|
||||
|
||||
X one(1);
|
||||
X five(5);
|
||||
|
||||
BOOST_CHECK(f1(&one) == 2);
|
||||
BOOST_CHECK(f1(&five) == 10);
|
||||
|
||||
boost::function1<int, X*> f1_2;
|
||||
f1_2 = &X::twice;
|
||||
|
||||
BOOST_CHECK(f1_2(&one) == 2);
|
||||
BOOST_CHECK(f1_2(&five) == 10);
|
||||
|
||||
boost::function2<int, X&, int> f2(&X::plus);
|
||||
BOOST_CHECK(f2(one, 3) == 4);
|
||||
BOOST_CHECK(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
int operator()(int x, int y) const { return x+y; }
|
||||
|
||||
add_with_throw_on_copy() {}
|
||||
|
||||
add_with_throw_on_copy(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
}
|
||||
|
||||
add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
}
|
||||
};
|
||||
|
||||
static void
|
||||
test_ref()
|
||||
{
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function2<int, int, int> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
}
|
||||
catch(std::runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
test_one_arg();
|
||||
test_two_args();
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
return 0;
|
||||
}
|
||||
@ -1,27 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
|
||||
|
||||
struct stateful_type { int operator()(int) const { return 0; } };
|
||||
|
||||
int main()
|
||||
{
|
||||
stateful_type a_function_object;
|
||||
boost::function<int (int)> f;
|
||||
f = boost::ref(a_function_object);
|
||||
|
||||
boost::function<int (int)> f2(f);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,27 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
|
||||
|
||||
struct stateful_type { int operator()(int) const { return 0; } };
|
||||
|
||||
int main()
|
||||
{
|
||||
stateful_type a_function_object;
|
||||
boost::function1<int, int> f;
|
||||
f = boost::ref(a_function_object);
|
||||
|
||||
boost::function1<int, int> f2(f);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,682 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
using namespace boost;
|
||||
using namespace std;
|
||||
|
||||
int global_int;
|
||||
|
||||
struct write_five_obj { void operator()() const { global_int = 5; } };
|
||||
struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
|
||||
static void write_five() { global_int = 5; }
|
||||
static void write_three() { global_int = 3; }
|
||||
struct generate_five_obj { int operator()() const { return 5; } };
|
||||
struct generate_three_obj { int operator()() const { return 3; } };
|
||||
static int generate_five() { return 5; }
|
||||
static int generate_three() { return 3; }
|
||||
static string identity_str(const string& s) { return s; }
|
||||
static string string_cat(const string& s1, const string& s2) { return s1+s2; }
|
||||
static int sum_ints(int x, int y) { return x+y; }
|
||||
|
||||
struct write_const_1_nonconst_2
|
||||
{
|
||||
void operator()() { global_int = 2; }
|
||||
void operator()() const { global_int = 1; }
|
||||
};
|
||||
|
||||
struct add_to_obj
|
||||
{
|
||||
add_to_obj(int v) : value(v) {}
|
||||
|
||||
int operator()(int x) const { return value + x; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
static void
|
||||
test_zero_args()
|
||||
{
|
||||
typedef function<void ()> func_void_type;
|
||||
|
||||
write_five_obj five;
|
||||
write_three_obj three;
|
||||
|
||||
// Default construction
|
||||
func_void_type v1;
|
||||
BOOST_CHECK(v1.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = five;
|
||||
BOOST_CHECK(v1 != 0);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v1.clear();
|
||||
BOOST_CHECK(v1 == 0);
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = v1;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v1 = five;
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = (v1);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear
|
||||
v1 = 0;
|
||||
BOOST_CHECK(0 == v1);
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
BOOST_CHECK(0 != v1);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = &write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Construction from another function (that is empty)
|
||||
v1.clear();
|
||||
func_void_type v2(v1);
|
||||
BOOST_CHECK(!v2? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v2 = three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v2 = (five);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
v2.clear();
|
||||
BOOST_CHECK(v2.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
|
||||
BOOST_CHECK(v2? true : false);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Swapping
|
||||
v1 = five;
|
||||
swap(v1, v2);
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
swap(v1, v2);
|
||||
v1.clear();
|
||||
|
||||
// Assignment
|
||||
v2 = five;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a function from an empty function
|
||||
v2 = v1;
|
||||
BOOST_CHECK(v2.empty());
|
||||
|
||||
// Assignment to a function from a function with a functor
|
||||
v1 = three;
|
||||
v2 = v1;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assign to a function from a function with a function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
v1 = v2;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Construct a function given another function containing a function
|
||||
func_void_type v3(v1);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v3.clear();
|
||||
BOOST_CHECK(!v3? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v3 = three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v3 = five;
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v3.clear();
|
||||
BOOST_CHECK(v3.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v3 = &write_five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v3 = &write_three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v3 = five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Construction of a function from a function containing a functor
|
||||
func_void_type v4(v3);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v4 = three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v4 = five;
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v4 = &write_five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v4 = &write_three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v4 = five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Construction of a function from a functor
|
||||
func_void_type v5(five);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v5 = three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v5 = five;
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v5 = &write_five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v5 = &write_three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v5 = five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Construction of a function from a function
|
||||
func_void_type v6(&write_five);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v6 = three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v6 = five;
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v6 = &write_five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v6 = &write_three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v6 = five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
|
||||
// Const vs. non-const
|
||||
write_const_1_nonconst_2 one_or_two;
|
||||
const function<void ()> v7(one_or_two);
|
||||
function<void ()> v8(one_or_two);
|
||||
|
||||
global_int = 0;
|
||||
v7();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
|
||||
global_int = 0;
|
||||
v8();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
|
||||
// Test construction from 0 and comparison to 0
|
||||
func_void_type v9(0);
|
||||
BOOST_CHECK(v9 == 0);
|
||||
BOOST_CHECK(0 == v9);
|
||||
|
||||
// Test return values
|
||||
typedef function<int ()> func_int_type;
|
||||
generate_five_obj gen_five;
|
||||
generate_three_obj gen_three;
|
||||
|
||||
func_int_type i0(gen_five);
|
||||
|
||||
BOOST_CHECK(i0() == 5);
|
||||
i0 = gen_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
i0 = &generate_five;
|
||||
BOOST_CHECK(i0() == 5);
|
||||
i0 = &generate_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_CHECK(i0? true : false);
|
||||
i0.clear();
|
||||
BOOST_CHECK(!i0? true : false);
|
||||
|
||||
// Test return values with compatible types
|
||||
typedef function<long ()> func_long_type;
|
||||
func_long_type i1(gen_five);
|
||||
|
||||
BOOST_CHECK(i1() == 5);
|
||||
i1 = gen_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
i1 = &generate_five;
|
||||
BOOST_CHECK(i1() == 5);
|
||||
i1 = &generate_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_CHECK(i1? true : false);
|
||||
i1.clear();
|
||||
BOOST_CHECK(!i1? true : false);
|
||||
}
|
||||
|
||||
static void
|
||||
test_one_arg()
|
||||
{
|
||||
negate<int> neg;
|
||||
|
||||
function<int (int)> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
|
||||
function<string (string)> id(&identity_str);
|
||||
BOOST_CHECK(id("str") == "str");
|
||||
|
||||
function<string (const char*)> id2(&identity_str);
|
||||
BOOST_CHECK(id2("foo") == "foo");
|
||||
|
||||
add_to_obj add_to(5);
|
||||
function<int (int)> f2(add_to);
|
||||
BOOST_CHECK(f2(3) == 8);
|
||||
|
||||
const function<int (int)> cf2(add_to);
|
||||
BOOST_CHECK(cf2(3) == 8);
|
||||
}
|
||||
|
||||
static void
|
||||
test_two_args()
|
||||
{
|
||||
function<string (const string&, const string&)> cat(&string_cat);
|
||||
BOOST_CHECK(cat("str", "ing") == "string");
|
||||
|
||||
function<int (short, short)> sum(&sum_ints);
|
||||
BOOST_CHECK(sum(2, 3) == 5);
|
||||
}
|
||||
|
||||
static void
|
||||
test_emptiness()
|
||||
{
|
||||
function<float ()> f1;
|
||||
BOOST_CHECK(f1.empty());
|
||||
|
||||
function<float ()> f2;
|
||||
f2 = f1;
|
||||
BOOST_CHECK(f2.empty());
|
||||
|
||||
function<double ()> f3;
|
||||
f3 = f2;
|
||||
BOOST_CHECK(f3.empty());
|
||||
}
|
||||
|
||||
struct X {
|
||||
X(int v) : value(v) {}
|
||||
|
||||
int twice() const { return 2*value; }
|
||||
int plus(int v) { return value + v; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
static void
|
||||
test_member_functions()
|
||||
{
|
||||
boost::function<int (X*)> f1(&X::twice);
|
||||
|
||||
X one(1);
|
||||
X five(5);
|
||||
|
||||
BOOST_CHECK(f1(&one) == 2);
|
||||
BOOST_CHECK(f1(&five) == 10);
|
||||
|
||||
boost::function<int (X*)> f1_2;
|
||||
f1_2 = &X::twice;
|
||||
|
||||
BOOST_CHECK(f1_2(&one) == 2);
|
||||
BOOST_CHECK(f1_2(&five) == 10);
|
||||
|
||||
boost::function<int (X&, int)> f2(&X::plus);
|
||||
BOOST_CHECK(f2(one, 3) == 4);
|
||||
BOOST_CHECK(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
int operator()(int x, int y) const { return x+y; }
|
||||
|
||||
add_with_throw_on_copy() {}
|
||||
|
||||
add_with_throw_on_copy(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw runtime_error("But this CAN'T throw");
|
||||
}
|
||||
|
||||
add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw runtime_error("But this CAN'T throw");
|
||||
}
|
||||
};
|
||||
|
||||
static void
|
||||
test_ref()
|
||||
{
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function<int (int, int)> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
}
|
||||
catch(runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
static void test_exception()
|
||||
{
|
||||
boost::function<int (int, int)> f;
|
||||
try {
|
||||
f(5, 4);
|
||||
BOOST_CHECK(false);
|
||||
}
|
||||
catch(boost::bad_function_call) {
|
||||
// okay
|
||||
}
|
||||
}
|
||||
|
||||
typedef boost::function< void * (void * reader) > reader_type;
|
||||
typedef std::pair<int, reader_type> mapped_type;
|
||||
|
||||
static void test_implicit()
|
||||
{
|
||||
mapped_type m;
|
||||
m = mapped_type();
|
||||
}
|
||||
|
||||
static void test_call_obj(boost::function<int (int, int)> f)
|
||||
{
|
||||
BOOST_CHECK(!f.empty());
|
||||
}
|
||||
|
||||
static void test_call_cref(const boost::function<int (int, int)>& f)
|
||||
{
|
||||
BOOST_CHECK(!f.empty());
|
||||
}
|
||||
|
||||
static void test_call()
|
||||
{
|
||||
test_call_obj(std::plus<int>());
|
||||
test_call_cref(std::plus<int>());
|
||||
}
|
||||
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
test_one_arg();
|
||||
test_two_args();
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_exception();
|
||||
test_implicit();
|
||||
test_call();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright (C) Douglas Gregor 2001-2005. 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>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
int
|
||||
test_main(int, char*[])
|
||||
{
|
||||
function0<int> f1;
|
||||
function0<int> f2;
|
||||
|
||||
if (f1 == f2) {
|
||||
}
|
||||
|
||||
BOOST_ERROR("This should not have compiled.");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,27 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright (C) Douglas Gregor 2001-2005. 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>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
static int bad_fn(float f) { return static_cast<int>(f); }
|
||||
|
||||
int
|
||||
test_main(int, char*[])
|
||||
{
|
||||
function0<int> f1;
|
||||
f1 = bad_fn;
|
||||
|
||||
BOOST_ERROR("This should not have compiled.");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,38 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/lambda/lambda.hpp>
|
||||
#include <boost/lambda/bind.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
using namespace boost::lambda;
|
||||
|
||||
static unsigned
|
||||
func_impl(int arg1, bool arg2, double arg3)
|
||||
{
|
||||
return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
|
||||
function <unsigned(double)> f2 = bind(f1, false, _1);
|
||||
function <unsigned()> f3 = bind(f2, 4.0);
|
||||
|
||||
f3();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,31 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
|
||||
struct X {
|
||||
int foo(int);
|
||||
};
|
||||
int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function<int (X*, int)> f;
|
||||
|
||||
f = &X::foo;
|
||||
|
||||
X x;
|
||||
f(&x, 5);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,31 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
|
||||
struct X {
|
||||
int foo(int);
|
||||
};
|
||||
int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function2<int, X*, int> f;
|
||||
|
||||
f = &X::foo;
|
||||
|
||||
X x;
|
||||
f(&x, 5);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
// Boost.Function regression test configuration file
|
||||
|
||||
// From the boost/status directory, run
|
||||
// ./regression --tests ../libs/function/test/regression.cfg -o function.html
|
||||
|
||||
|
||||
run libs/function/test/allocator_test.cpp
|
||||
run libs/function/test/function_n_test.cpp
|
||||
run libs/function/test/function_test.cpp
|
||||
compile-fail libs/function/test/function_test_fail1.cpp
|
||||
compile-fail libs/function/test/function_test_fail2.cpp
|
||||
run libs/function/test/mixin_test.cpp
|
||||
run libs/function/test/policy_test.cpp
|
||||
run libs/function/test/stateless_test.cpp
|
||||
@ -1,38 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <stdexcept>
|
||||
|
||||
struct stateless_integer_add {
|
||||
int operator()(int x, int y) const { return x+y; }
|
||||
|
||||
void* operator new(std::size_t)
|
||||
{
|
||||
throw std::runtime_error("Cannot allocate a stateless_integer_add");
|
||||
}
|
||||
|
||||
void* operator new(std::size_t, void* p)
|
||||
{
|
||||
return p;
|
||||
}
|
||||
|
||||
void operator delete(void*) throw()
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
boost::function2<int, int, int> f;
|
||||
f = stateless_integer_add();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,30 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
|
||||
struct X {
|
||||
int foo(int);
|
||||
};
|
||||
int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function<int (int)> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,30 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
|
||||
struct X {
|
||||
int foo(int);
|
||||
};
|
||||
int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function1<int, int> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
|
||||
void do_sum_avg(int values[], int n, int& sum, float& avg)
|
||||
{
|
||||
sum = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
sum += values[i];
|
||||
avg = (float)sum / n;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
boost::function<void (int values[], int n, int& sum, float& avg)> sum_avg;
|
||||
sum_avg = &do_sum_avg;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
// Function library
|
||||
|
||||
// Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
|
||||
void do_sum_avg(int values[], int n, int& sum, float& avg)
|
||||
{
|
||||
sum = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
sum += values[i];
|
||||
avg = (float)sum / n;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
boost::function4<void, int*, int, int&, float&> sum_avg;
|
||||
sum_avg = &do_sum_avg;
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user