forked from boostorg/function
Compare commits
3 Commits
boost-1.33
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| 49da5be3ed | |||
| 852857457b | |||
| cdb403b298 |
@ -5,7 +5,7 @@
|
||||
<title>History & Compatibility Notes</title>
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para><bold>Version 1.30.0</bold>: </para>
|
||||
<listitem><para><emphasis role="bold">Version 1.30.0</emphasis>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>All features deprecated in version 1.29.0 have
|
||||
been removed from Boost.Function.</para></listitem>
|
||||
@ -32,7 +32,7 @@
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.29.0</bold>:
|
||||
<listitem><para><emphasis role="bold">Version 1.29.0</emphasis>:
|
||||
Boost.Function has been partially redesigned to minimize the
|
||||
interface and make it cleaner. Several seldom- or never-used
|
||||
features of the older Boost.Function have been deprecated and will
|
||||
|
||||
@ -297,7 +297,7 @@
|
||||
<parameter name="aN"><paramtype>argN_type</paramtype></parameter>
|
||||
<effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
|
||||
<returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
@ -719,7 +719,7 @@
|
||||
<parameter name="aN"><paramtype>argN_type</paramtype></parameter>
|
||||
<effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
|
||||
<returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
|
||||
@ -329,8 +329,8 @@ exceptions during assignment or construction.
|
||||
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>
|
||||
function object (which must be
|
||||
<conceptname>EqualityComparable</conceptname>). For instance:</para>
|
||||
|
||||
<programlisting name="function.tutorial.compare">int compute_with_X(X*, int);
|
||||
|
||||
|
||||
@ -1,64 +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/libs/function
|
||||
|
||||
// William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
|
||||
// design of this library.
|
||||
|
||||
#include <boost/preprocessor/iterate.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#ifndef BOOST_FUNCTION_MAX_ARGS
|
||||
# define BOOST_FUNCTION_MAX_ARGS 10
|
||||
#endif // BOOST_FUNCTION_MAX_ARGS
|
||||
|
||||
// Include the prologue here so that the use of file-level iteration
|
||||
// in anything that may be included by function_template.hpp doesn't break
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
// Visual Age C++ doesn't handle the file iteration well
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 0
|
||||
# include <boost/function/function0.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 1
|
||||
# include <boost/function/function1.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 2
|
||||
# include <boost/function/function2.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 3
|
||||
# include <boost/function/function3.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 4
|
||||
# include <boost/function/function4.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 5
|
||||
# include <boost/function/function5.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 6
|
||||
# include <boost/function/function6.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 7
|
||||
# include <boost/function/function7.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 8
|
||||
# include <boost/function/function8.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 9
|
||||
# include <boost/function/function9.hpp>
|
||||
# endif
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 10
|
||||
# include <boost/function/function10.hpp>
|
||||
# endif
|
||||
#else
|
||||
// What is the '3' for?
|
||||
# define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,<boost/function/detail/function_iterate.hpp>))
|
||||
# include BOOST_PP_ITERATE()
|
||||
# undef BOOST_PP_ITERATION_PARAMS_1
|
||||
#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,24 +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/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>
|
||||
#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,698 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2004. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#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/type_traits/is_stateless.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/pending/ct_if.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
# include "boost/utility/enable_if.hpp"
|
||||
#else
|
||||
# include "boost/mpl/bool.hpp"
|
||||
#endif
|
||||
#include <boost/function_equal.hpp>
|
||||
|
||||
// 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 {
|
||||
|
||||
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
|
||||
// The library shipping with MIPSpro 7.3.1.3m has a broken allocator<void>
|
||||
class function_base;
|
||||
|
||||
template<typename Signature,
|
||||
typename Allocator = std::allocator<function_base> >
|
||||
class function;
|
||||
#else
|
||||
template<typename Signature, typename Allocator = std::allocator<void> >
|
||||
class function;
|
||||
#endif
|
||||
|
||||
template<typename Signature, typename Allocator>
|
||||
inline void swap(function<Signature, Allocator>& f1,
|
||||
function<Signature, Allocator>& f2)
|
||||
{
|
||||
f1.swap(f2);
|
||||
}
|
||||
|
||||
} // end namespace boost
|
||||
#endif // have partial specialization
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
namespace function {
|
||||
/**
|
||||
* A union of a function pointer and a void pointer. This is necessary
|
||||
* because 5.2.10/6 allows reinterpret_cast<> to safely cast between
|
||||
* function pointer types and 5.2.9/10 allows static_cast<> to safely
|
||||
* cast between a void pointer and an object pointer. But it is not legal
|
||||
* to cast between a function pointer and a void* (in either direction),
|
||||
* so function requires a union of the two. */
|
||||
union any_pointer
|
||||
{
|
||||
void* obj_ptr;
|
||||
const void* const_obj_ptr;
|
||||
void (*func_ptr)();
|
||||
char data[1];
|
||||
};
|
||||
|
||||
inline any_pointer make_any_pointer(void* o)
|
||||
{
|
||||
any_pointer p;
|
||||
p.obj_ptr = o;
|
||||
return p;
|
||||
}
|
||||
|
||||
inline any_pointer make_any_pointer(const void* o)
|
||||
{
|
||||
any_pointer p;
|
||||
p.const_obj_ptr = o;
|
||||
return p;
|
||||
}
|
||||
|
||||
inline any_pointer make_any_pointer(void (*f)())
|
||||
{
|
||||
any_pointer p;
|
||||
p.func_ptr = f;
|
||||
return p;
|
||||
}
|
||||
|
||||
/**
|
||||
* The unusable class is a placeholder for unused function arguments
|
||||
* It is also completely unusable except that it constructable from
|
||||
* 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
|
||||
};
|
||||
|
||||
// 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 {};
|
||||
struct stateless_function_obj_tag {};
|
||||
|
||||
template<typename F>
|
||||
class get_function_tag
|
||||
{
|
||||
typedef typename ct_if<(is_pointer<F>::value),
|
||||
function_ptr_tag,
|
||||
function_obj_tag>::type ptr_or_obj_tag;
|
||||
|
||||
typedef typename ct_if<(is_member_pointer<F>::value),
|
||||
member_ptr_tag,
|
||||
ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
|
||||
|
||||
typedef typename ct_if<(is_reference_wrapper<F>::value),
|
||||
function_obj_ref_tag,
|
||||
ptr_or_obj_or_mem_tag>::type or_ref_tag;
|
||||
|
||||
public:
|
||||
typedef typename ct_if<(is_stateless<F>::value),
|
||||
stateless_function_obj_tag,
|
||||
or_ref_tag>::type type;
|
||||
};
|
||||
|
||||
// The trivial manager does nothing but return the same pointer (if we
|
||||
// are cloning) or return the null pointer (if we are deleting).
|
||||
template<typename F>
|
||||
struct trivial_manager
|
||||
{
|
||||
static inline any_pointer
|
||||
get(any_pointer f, functor_manager_operation_type op)
|
||||
{
|
||||
switch (op) {
|
||||
case clone_functor_tag: return f;
|
||||
|
||||
case destroy_functor_tag:
|
||||
return make_any_pointer(reinterpret_cast<void*>(0));
|
||||
|
||||
case check_functor_type_tag:
|
||||
{
|
||||
std::type_info* t = static_cast<std::type_info*>(f.obj_ptr);
|
||||
return BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(F), *t)?
|
||||
f
|
||||
: make_any_pointer(reinterpret_cast<void*>(0));
|
||||
}
|
||||
}
|
||||
|
||||
// Clears up a warning with GCC 3.2.3
|
||||
return make_any_pointer(reinterpret_cast<void*>(0));
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The functor_manager class contains a static function "manage" which
|
||||
* can clone or destroy the given function/function object pointer.
|
||||
*/
|
||||
template<typename Functor, typename Allocator>
|
||||
struct functor_manager
|
||||
{
|
||||
private:
|
||||
typedef Functor functor_type;
|
||||
|
||||
// For function pointers, the manager is trivial
|
||||
static inline any_pointer
|
||||
manager(any_pointer function_ptr,
|
||||
functor_manager_operation_type op,
|
||||
function_ptr_tag)
|
||||
{
|
||||
if (op == clone_functor_tag)
|
||||
return function_ptr;
|
||||
else
|
||||
return make_any_pointer(static_cast<void (*)()>(0));
|
||||
}
|
||||
|
||||
// For function object pointers, we clone the pointer to each
|
||||
// function has its own version.
|
||||
static inline any_pointer
|
||||
manager(any_pointer function_obj_ptr,
|
||||
functor_manager_operation_type op,
|
||||
function_obj_tag)
|
||||
{
|
||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
||||
typedef typename Allocator::template rebind<functor_type>::other
|
||||
allocator_type;
|
||||
typedef typename allocator_type::pointer pointer_type;
|
||||
#else
|
||||
typedef functor_type* pointer_type;
|
||||
#endif // BOOST_NO_STD_ALLOCATOR
|
||||
|
||||
# ifndef BOOST_NO_STD_ALLOCATOR
|
||||
allocator_type allocator;
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
|
||||
if (op == clone_functor_tag) {
|
||||
functor_type* f =
|
||||
static_cast<functor_type*>(function_obj_ptr.obj_ptr);
|
||||
|
||||
// Clone the functor
|
||||
# ifndef BOOST_NO_STD_ALLOCATOR
|
||||
pointer_type copy = allocator.allocate(1);
|
||||
allocator.construct(copy, *f);
|
||||
|
||||
// Get back to the original pointer type
|
||||
functor_type* new_f = static_cast<functor_type*>(copy);
|
||||
# else
|
||||
functor_type* new_f = new functor_type(*f);
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
return make_any_pointer(static_cast<void*>(new_f));
|
||||
}
|
||||
else {
|
||||
/* Cast from the void pointer to the functor pointer type */
|
||||
functor_type* f =
|
||||
reinterpret_cast<functor_type*>(function_obj_ptr.obj_ptr);
|
||||
|
||||
# ifndef BOOST_NO_STD_ALLOCATOR
|
||||
/* Cast from the functor pointer type to the allocator's pointer
|
||||
type */
|
||||
pointer_type victim = static_cast<pointer_type>(f);
|
||||
|
||||
// Destroy and deallocate the functor
|
||||
allocator.destroy(victim);
|
||||
allocator.deallocate(victim, 1);
|
||||
# else
|
||||
delete f;
|
||||
# endif // BOOST_NO_STD_ALLOCATOR
|
||||
|
||||
return make_any_pointer(static_cast<void*>(0));
|
||||
}
|
||||
}
|
||||
public:
|
||||
/* Dispatch to an appropriate manager based on whether we have a
|
||||
function pointer or a function object pointer. */
|
||||
static any_pointer
|
||||
manage(any_pointer functor_ptr, functor_manager_operation_type op)
|
||||
{
|
||||
if (op == check_functor_type_tag) {
|
||||
std::type_info* type =
|
||||
static_cast<std::type_info*>(functor_ptr.obj_ptr);
|
||||
return (BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(Functor), *type)?
|
||||
functor_ptr
|
||||
: make_any_pointer(reinterpret_cast<void*>(0)));
|
||||
}
|
||||
else {
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
return manager(functor_ptr, op, tag_type());
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// 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
|
||||
} // 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() : manager(0)
|
||||
{
|
||||
functor.obj_ptr = 0;
|
||||
}
|
||||
|
||||
// Is this function empty?
|
||||
bool empty() const { return !manager; }
|
||||
|
||||
template<typename Functor>
|
||||
Functor* target()
|
||||
{
|
||||
if (!manager) return 0;
|
||||
|
||||
detail::function::any_pointer result =
|
||||
manager(detail::function::make_any_pointer(&typeid(Functor)),
|
||||
detail::function::check_functor_type_tag);
|
||||
if (!result.obj_ptr) return 0;
|
||||
else {
|
||||
typedef typename detail::function::get_function_tag<Functor>::type tag;
|
||||
return get_functor_pointer<Functor>(tag(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
const Functor* target( Functor * = 0 ) const
|
||||
#else
|
||||
const Functor* target() const
|
||||
#endif
|
||||
{
|
||||
if (!manager) return 0;
|
||||
|
||||
detail::function::any_pointer result =
|
||||
manager(detail::function::make_any_pointer(&typeid(Functor)),
|
||||
detail::function::check_functor_type_tag);
|
||||
if (!result.obj_ptr) return 0;
|
||||
else {
|
||||
typedef typename detail::function::get_function_tag<Functor>::type tag;
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
return get_functor_pointer(tag(), 0, (Functor*)0);
|
||||
#else
|
||||
return get_functor_pointer<Functor>(tag(), 0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
bool contains(const F& f) const
|
||||
{
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
if (const F* fp = this->target( (F*)0 )) {
|
||||
#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::any_pointer (*manager)(
|
||||
detail::function::any_pointer,
|
||||
detail::function::functor_manager_operation_type);
|
||||
detail::function::any_pointer functor;
|
||||
|
||||
private:
|
||||
template<typename Functor>
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
Functor* get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0)
|
||||
#else
|
||||
Functor* get_functor_pointer(detail::function::function_ptr_tag, int)
|
||||
#endif
|
||||
{ return reinterpret_cast<Functor*>(&functor.func_ptr); }
|
||||
|
||||
template<typename Functor, typename Tag>
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
Functor* get_functor_pointer(Tag, long, Functor * = 0)
|
||||
#else
|
||||
Functor* get_functor_pointer(Tag, long)
|
||||
#endif
|
||||
{ return static_cast<Functor*>(functor.obj_ptr); }
|
||||
|
||||
template<typename Functor>
|
||||
const Functor*
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0) const
|
||||
#else
|
||||
get_functor_pointer(detail::function::function_ptr_tag, int) const
|
||||
#endif
|
||||
{ return reinterpret_cast<const Functor*>(&functor.func_ptr); }
|
||||
|
||||
template<typename Functor, typename Tag>
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
const Functor* get_functor_pointer(Tag, long, Functor * = 0) const
|
||||
#else
|
||||
const Functor* get_functor_pointer(Tag, long) const
|
||||
#endif
|
||||
{ return static_cast<const Functor*>(functor.const_obj_ptr); }
|
||||
};
|
||||
|
||||
/**
|
||||
* 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,712 +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
|
||||
|
||||
// Note: this header is a header template and must NOT have multiple-inclusion
|
||||
// protection.
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
#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(arg, BOOST_PP_CAT(BOOST_PP_INC(I),_type));
|
||||
|
||||
#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
|
||||
|
||||
// Type of the default allocator
|
||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
||||
# define BOOST_FUNCTION_DEFAULT_ALLOCATOR std::allocator<function_base>
|
||||
#else
|
||||
# define BOOST_FUNCTION_DEFAULT_ALLOCATOR int
|
||||
#endif // BOOST_NO_STD_ALLOCATOR
|
||||
|
||||
// Comma if nonzero number of arguments
|
||||
#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_STATELESS_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(stateless_void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
|
||||
BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
#define BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER \
|
||||
BOOST_JOIN(get_stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
|
||||
|
||||
#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(any_pointer 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(any_pointer function_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
|
||||
BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static R invoke(any_pointer function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f = (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(any_pointer function_obj_ptr BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj* f = (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_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static R invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)
|
||||
{
|
||||
FunctionObj f = FunctionObj();
|
||||
return f(BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
template<
|
||||
typename FunctionObj,
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS
|
||||
>
|
||||
struct BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
static BOOST_FUNCTION_VOID_RETURN_TYPE
|
||||
invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)
|
||||
|
||||
{
|
||||
FunctionObj f = FunctionObj();
|
||||
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 ct_if<(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 ct_if<(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_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
{
|
||||
typedef typename ct_if<(is_void<R>::value),
|
||||
BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>,
|
||||
BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>
|
||||
>::type type;
|
||||
};
|
||||
|
||||
} // end namespace function
|
||||
} // end namespace detail
|
||||
|
||||
template<
|
||||
typename R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
|
||||
>
|
||||
class BOOST_FUNCTION_FUNCTION : public function_base
|
||||
{
|
||||
public:
|
||||
#ifndef BOOST_NO_VOID_RETURNS
|
||||
typedef R result_type;
|
||||
#else
|
||||
typedef typename detail::function::function_return_type<R>::type
|
||||
result_type;
|
||||
#endif // BOOST_NO_VOID_RETURNS
|
||||
|
||||
private:
|
||||
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 Allocator allocator_type;
|
||||
typedef BOOST_FUNCTION_FUNCTION self_type;
|
||||
|
||||
BOOST_FUNCTION_FUNCTION() : function_base()
|
||||
, invoker(0) {}
|
||||
|
||||
// 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(),
|
||||
invoker(0)
|
||||
{
|
||||
this->assign_to(f);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
BOOST_FUNCTION_FUNCTION(clear_type*) : function_base(), invoker(0) {}
|
||||
#else
|
||||
BOOST_FUNCTION_FUNCTION(int zero) : function_base(), invoker(0)
|
||||
{
|
||||
BOOST_ASSERT(zero == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) :
|
||||
function_base(),
|
||||
invoker(0)
|
||||
{
|
||||
this->assign_to_own(f);
|
||||
}
|
||||
|
||||
~BOOST_FUNCTION_FUNCTION() { clear(); }
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
|
||||
// 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 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)
|
||||
{
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#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;
|
||||
|
||||
self_type(f).swap(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void swap(BOOST_FUNCTION_FUNCTION& other)
|
||||
{
|
||||
if (&other == this)
|
||||
return;
|
||||
|
||||
std::swap(this->manager, other.manager);
|
||||
std::swap(this->functor, other.functor);
|
||||
std::swap(invoker, other.invoker);
|
||||
}
|
||||
|
||||
// Clear out a target, if there is one
|
||||
void clear()
|
||||
{
|
||||
if (this->manager) {
|
||||
function_base::functor =
|
||||
this->manager(this->functor, detail::function::destroy_functor_tag);
|
||||
}
|
||||
|
||||
this->manager = 0;
|
||||
invoker = 0;
|
||||
}
|
||||
|
||||
#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
|
||||
// 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()) {
|
||||
invoker = f.invoker;
|
||||
this->manager = f.manager;
|
||||
this->functor =
|
||||
f.manager(f.functor, detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
void assign_to(Functor f)
|
||||
{
|
||||
typedef typename detail::function::get_function_tag<Functor>::type tag;
|
||||
this->assign_to(f, tag());
|
||||
}
|
||||
|
||||
template<typename FunctionPtr>
|
||||
void assign_to(FunctionPtr f, detail::function::function_ptr_tag)
|
||||
{
|
||||
clear();
|
||||
|
||||
if (f) {
|
||||
typedef typename detail::function::BOOST_FUNCTION_GET_FUNCTION_INVOKER<
|
||||
FunctionPtr,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
actual_invoker_type;
|
||||
|
||||
invoker = &actual_invoker_type::invoke;
|
||||
this->manager =
|
||||
&detail::function::functor_manager<FunctionPtr, Allocator>::manage;
|
||||
this->functor =
|
||||
this->manager(detail::function::make_any_pointer(
|
||||
// should be a reinterpret cast, but some compilers
|
||||
// insist on giving cv-qualifiers to free functions
|
||||
(void (*)())(f)
|
||||
),
|
||||
detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS > 0
|
||||
template<typename MemberPtr>
|
||||
void assign_to(MemberPtr f, detail::function::member_ptr_tag)
|
||||
{
|
||||
this->assign_to(mem_fn(f));
|
||||
}
|
||||
#endif // BOOST_FUNCTION_NUM_ARGS > 0
|
||||
|
||||
template<typename FunctionObj>
|
||||
void assign_to(FunctionObj f, detail::function::function_obj_tag)
|
||||
{
|
||||
if (!detail::function::has_empty_target(boost::addressof(f))) {
|
||||
typedef
|
||||
typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
actual_invoker_type;
|
||||
|
||||
invoker = &actual_invoker_type::invoke;
|
||||
this->manager = &detail::function::functor_manager<
|
||||
FunctionObj, Allocator>::manage;
|
||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
||||
typedef typename Allocator::template rebind<FunctionObj>::other
|
||||
rebound_allocator_type;
|
||||
typedef typename rebound_allocator_type::pointer pointer_type;
|
||||
rebound_allocator_type allocator;
|
||||
pointer_type copy = allocator.allocate(1);
|
||||
allocator.construct(copy, f);
|
||||
|
||||
// Get back to the original pointer type
|
||||
FunctionObj* new_f = static_cast<FunctionObj*>(copy);
|
||||
#else
|
||||
FunctionObj* new_f = new FunctionObj(f);
|
||||
#endif // BOOST_NO_STD_ALLOCATOR
|
||||
this->functor =
|
||||
detail::function::make_any_pointer(static_cast<void*>(new_f));
|
||||
}
|
||||
}
|
||||
|
||||
template<typename FunctionObj>
|
||||
void assign_to(const reference_wrapper<FunctionObj>& f,
|
||||
detail::function::function_obj_ref_tag)
|
||||
{
|
||||
if (!detail::function::has_empty_target(f.get_pointer())) {
|
||||
typedef
|
||||
typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
actual_invoker_type;
|
||||
|
||||
invoker = &actual_invoker_type::invoke;
|
||||
this->manager = &detail::function::trivial_manager<FunctionObj>::get;
|
||||
this->functor =
|
||||
this->manager(
|
||||
detail::function::make_any_pointer(
|
||||
const_cast<FunctionObj*>(f.get_pointer())),
|
||||
detail::function::clone_functor_tag);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename FunctionObj>
|
||||
void assign_to(FunctionObj, detail::function::stateless_function_obj_tag)
|
||||
{
|
||||
typedef
|
||||
typename detail::function::
|
||||
BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER<
|
||||
FunctionObj,
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
>::type
|
||||
actual_invoker_type;
|
||||
invoker = &actual_invoker_type::invoke;
|
||||
this->manager = &detail::function::trivial_manager<FunctionObj>::get;
|
||||
this->functor = detail::function::make_any_pointer(this);
|
||||
}
|
||||
|
||||
typedef result_type (*invoker_type)(detail::function::any_pointer
|
||||
BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS);
|
||||
|
||||
invoker_type invoker;
|
||||
};
|
||||
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
||||
typename Allocator>
|
||||
inline void swap(BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
||||
Allocator
|
||||
>& f1,
|
||||
BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS,
|
||||
Allocator
|
||||
>& f2)
|
||||
{
|
||||
f1.swap(f2);
|
||||
}
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
|
||||
typename Allocator>
|
||||
typename BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
|
||||
Allocator>::result_type
|
||||
BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
|
||||
|
||||
Allocator>
|
||||
::operator()(BOOST_FUNCTION_PARMS) const
|
||||
{
|
||||
if (this->empty())
|
||||
boost::throw_exception(bad_function_call());
|
||||
|
||||
return invoker(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Poison comparisons between boost::function objects of the same type.
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
||||
typename Allocator>
|
||||
void operator==(const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
||||
Allocator>&,
|
||||
const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
||||
Allocator>&);
|
||||
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
|
||||
typename Allocator>
|
||||
void operator!=(const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
||||
Allocator>&,
|
||||
const BOOST_FUNCTION_FUNCTION<
|
||||
R BOOST_FUNCTION_COMMA
|
||||
BOOST_FUNCTION_TEMPLATE_ARGS ,
|
||||
Allocator>&);
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
|
||||
#if BOOST_FUNCTION_NUM_ARGS == 0
|
||||
#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,
|
||||
typename Allocator>
|
||||
class function<BOOST_FUNCTION_PARTIAL_SPEC, Allocator>
|
||||
: public BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
BOOST_FUNCTION_COMMA Allocator>
|
||||
{
|
||||
typedef BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS
|
||||
BOOST_FUNCTION_COMMA Allocator> base_type;
|
||||
typedef function self_type;
|
||||
|
||||
struct clear_type {};
|
||||
|
||||
public:
|
||||
typedef typename base_type::allocator_type allocator_type;
|
||||
|
||||
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)
|
||||
{
|
||||
}
|
||||
|
||||
#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_DEFAULT_ALLOCATOR
|
||||
#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_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
|
||||
#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
|
||||
#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
|
||||
@ -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
|
||||
@ -62,7 +62,6 @@ DEPENDS all : test ;
|
||||
[ run libs/function/test/function_ref_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains2_test.cpp : : : : ]
|
||||
;
|
||||
}
|
||||
|
||||
@ -56,8 +56,6 @@ import testing ;
|
||||
|
||||
[ run libs/function/test/contains_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains2_test.cpp : : : : ]
|
||||
|
||||
;
|
||||
}
|
||||
|
||||
|
||||
@ -41,20 +41,11 @@ struct counting_allocator : public std::allocator<T>
|
||||
}
|
||||
};
|
||||
|
||||
struct plus_int
|
||||
{
|
||||
int operator()(int x, int y) const { return x + y; }
|
||||
|
||||
int unused_state_data;
|
||||
};
|
||||
|
||||
static int do_minus(int x, int y) { return x-y; }
|
||||
|
||||
struct DoNothing
|
||||
{
|
||||
void operator()() const {}
|
||||
|
||||
int unused_state_data;
|
||||
};
|
||||
|
||||
static void do_nothing() {}
|
||||
@ -63,32 +54,28 @@ int
|
||||
test_main(int, char*[])
|
||||
{
|
||||
function2<int, int, int, counting_allocator<int> > f;
|
||||
f = plus_int();
|
||||
f = plus<int>();
|
||||
f.clear();
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f = &do_minus;
|
||||
f.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
|
||||
function0<void, counting_allocator<int> > fv;
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = DoNothing();
|
||||
fv.clear();
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = &do_nothing;
|
||||
fv.clear();
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,88 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2004.
|
||||
// Copyright 2005 Peter Dimov
|
||||
|
||||
// Use, modification and distribution is subject to
|
||||
// the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
static int forty_two()
|
||||
{
|
||||
return 42;
|
||||
}
|
||||
|
||||
struct Seventeen
|
||||
{
|
||||
int operator()() const
|
||||
{
|
||||
return 17;
|
||||
}
|
||||
};
|
||||
|
||||
bool operator==(const Seventeen&, const Seventeen&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
struct ReturnInt
|
||||
{
|
||||
explicit ReturnInt(int value) : value(value)
|
||||
{
|
||||
}
|
||||
|
||||
int operator()() const
|
||||
{
|
||||
return value;
|
||||
}
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
bool operator==(const ReturnInt& x, const ReturnInt& y)
|
||||
{
|
||||
return x.value == y.value;
|
||||
}
|
||||
|
||||
bool operator!=(const ReturnInt& x, const ReturnInt& y)
|
||||
{
|
||||
return x.value != y.value;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function0<int> fn;
|
||||
|
||||
fn = &forty_two;
|
||||
|
||||
BOOST_TEST( fn() == 42 );
|
||||
|
||||
BOOST_TEST( fn.contains(&forty_two) );
|
||||
BOOST_TEST( !fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(12) ) );
|
||||
|
||||
fn = Seventeen();
|
||||
|
||||
BOOST_TEST( fn() == 17 );
|
||||
|
||||
BOOST_TEST( !fn.contains( &forty_two ) );
|
||||
BOOST_TEST( fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(12) ) );
|
||||
|
||||
fn = ReturnInt(12);
|
||||
|
||||
BOOST_TEST( fn() == 12 );
|
||||
|
||||
BOOST_TEST( !fn.contains( &forty_two ) );
|
||||
BOOST_TEST( !fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( fn.contains( ReturnInt(12) ) );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -31,63 +31,23 @@ bool operator==(const ReturnInt& x, const ReturnInt& y)
|
||||
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>());
|
||||
BOOST_TEST(*f.target<int (*)()>() == &forty_two);
|
||||
BOOST_TEST(!f.target<Seventeen>());
|
||||
|
||||
f = Seventeen();
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<Seventeen>());
|
||||
BOOST_TEST(!f.target<int (*)()>());
|
||||
BOOST_TEST(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);
|
||||
BOOST_TEST(!f.target<int (*)()>());
|
||||
BOOST_TEST(f.target<Seventeen>());
|
||||
BOOST_TEST(f.target<Seventeen>() == &this_seventeen);
|
||||
}
|
||||
|
||||
static void equal_test()
|
||||
@ -95,58 +55,46 @@ static void equal_test()
|
||||
boost::function0<int> f;
|
||||
|
||||
f = &forty_two;
|
||||
BOOST_CHECK(f == &forty_two);
|
||||
BOOST_CHECK(f != ReturnInt(17));
|
||||
BOOST_TEST(f == &forty_two);
|
||||
BOOST_TEST(f != ReturnInt(17));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two == f);
|
||||
BOOST_CHECK(ReturnInt(17) != f);
|
||||
BOOST_TEST(&forty_two == f);
|
||||
BOOST_TEST(ReturnInt(17) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(&forty_two));
|
||||
BOOST_TEST(f.contains(&forty_two));
|
||||
|
||||
f = ReturnInt(17);
|
||||
BOOST_CHECK(f != &forty_two);
|
||||
BOOST_CHECK(f == ReturnInt(17));
|
||||
BOOST_CHECK(f != ReturnInt(16));
|
||||
BOOST_TEST(f != &forty_two);
|
||||
BOOST_TEST(f == ReturnInt(17));
|
||||
BOOST_TEST(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);
|
||||
BOOST_TEST(&forty_two != f);
|
||||
BOOST_TEST(ReturnInt(17) == f);
|
||||
BOOST_TEST(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)));
|
||||
BOOST_TEST(f.contains(ReturnInt(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));
|
||||
BOOST_TEST(g == &forty_two);
|
||||
BOOST_TEST(g != ReturnInt(17));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two == g);
|
||||
BOOST_CHECK(ReturnInt(17) != g);
|
||||
BOOST_TEST(&forty_two == g);
|
||||
BOOST_TEST(ReturnInt(17) != g);
|
||||
# endif
|
||||
|
||||
g = ReturnInt(17);
|
||||
BOOST_CHECK(g != &forty_two);
|
||||
BOOST_CHECK(g == ReturnInt(17));
|
||||
BOOST_CHECK(g != ReturnInt(16));
|
||||
BOOST_TEST(g != &forty_two);
|
||||
BOOST_TEST(g == ReturnInt(17));
|
||||
BOOST_TEST(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);
|
||||
BOOST_TEST(&forty_two != g);
|
||||
BOOST_TEST(ReturnInt(17) == g);
|
||||
BOOST_TEST(ReturnInt(16) != g);
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
@ -158,28 +106,28 @@ static void ref_equal_test()
|
||||
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));
|
||||
BOOST_TEST(f == boost::ref(ri));
|
||||
BOOST_TEST(f == ri);
|
||||
BOOST_TEST(boost::ref(ri) == f);
|
||||
BOOST_TEST(!(f != boost::ref(ri)));
|
||||
BOOST_TEST(!(f != ri));
|
||||
BOOST_TEST(!(boost::ref(ri) != f));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri == f);
|
||||
BOOST_CHECK(!(ri != f));
|
||||
BOOST_TEST(ri == f);
|
||||
BOOST_TEST(!(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));
|
||||
BOOST_TEST(f == ri2);
|
||||
BOOST_TEST(f != boost::ref(ri2));
|
||||
BOOST_TEST(boost::ref(ri2) != f);
|
||||
BOOST_TEST(!(f != ri2));
|
||||
BOOST_TEST(!(f == boost::ref(ri2)));
|
||||
BOOST_TEST(!(boost::ref(ri2) == f));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri2 == f);
|
||||
BOOST_CHECK(!(ri2 != f));
|
||||
BOOST_TEST(ri2 == f);
|
||||
BOOST_TEST(!(ri2 != f));
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -189,28 +137,28 @@ static void ref_equal_test()
|
||||
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));
|
||||
BOOST_TEST(f == boost::ref(ri));
|
||||
BOOST_TEST(f == ri);
|
||||
BOOST_TEST(boost::ref(ri) == f);
|
||||
BOOST_TEST(!(f != boost::ref(ri)));
|
||||
BOOST_TEST(!(f != ri));
|
||||
BOOST_TEST(!(boost::ref(ri) != f));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri == f);
|
||||
BOOST_CHECK(!(ri != f));
|
||||
BOOST_TEST(ri == f);
|
||||
BOOST_TEST(!(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));
|
||||
BOOST_TEST(f == ri2);
|
||||
BOOST_TEST(f != boost::ref(ri2));
|
||||
BOOST_TEST(boost::ref(ri2) != f);
|
||||
BOOST_TEST(!(f != ri2));
|
||||
BOOST_TEST(!(f == boost::ref(ri2)));
|
||||
BOOST_TEST(!(boost::ref(ri2) == f));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri2 == f);
|
||||
BOOST_CHECK(!(ri2 != f));
|
||||
BOOST_TEST(ri2 == f);
|
||||
BOOST_TEST(!(ri2 != f));
|
||||
# endif
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -56,30 +56,30 @@ test_zero_args()
|
||||
|
||||
// Default construction
|
||||
func_void_type v1;
|
||||
BOOST_CHECK(v1.empty());
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v1.clear();
|
||||
BOOST_CHECK(!v1);
|
||||
BOOST_TEST(!v1);
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = v1;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v1 = five;
|
||||
@ -88,61 +88,61 @@ test_zero_args()
|
||||
global_int = 0;
|
||||
v1 = (v1);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear
|
||||
v1 = 0;
|
||||
BOOST_CHECK(v1.empty());
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = &write_five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = &write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Construction from another function (that is empty)
|
||||
v1.clear();
|
||||
func_void_type v2(v1);
|
||||
BOOST_CHECK(!v2? true : false);
|
||||
BOOST_TEST(!v2? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v2 = three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v2 = (five);
|
||||
@ -150,86 +150,86 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
v2.clear();
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v2 = (&write_five);
|
||||
BOOST_CHECK(v2? true : false);
|
||||
BOOST_TEST(v2? true : false);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Swapping
|
||||
v1 = five;
|
||||
swap(v1, v2);
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
swap(v1, v2);
|
||||
v1.clear();
|
||||
|
||||
// Assignment
|
||||
v2 = five;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a function from an empty function
|
||||
v2 = v1;
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to a function from a function with a functor
|
||||
v1 = three;
|
||||
v2 = v1;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assign to a function from a function with a function
|
||||
v2 = &write_five;
|
||||
v1 = v2;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construct a function given another function containing a function
|
||||
func_void_type v3(v1);
|
||||
@ -237,20 +237,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v3.clear();
|
||||
BOOST_CHECK(!v3? true : false);
|
||||
BOOST_TEST(!v3? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v3 = three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v3 = five;
|
||||
@ -258,38 +258,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v3.clear();
|
||||
BOOST_CHECK(v3.empty());
|
||||
BOOST_TEST(v3.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v3 = &write_five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v3 = &write_three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v3 = five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function containing a functor
|
||||
func_void_type v4(v3);
|
||||
@ -297,20 +297,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v4 = three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v4 = five;
|
||||
@ -318,38 +318,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v4 = &write_five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v4 = &write_three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v4 = five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a functor
|
||||
func_void_type v5(five);
|
||||
@ -357,20 +357,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v5 = three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v5 = five;
|
||||
@ -378,38 +378,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v5 = &write_five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v5 = &write_three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v5 = five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function
|
||||
func_void_type v6(&write_five);
|
||||
@ -417,20 +417,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v6 = three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v6 = five;
|
||||
@ -438,38 +438,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v6 = &write_five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v6 = &write_three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v6 = five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Const vs. non-const
|
||||
// Initialization for Borland C++ 5.5
|
||||
@ -479,19 +479,19 @@ test_zero_args()
|
||||
|
||||
global_int = 0;
|
||||
v7();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
global_int = 0;
|
||||
v8();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
// Test construction from 0 and comparison to 0
|
||||
func_void_type v9(0);
|
||||
BOOST_CHECK(v9 == 0);
|
||||
BOOST_TEST(v9 == 0);
|
||||
# if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540 || defined(BOOST_STRICT_CONFIG)
|
||||
BOOST_CHECK(0 == v9);
|
||||
BOOST_TEST(0 == v9);
|
||||
#else
|
||||
BOOST_CHECK(v9.empty());
|
||||
BOOST_TEST(v9.empty());
|
||||
#endif
|
||||
|
||||
// Test return values
|
||||
@ -501,31 +501,31 @@ test_zero_args()
|
||||
generate_three_obj gen_three = generate_three_obj();
|
||||
func_int_type i0(gen_five);
|
||||
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = gen_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_TEST(i0() == 3);
|
||||
i0 = &generate_five;
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = &generate_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_CHECK(i0? true : false);
|
||||
BOOST_TEST(i0() == 3);
|
||||
BOOST_TEST(i0? true : false);
|
||||
i0.clear();
|
||||
BOOST_CHECK(!i0? true : false);
|
||||
BOOST_TEST(!i0? true : false);
|
||||
|
||||
// Test return values with compatible types
|
||||
typedef function0<long> func_long_type;
|
||||
func_long_type i1(gen_five);
|
||||
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = gen_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_TEST(i1() == 3);
|
||||
i1 = &generate_five;
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = &generate_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_CHECK(i1? true : false);
|
||||
BOOST_TEST(i1() == 3);
|
||||
BOOST_TEST(i1? true : false);
|
||||
i1.clear();
|
||||
BOOST_CHECK(!i1? true : false);
|
||||
BOOST_TEST(!i1? true : false);
|
||||
}
|
||||
|
||||
static void
|
||||
@ -534,45 +534,45 @@ test_one_arg()
|
||||
negate<int> neg = negate<int>(); // Initialization for Borland C++ 5.5
|
||||
|
||||
function1<int, int> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
BOOST_TEST(f1(5) == -5);
|
||||
|
||||
function1<string, string> id(&identity_str);
|
||||
BOOST_CHECK(id("str") == "str");
|
||||
BOOST_TEST(id("str") == "str");
|
||||
|
||||
function1<std::string, const char*> id2(&identity_str);
|
||||
BOOST_CHECK(id2("foo") == "foo");
|
||||
BOOST_TEST(id2("foo") == "foo");
|
||||
|
||||
add_to_obj add_to(5);
|
||||
function1<int, int> f2(add_to);
|
||||
BOOST_CHECK(f2(3) == 8);
|
||||
BOOST_TEST(f2(3) == 8);
|
||||
|
||||
const function1<int, int> cf2(add_to);
|
||||
BOOST_CHECK(cf2(3) == 8);
|
||||
BOOST_TEST(cf2(3) == 8);
|
||||
}
|
||||
|
||||
static void
|
||||
test_two_args()
|
||||
{
|
||||
function2<string, const string&, const string&> cat(&string_cat);
|
||||
BOOST_CHECK(cat("str", "ing") == "string");
|
||||
BOOST_TEST(cat("str", "ing") == "string");
|
||||
|
||||
function2<int, short, short> sum(&sum_ints);
|
||||
BOOST_CHECK(sum(2, 3) == 5);
|
||||
BOOST_TEST(sum(2, 3) == 5);
|
||||
}
|
||||
|
||||
static void
|
||||
test_emptiness()
|
||||
{
|
||||
function0<float> f1;
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_TEST(f1.empty());
|
||||
|
||||
function0<float> f2;
|
||||
f2 = f1;
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_TEST(f2.empty());
|
||||
|
||||
function0<double> f3;
|
||||
f3 = f2;
|
||||
BOOST_CHECK(f3.empty());
|
||||
BOOST_TEST(f3.empty());
|
||||
}
|
||||
|
||||
struct X {
|
||||
@ -593,18 +593,18 @@ test_member_functions()
|
||||
X one(1);
|
||||
X five(5);
|
||||
|
||||
BOOST_CHECK(f1(&one) == 2);
|
||||
BOOST_CHECK(f1(&five) == 10);
|
||||
BOOST_TEST(f1(&one) == 2);
|
||||
BOOST_TEST(f1(&five) == 10);
|
||||
|
||||
boost::function1<int, X*> f1_2;
|
||||
f1_2 = &X::twice;
|
||||
|
||||
BOOST_CHECK(f1_2(&one) == 2);
|
||||
BOOST_CHECK(f1_2(&five) == 10);
|
||||
BOOST_TEST(f1_2(&one) == 2);
|
||||
BOOST_TEST(f1_2(&five) == 10);
|
||||
|
||||
boost::function2<int, X&, int> f2(&X::plus);
|
||||
BOOST_CHECK(f2(one, 3) == 4);
|
||||
BOOST_CHECK(f2(five, 4) == 9);
|
||||
BOOST_TEST(f2(one, 3) == 4);
|
||||
BOOST_TEST(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
@ -629,7 +629,7 @@ test_ref()
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function2<int, int, int> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
BOOST_TEST(f(1, 3) == 4);
|
||||
}
|
||||
catch(std::runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
|
||||
@ -56,30 +56,30 @@ test_zero_args()
|
||||
|
||||
// Default construction
|
||||
func_void_type v1;
|
||||
BOOST_CHECK(v1.empty());
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = five;
|
||||
BOOST_CHECK(v1 != 0);
|
||||
BOOST_TEST(v1 != 0);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v1.clear();
|
||||
BOOST_CHECK(v1 == 0);
|
||||
BOOST_TEST(v1 == 0);
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = v1;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v1 = five;
|
||||
@ -88,61 +88,61 @@ test_zero_args()
|
||||
global_int = 0;
|
||||
v1 = (v1);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear
|
||||
v1 = 0;
|
||||
BOOST_CHECK(0 == v1);
|
||||
BOOST_TEST(0 == v1);
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
BOOST_CHECK(0 != v1);
|
||||
BOOST_TEST(0 != v1);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = &write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Construction from another function (that is empty)
|
||||
v1.clear();
|
||||
func_void_type v2(v1);
|
||||
BOOST_CHECK(!v2? true : false);
|
||||
BOOST_TEST(!v2? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v2 = three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v2 = (five);
|
||||
@ -150,86 +150,86 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
v2.clear();
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
|
||||
BOOST_CHECK(v2? true : false);
|
||||
BOOST_TEST(v2? true : false);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Swapping
|
||||
v1 = five;
|
||||
swap(v1, v2);
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
swap(v1, v2);
|
||||
v1.clear();
|
||||
|
||||
// Assignment
|
||||
v2 = five;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a function from an empty function
|
||||
v2 = v1;
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to a function from a function with a functor
|
||||
v1 = three;
|
||||
v2 = v1;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assign to a function from a function with a function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
v1 = v2;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construct a function given another function containing a function
|
||||
func_void_type v3(v1);
|
||||
@ -237,20 +237,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v3.clear();
|
||||
BOOST_CHECK(!v3? true : false);
|
||||
BOOST_TEST(!v3? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v3 = three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v3 = five;
|
||||
@ -258,38 +258,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v3.clear();
|
||||
BOOST_CHECK(v3.empty());
|
||||
BOOST_TEST(v3.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v3 = &write_five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v3 = &write_three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v3 = five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function containing a functor
|
||||
func_void_type v4(v3);
|
||||
@ -297,20 +297,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v4 = three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v4 = five;
|
||||
@ -318,38 +318,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v4 = &write_five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v4 = &write_three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v4 = five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a functor
|
||||
func_void_type v5(five);
|
||||
@ -357,20 +357,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v5 = three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v5 = five;
|
||||
@ -378,38 +378,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v5 = &write_five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v5 = &write_three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v5 = five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function
|
||||
func_void_type v6(&write_five);
|
||||
@ -417,20 +417,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v6 = three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v6 = five;
|
||||
@ -438,38 +438,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v6 = &write_five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v6 = &write_three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v6 = five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Const vs. non-const
|
||||
write_const_1_nonconst_2 one_or_two;
|
||||
@ -478,16 +478,16 @@ test_zero_args()
|
||||
|
||||
global_int = 0;
|
||||
v7();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
global_int = 0;
|
||||
v8();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
// Test construction from 0 and comparison to 0
|
||||
func_void_type v9(0);
|
||||
BOOST_CHECK(v9 == 0);
|
||||
BOOST_CHECK(0 == v9);
|
||||
BOOST_TEST(v9 == 0);
|
||||
BOOST_TEST(0 == v9);
|
||||
|
||||
// Test return values
|
||||
typedef function<int ()> func_int_type;
|
||||
@ -496,31 +496,31 @@ test_zero_args()
|
||||
|
||||
func_int_type i0(gen_five);
|
||||
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = gen_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_TEST(i0() == 3);
|
||||
i0 = &generate_five;
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = &generate_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_CHECK(i0? true : false);
|
||||
BOOST_TEST(i0() == 3);
|
||||
BOOST_TEST(i0? true : false);
|
||||
i0.clear();
|
||||
BOOST_CHECK(!i0? true : false);
|
||||
BOOST_TEST(!i0? true : false);
|
||||
|
||||
// Test return values with compatible types
|
||||
typedef function<long ()> func_long_type;
|
||||
func_long_type i1(gen_five);
|
||||
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = gen_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_TEST(i1() == 3);
|
||||
i1 = &generate_five;
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = &generate_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_CHECK(i1? true : false);
|
||||
BOOST_TEST(i1() == 3);
|
||||
BOOST_TEST(i1? true : false);
|
||||
i1.clear();
|
||||
BOOST_CHECK(!i1? true : false);
|
||||
BOOST_TEST(!i1? true : false);
|
||||
}
|
||||
|
||||
static void
|
||||
@ -529,45 +529,45 @@ test_one_arg()
|
||||
negate<int> neg;
|
||||
|
||||
function<int (int)> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
BOOST_TEST(f1(5) == -5);
|
||||
|
||||
function<string (string)> id(&identity_str);
|
||||
BOOST_CHECK(id("str") == "str");
|
||||
BOOST_TEST(id("str") == "str");
|
||||
|
||||
function<string (const char*)> id2(&identity_str);
|
||||
BOOST_CHECK(id2("foo") == "foo");
|
||||
BOOST_TEST(id2("foo") == "foo");
|
||||
|
||||
add_to_obj add_to(5);
|
||||
function<int (int)> f2(add_to);
|
||||
BOOST_CHECK(f2(3) == 8);
|
||||
BOOST_TEST(f2(3) == 8);
|
||||
|
||||
const function<int (int)> cf2(add_to);
|
||||
BOOST_CHECK(cf2(3) == 8);
|
||||
BOOST_TEST(cf2(3) == 8);
|
||||
}
|
||||
|
||||
static void
|
||||
test_two_args()
|
||||
{
|
||||
function<string (const string&, const string&)> cat(&string_cat);
|
||||
BOOST_CHECK(cat("str", "ing") == "string");
|
||||
BOOST_TEST(cat("str", "ing") == "string");
|
||||
|
||||
function<int (short, short)> sum(&sum_ints);
|
||||
BOOST_CHECK(sum(2, 3) == 5);
|
||||
BOOST_TEST(sum(2, 3) == 5);
|
||||
}
|
||||
|
||||
static void
|
||||
test_emptiness()
|
||||
{
|
||||
function<float ()> f1;
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_TEST(f1.empty());
|
||||
|
||||
function<float ()> f2;
|
||||
f2 = f1;
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_TEST(f2.empty());
|
||||
|
||||
function<double ()> f3;
|
||||
f3 = f2;
|
||||
BOOST_CHECK(f3.empty());
|
||||
BOOST_TEST(f3.empty());
|
||||
}
|
||||
|
||||
struct X {
|
||||
@ -587,18 +587,18 @@ test_member_functions()
|
||||
X one(1);
|
||||
X five(5);
|
||||
|
||||
BOOST_CHECK(f1(&one) == 2);
|
||||
BOOST_CHECK(f1(&five) == 10);
|
||||
BOOST_TEST(f1(&one) == 2);
|
||||
BOOST_TEST(f1(&five) == 10);
|
||||
|
||||
boost::function<int (X*)> f1_2;
|
||||
f1_2 = &X::twice;
|
||||
|
||||
BOOST_CHECK(f1_2(&one) == 2);
|
||||
BOOST_CHECK(f1_2(&five) == 10);
|
||||
BOOST_TEST(f1_2(&one) == 2);
|
||||
BOOST_TEST(f1_2(&five) == 10);
|
||||
|
||||
boost::function<int (X&, int)> f2(&X::plus);
|
||||
BOOST_CHECK(f2(one, 3) == 4);
|
||||
BOOST_CHECK(f2(five, 4) == 9);
|
||||
BOOST_TEST(f2(one, 3) == 4);
|
||||
BOOST_TEST(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
@ -623,19 +623,83 @@ test_ref()
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function<int (int, int)> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
BOOST_TEST(f(1, 3) == 4);
|
||||
}
|
||||
catch(runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
static int alloc_count = 0;
|
||||
static int dealloc_count = 0;
|
||||
|
||||
template<typename T>
|
||||
struct counting_allocator : public allocator<T>
|
||||
{
|
||||
template<typename U>
|
||||
struct rebind
|
||||
{
|
||||
typedef counting_allocator<U> other;
|
||||
};
|
||||
|
||||
|
||||
T* allocate(size_t n)
|
||||
{
|
||||
alloc_count++;
|
||||
return allocator<T>::allocate(n);
|
||||
}
|
||||
|
||||
void deallocate(T* p, size_t n)
|
||||
{
|
||||
dealloc_count++;
|
||||
allocator<T>::deallocate(p, n);
|
||||
}
|
||||
};
|
||||
|
||||
static int do_minus(int x, int y) { return x-y; }
|
||||
|
||||
struct DoNothing
|
||||
{
|
||||
void operator()() const {}
|
||||
};
|
||||
|
||||
static void do_nothing() {}
|
||||
|
||||
static void test_allocator()
|
||||
{
|
||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
||||
boost::function<int (int, int), counting_allocator<int> > f;
|
||||
f = plus<int>();
|
||||
f.clear();
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f = &do_minus;
|
||||
f.clear();
|
||||
|
||||
boost::function<void (), counting_allocator<int> > fv;
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = DoNothing();
|
||||
fv.clear();
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = &do_nothing;
|
||||
fv.clear();
|
||||
#endif // ndef BOOST_NO_STD_ALLOCATOR
|
||||
}
|
||||
|
||||
static void test_exception()
|
||||
{
|
||||
boost::function<int (int, int)> f;
|
||||
try {
|
||||
f(5, 4);
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
catch(boost::bad_function_call) {
|
||||
// okay
|
||||
@ -675,6 +739,7 @@ int test_main(int, char* [])
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_allocator();
|
||||
test_exception();
|
||||
test_implicit();
|
||||
test_call();
|
||||
|
||||
Reference in New Issue
Block a user