boostorg/function
1
0
Fork 1
mirror of https://github.com/boostorg/function.git synced 2025-07-24 09:57:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

- Removed everything deprecated in 1.29.0

Browse Source 
- Deprecate user use of function_base
- Use the Boost Preprocessor library to make Function scalable to any
  (reasonable) number of arguments
- Make any_pointer a POD (oops)
- Test Boost.Function for 30 arguments
- Remove tests of deprecated features


[SVN r15498]
This commit is contained in:
Douglas Gregor
2002-09-24 17:16:17 +00:00
parent f36e83fb27
commit f9ae459b2d
27 changed files with 509 additions and 2365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
doc/reference.html
View File

@ -13,9 +13,8 @@
<pre>
<b>namespace</b> boost {
<b>class</b> <a href="#function_base">function_base</a>
<b>class</b> <a href="#function_base">function_base</a> <em> // Deprecated</em>
{
<b>typedef</b> <em>implementation-defined</em> safe_bool;
<a href="#empty"><b>bool</b> empty() <b>const</b></a>;
};
@ -25,14 +24,13 @@
<b>typename</b> Arg2,
<i>...</i>
<b>typename</b> Arg<i>N</i>,
<b>typename</b> Policy = empty_function_policy, <em>// Deprecated</em>
<b>typename</b> Mixin = empty_function_mixin, <em>// Deprecated</em>
<b>typename</b> Allocator = std::allocator&lt;function_base&gt; &gt;
<b>class</b> <a href="#functionN">function<i>N</i></a> : <b>public</b> <a href="#function_base">function_base</a>, <b>public</b> Mixin
<b>typename</b> Allocator = std::allocator&lt;<b>void</b>&gt; &gt;
<b>class</b> <a href="#functionN">function<i>N</i></a> : <b>public</b> <a href="#function_base">function_base</a>
{
<b>typedef</b> <em>implementation-defined</em> safe_bool;
<b>public</b>:
<b>typedef</b> ResultType result_type; <em>// <a href="#novoid">[1]</a></em>
<b>typedef</b> Policy policy_type; <em>// Deprecated</em>
<b>typedef</b> Mixin mixin_type; <em>// Deprecated</em>
<b>typedef</b> Allocator allocator_type;
<b>typedef</b> Arg1 argument_type; <i>// If N == 1</i>
@ -50,17 +48,15 @@
<b>enum</b> { arity = <em>N</em> };
<i>// Construction</i>
<a href="#functionN_default"><b>explicit</b> function<i>N</i>(<b>const</b> Mixin<b>&amp;</b> = Mixin())</a>;
<a href="#functionN_default"><b>explicit</b> function<i>N</i>()</a>;
<a href="#functionN_copy">function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
<a href="#functionN_target"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F, <b>const</b> Mixin<b>&amp;</b> = Mixin())</a>;
<a href="#functionN_target"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F)</a>;
<a href="#functionN_target_ref"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(reference_wrapper&lt;F&gt;)</a>;
<i>// Assignment</i>
<a href="#functionN_copy_assn">function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
<a href="#functionN_target_assn"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(F)</a>;
<a href="#functionN_target_ref_assn"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(reference_wrapper&lt;F&gt;)</a>;
<a href="#functionN_copy_set"><b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b>)</a>; <em>// Deprecated</em>
<a href="#functionN_target_set"><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F)</a>; <em>// Deprecated</em>
<a href="#functionN_swap"><b>void</b> swap(function<i>N</i><b>&amp;</b>)</a>;
<a href="#functionN_clear"><b>void</b> clear()</a>;
@ -77,37 +73,30 @@
<b>typename</b> Arg2,
<i>...</i>
<b>typename</b> Arg<i>N</i>,
<b>typename</b> Policy, <em>// Deprecated</em>
<b>typename</b> Mixin, <em>// Deprecated</em>
<b>typename</b> Allocator&gt;
<b>void</b> <a href="#swap_functionN">swap</a>(function<em>N</em>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>,
function<em>N</em>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>);
<b>void</b> <a href="#swap_functionN">swap</a>(function<em>N</em>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Allocator&gt;<b>&amp;</b>,
function<em>N</em>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Allocator&gt;<b>&amp;</b>);
// For any <i>N</i> in [0, <i>MAX_ARGS</i>]
<b>template</b>&lt;<b>typename</b> Signature, <em>// Function type: ResultType (Arg1, Arg2, ..., Arg<em>N</em>)</em>
<b>typename</b> Policy = empty_function_policy, <em>// Deprecated</em>
<b>typename</b> Mixin = empty_function_mixin, <em>// Deprecated</em>
<b>typename</b> Allocator = std::allocator&lt;function_base&gt; &gt;
<b>class</b> <a href="#function">function</a> : <b>public</b> <a href="#functionN">function<i>N</i></a>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>&gt;
<b>typename</b> Allocator = std::allocator&lt;<b>void</b>&gt; &gt;
<b>class</b> <a href="#function">function</a> : <b>public</b> <a href="#functionN">function<i>N</i></a>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Allocator&gt;
{
<i>// Construction</i>
function();
function(<b>const</b> function<b>&amp;</b>);
function(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>);
function(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>, Allocator&gt;<b>&amp;</b>);
<b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F);
<i>// Assignment</i>
function<b>&amp;</b> <b>operator</b>=(<b>const</b> function<b>&amp;</b>);
function<b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>);
function<b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>, Allocator&gt;<b>&amp;</b>);
<b>template</b>&lt;<b>typename</b> F&gt; function<b>&amp;</b> <b>operator</b>=(F);
<b>void</b> set(<b>const</b> function<b>&amp;</b>); <em>// Deprecated</em>
<b>void</b> set(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>); <em>// Deprecated</em>
<b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F); <em>// Deprecated</em>
};
<b>template</b>&lt;<b>typename</b> Signature, <b>typename</b> Policy, <b>typename</b> Mixin, <b>typename</b> Allocator&gt;
<b>void</b> <a href="#swap_function">swap</a>(function&lt;Signature, Policy, Mixin, Allocator&gt;<b>&amp;</b>,
function&lt;Signature, Policy, Mixin, Allocator&gt;<b>&amp;</b>);
<b>template</b>&lt;<b>typename</b> Signature, <b>typename</b> Allocator&gt;
<b>void</b> <a href="#swap_function">swap</a>(function&lt;Signature, Allocator&gt;<b>&amp;</b>,
function&lt;Signature, Allocator&gt;<b>&amp;</b>);
}
</pre>
@ -141,7 +130,7 @@
<h2><a name="function_base">Class <code>function_base</code></a></h2>
<p> Class <code>function_base</code> is the common base class for all Boost.Function objects. Objects of type <code>function_base</code> may not be created directly.
<p> <font color=red>Note: the use of this class by users is deprecated. This class will become an implementation detail in the future.</font>
<p> <a name="empty"><code><b>bool</b> empty() <b>const</b></code></a>
<ul>
<li><b>Returns</b>: <code>true</code> if the function object has a target, <code>false</code> otherwise.</li>
@ -151,40 +140,37 @@
<h2><a name="functionN">Class template <code>function<i>N</i></code></a></h2>
<p> Class template <code>function<i>N</i></code> is actually a family of related classes <code>function0</code>, <code>function1</code>, etc., up to some implementation-defined maximum. In this context, <code><i>N</i></code> refers to the number of parameters and <code>f</code> refers to the implicit object parameter.
<p> <a name="functionN_default"><code><b>explicit</b> function<i>N</i>(<b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
<p> <a name="functionN_default"><code><b>explicit</b> function<i>N</i>();</code></a>
<ul>
<li><b>Effects</b>: Constructs the <code>Mixin</code> subobject with the given mixin.</li>
<li><b>Postconditions</b>: <code>f.<a href="#empty">empty</a>()</code>.</li>
<li><b>Throws</b>: will not throw unless construction of the <code>Mixin</code> subobject throws.</li>
<li><b>Throws</b>: will not throw.</li>
</ul>
<p> <a name="functionN_copy"><code>function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
<ul>
<li><b>Postconditions</b>: <code>f</code> contains a copy of the <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for the <code>f</code> is copy-constructed from the mixin of <code>g</code>.</li>
<li><b>Throws</b>: will not throw unless copying the target of <code>g</code> or construction of the <code>Mixin</code> subobject throws.</li>
<li><b>Postconditions</b>: <code>f</code> contains a copy of the <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. </li>
<li><b>Throws</b>: will not throw unless copying the target of <code>g</code> throws.</li>
</ul>
<p> <a name="functionN_target"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F g, <b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
<p> <a name="functionN_target"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F g);</code></a>
<ul>
<li><b>Requires</b>: <code>g</code> is a <a href="#compatible">compatible</a> function object.</li>
<li><b>Effects</b>: Constructs the <code>Mixin</code> subobject from the given mixin.</li>
<li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code> if <code>g</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g</code> is empty.</li>
<li><b>Throws</b>: will not throw when <code>g</code> is a <a href="#stateless">stateless</a> function object unless construction of the <code>Mixin</code> subobject throws.</li>
<li><b>Throws</b>: will not throw when <code>g</code> is <a href="#stateless">stateless</a>; otherwise, may throw when a copy of <code>g</code> is made.</li>
</ul>
<p> <a name="functionN_target_ref"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(<a href="../../bind/ref.html">reference_wrapper</a>&lt;F&gt; g);</code></a>
<ul>
<li><b>Requires</b>: <code>g.get()</code> is a <a href="#compatible">compatible</a> function object.</li>
<li><b>Effects</b>: Constructs the <code>Mixin</code> subobject from the given mixin.</li>
<li><b>Postconditions</b>: <code>this</code> object targets <code>g</code> (<em>not</em> a copy of <code>g.get()</code>) if <code>g.get()</code> is nonempty, or <code>this-&gt;empty()</code> if <code>g.get()</code> is empty.</li>
<li><b>Throws</b>: will not throw unless the construction of the <code>Mixin</code> subobject throws.</li>
<li><b>Throws</b>: will not throw.</li>
</ul>
<p> <a name="functionN_copy_assn"><code>function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
<ul>
<li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for <code>f</code> is assigned the value of the mixin for <code>g</code>.</li>
<li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. </li>
<li><b>Returns</b>: <code>*this</code>.</li>
<li><b>Throws</b>: will not throw when the target of <code>g</code> is a <a href="#stateless">stateless</a> function object or a reference to the function object, unless the copy of the <code>Mixin</code> subobject throws.</li>
<li><b>Throws</b>: will not throw when the target of <code>g</code> is a <a href="#stateless">stateless</a> function object or a reference to the function object.</li>
</ul>
<p> <a name="functionN_target_assn"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(F g);</code></a>
@ -203,21 +189,9 @@
<li><b>Throws</b>: will throw only if the destruction or deallocation of the target of <code>this</code> throws.</li>
</ul>
<p> <a name="functionN_copy_set"><code><b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
<ul>
<li><b>Effects</b>: <code><a href="#functionN_copy_assn">*this = g</a></code>.</li>
<li><b>Note</b>: This function is deprecated and will be removed in future versions of Boost.Function. Please use the assignment operator instead.</li>
</ul>
<p> <a name="functionN_target_set"><code><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F g);</code></a>
<ul>
<li><b>Effects</b>: <code><a href="#functionN_target_assn">*this = g</a></code>.</li>
<li><b>Note</b>: This function is deprecated and will be removed in future versions of Boost.Function. Please use the assignment operator instead.</li>
</ul>
<p> <a name="functionN_swap"><code><b>void</b> swap(function<i>N</i><b>&amp;</b> g);</code></a>
<ul>
<li><b>Effects</b>: interchanges the targets of <code>f</code> and <code>g</code> and swaps the mixins of <code>f</code> and <code>g</code>.</li>
<li><b>Effects</b>: interchanges the targets of <code>f</code> and <code>g</code>. </li>
<li><b>Throws</b>: will not throw.</li>
</ul>
@ -267,11 +241,9 @@
<b>typename</b> Arg2,
<i>...</i>
<b>typename</b> Arg<i>N</i>,
<b>typename</b> Policy, <em>// Deprecated</em>
<b>typename</b> Mixin, <em>// Deprecated</em>
<b>typename</b> Allocator&gt;
<b>void</b> <a name="swap_functionN">swap</a>(function<i>N</i>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> f,
function<i>N</i>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> g);
<b>void</b> <a name="swap_functionN">swap</a>(function<i>N</i>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Allocator&gt;<b>&amp;</b> f,
function<i>N</i>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Allocator&gt;<b>&amp;</b> g);
</pre>
<ul>
<li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>
@ -279,9 +251,9 @@
<p>
<pre>
<b>template</b>&lt;<b>typename</b> Signature, <b>typename</b> Policy, <b>typename</b> Mixin, <b>typename</b> Allocator&gt;
<b>void</b> <a name="swap_function">swap</a>(function&lt;Signature, Policy, Mixin, Allocator&gt;<b>&amp;</b> f,
function&lt;Signature, Policy, Mixin, Allocator&gt;<b>&amp;</b> g);
<b>template</b>&lt;<b>typename</b> Signature, <b>typename</b> Allocator&gt;
<b>void</b> <a name="swap_function">swap</a>(function&lt;Signature, Allocator&gt;<b>&amp;</b> f,
function&lt;Signature, Allocator&gt;<b>&amp;</b> g);
</pre>
<ul>
<li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>

888
include/boost/function.hpp
View File

@ -16,885 +16,17 @@
// William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
// design of this library.
#ifndef BOOST_FUNCTION_HPP
#define BOOST_FUNCTION_HPP
#include <boost/preprocessor/iterate.hpp>
#include <boost/function/function_base.hpp>
#include <boost/type_traits/function_traits.hpp>
#include <boost/type_traits/same_traits.hpp>
#include <boost/type_traits/transform_traits.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/function/function0.hpp>
#include <boost/function/function1.hpp>
#include <boost/function/function2.hpp>
#include <boost/function/function3.hpp>
#include <boost/function/function4.hpp>
#include <boost/function/function5.hpp>
#include <boost/function/function6.hpp>
#include <boost/function/function7.hpp>
#include <boost/function/function8.hpp>
#include <boost/function/function9.hpp>
#include <boost/function/function10.hpp>
#ifndef BOOST_FUNCTION_MAX_ARGS
# define BOOST_FUNCTION_MAX_ARGS 10
#endif // BOOST_FUNCTION_MAX_ARGS
// Don't compile any of this code if we've asked not to include the deprecated
// syntax and we don't have partial specialization, because none of this code
// can work.
#if !defined (BOOST_FUNCTION_NO_DEPRECATED) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
// 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>
namespace boost {
namespace detail {
namespace function {
// Choose the appropriate underlying implementation
template<int Args> struct real_get_function_impl {};
// 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()
template<>
struct real_get_function_impl<0>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function0<R,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator> type;
};
};
template<>
struct real_get_function_impl<1>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function1<R, T1,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator> type;
};
};
template<>
struct real_get_function_impl<2>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function2<R, T1, T2,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator> type;
};
};
template<>
struct real_get_function_impl<3>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function3<R, T1, T2, T3,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator> type;
};
};
template<>
struct real_get_function_impl<4>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function4<R, T1, T2, T3, T4,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator> type;
};
};
template<>
struct real_get_function_impl<5>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function5<R, T1, T2, T3, T4, T5,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator>
type;
};
};
template<>
struct real_get_function_impl<6>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function6<R, T1, T2, T3, T4, T5, T6,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator>
type;
};
};
template<>
struct real_get_function_impl<7>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function7<R, T1, T2, T3, T4, T5, T6, T7,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator> type;
};
};
template<>
struct real_get_function_impl<8>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function8<R, T1, T2, T3, T4, T5, T6, T7, T8,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator> type;
};
};
template<>
struct real_get_function_impl<9>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator> type;
};
};
template<>
struct real_get_function_impl<10>
{
template<
typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy,
typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator
>
struct params
{
typedef function10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator> type;
};
};
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template<bool GetIt, typename Traits>
struct get_arg1_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg1_type<true, Traits>
{
typedef typename Traits::arg1_type type;
};
template<bool GetIt, typename Traits>
struct get_arg2_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg2_type<true, Traits>
{
typedef typename Traits::arg2_type type;
};
template<bool GetIt, typename Traits>
struct get_arg3_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg3_type<true, Traits>
{
typedef typename Traits::arg3_type type;
};
template<bool GetIt, typename Traits>
struct get_arg4_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg4_type<true, Traits>
{
typedef typename Traits::arg4_type type;
};
template<bool GetIt, typename Traits>
struct get_arg5_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg5_type<true, Traits>
{
typedef typename Traits::arg5_type type;
};
template<bool GetIt, typename Traits>
struct get_arg6_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg6_type<true, Traits>
{
typedef typename Traits::arg6_type type;
};
template<bool GetIt, typename Traits>
struct get_arg7_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg7_type<true, Traits>
{
typedef typename Traits::arg7_type type;
};
template<bool GetIt, typename Traits>
struct get_arg8_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg8_type<true, Traits>
{
typedef typename Traits::arg8_type type;
};
template<bool GetIt, typename Traits>
struct get_arg9_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg9_type<true, Traits>
{
typedef typename Traits::arg9_type type;
};
template<bool GetIt, typename Traits>
struct get_arg10_type
{
typedef unusable type;
};
template<typename Traits>
struct get_arg10_type<true, Traits>
{
typedef typename Traits::arg10_type type;
};
template<int X, int Y>
struct gte
{
BOOST_STATIC_CONSTANT(bool, value = (X >= Y));
};
template<bool IsFunction,
typename InR,
typename InT1,
typename InT2,
typename InT3,
typename InT4,
typename InT5,
typename InT6,
typename InT7,
typename InT8,
typename InT9,
typename InT10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename InPolicy,
typename InMixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename InAllocator>
struct maybe_decode_function_args
{
typedef function_traits<InR> traits;
typedef typename traits::result_type R;
typedef typename get_arg1_type<(gte<(traits::arity), 1>::value),
traits>::type T1;
typedef typename get_arg2_type<(gte<(traits::arity), 2>::value),
traits>::type T2;
typedef typename get_arg3_type<(gte<(traits::arity), 3>::value),
traits>::type T3;
typedef typename get_arg4_type<(gte<(traits::arity), 4>::value),
traits>::type T4;
typedef typename get_arg5_type<(gte<(traits::arity), 5>::value),
traits>::type T5;
typedef typename get_arg6_type<(gte<(traits::arity), 6>::value),
traits>::type T6;
typedef typename get_arg7_type<(gte<(traits::arity), 7>::value),
traits>::type T7;
typedef typename get_arg8_type<(gte<(traits::arity), 8>::value),
traits>::type T8;
typedef typename get_arg9_type<(gte<(traits::arity), 9>::value),
traits>::type T9;
typedef typename get_arg10_type<(gte<(traits::arity), 10>::value),
traits>::type T10;
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typedef typename ct_if<(is_same<InT1, unusable>::value),
empty_function_policy,
InT1>::type Policy;
typedef typename ct_if<(is_same<InT2, unusable>::value),
empty_function_mixin,
InT2>::type Mixin;
typedef typename ct_if<(is_same<InT3, unusable>::value),
std::allocator<function_base>,
InT3>::type Allocator;
#else
typedef typename ct_if<(is_same<InT1, unusable>::value),
std::allocator<function_base>,
InT1>::type Allocator;
#endif // BOOST_FUNCTION_NO_DEPRECATED
};
#ifndef BOOST_FUNCTION_NO_DEPRECATED
template<typename InR,
typename InT1,
typename InT2,
typename InT3,
typename InT4,
typename InT5,
typename InT6,
typename InT7,
typename InT8,
typename InT9,
typename InT10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename InPolicy,
typename InMixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename InAllocator>
struct maybe_decode_function_args<false, InR, InT1, InT2, InT3, InT4,
InT5, InT6, InT7, InT8, InT9, InT10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
InPolicy, InMixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
InAllocator>
{
// Not a function, so just map the types directly
typedef InR R;
typedef InT1 T1;
typedef InT2 T2;
typedef InT3 T3;
typedef InT4 T4;
typedef InT5 T5;
typedef InT6 T6;
typedef InT7 T7;
typedef InT8 T8;
typedef InT9 T9;
typedef InT10 T10;
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typedef InPolicy Policy;
typedef InMixin Mixin;
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typedef InAllocator Allocator;
};
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
#endif // ndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template<
typename InR,
typename InT1,
typename InT2,
typename InT3,
typename InT4,
typename InT5,
typename InT6,
typename InT7,
typename InT8,
typename InT9,
typename InT10,
typename InPolicy = empty_function_policy,
typename InMixin = empty_function_mixin,
typename InAllocator = std::allocator<function_base>
>
struct get_function_impl
{
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
typedef maybe_decode_function_args<(is_function<InR>::value),
InR, InT1, InT2, InT3, InT4, InT5,
InT6, InT7, InT8, InT9, InT10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
InPolicy, InMixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
InAllocator> decoder;
typedef typename decoder::R R;
typedef typename decoder::T1 T1;
typedef typename decoder::T2 T2;
typedef typename decoder::T3 T3;
typedef typename decoder::T4 T4;
typedef typename decoder::T5 T5;
typedef typename decoder::T6 T6;
typedef typename decoder::T7 T7;
typedef typename decoder::T8 T8;
typedef typename decoder::T9 T9;
typedef typename decoder::T10 T10;
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typedef typename decoder::Policy Policy;
typedef typename decoder::Mixin Mixin;
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typedef typename decoder::Allocator Allocator;
#else
typedef InR R;
typedef InT1 T1;
typedef InT2 T2;
typedef InT3 T3;
typedef InT4 T4;
typedef InT5 T5;
typedef InT6 T6;
typedef InT7 T7;
typedef InT8 T8;
typedef InT9 T9;
typedef InT10 T10;
typedef InPolicy Policy;
typedef InMixin Mixin;
typedef InAllocator Allocator;
#endif // def BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
typedef typename real_get_function_impl<
(count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
>::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy, Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator>::type
type;
};
#ifndef BOOST_FUNCTION_NO_DEPRECATED
template<
typename InR,
typename InT1,
typename InT2,
typename InT3,
typename InT4,
typename InT5,
typename InT6,
typename InT7,
typename InT8,
typename InT9,
typename InT10,
typename InMyPolicy = empty_function_policy,
typename InMyMixin = empty_function_mixin,
typename InMyAllocator = std::allocator<function_base>
>
class function_traits_builder
{
typedef get_function_impl<InR, InT1, InT2, InT3, InT4, InT5, InT6, InT7,
InT8, InT9, InT10, InMyPolicy, InMyMixin,
InMyAllocator>
impl;
typedef typename impl::R MyR;
typedef typename impl::T1 MyT1;
typedef typename impl::T2 MyT2;
typedef typename impl::T3 MyT3;
typedef typename impl::T4 MyT4;
typedef typename impl::T5 MyT5;
typedef typename impl::T6 MyT6;
typedef typename impl::T7 MyT7;
typedef typename impl::T8 MyT8;
typedef typename impl::T9 MyT9;
typedef typename impl::T10 MyT10;
typedef typename impl::Policy MyPolicy;
typedef typename impl::Mixin MyMixin;
typedef typename impl::Allocator MyAllocator;
public:
typedef typename impl::type type;
typedef MyPolicy policy_type;
typedef MyMixin mixin_type;
typedef MyAllocator allocator_type;
#ifndef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
template<typename Policy>
struct policy :
public function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4, MyT5, MyT6,
MyT7, MyT8, MyT9, MyT10, Policy,
mixin_type, allocator_type> {};
template<typename Mixin>
struct mixin :
public function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4, MyT5, MyT6,
MyT7, MyT8, MyT9, MyT10, policy_type,
Mixin, allocator_type> {};
template<typename Allocator>
struct allocator :
public function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4, MyT5, MyT6,
MyT7, MyT8, MyT9, MyT10, policy_type,
mixin_type, Allocator> {};
#else
template<typename Policy>
struct policy
{
typedef typename function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4,
MyT5, MyT6, MyT7, MyT8, MyT9,
MyT10, Policy, mixin_type,
allocator_type>::type
type;
};
template<typename Mixin>
struct mixin
{
typedef typename function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4,
MyT5, MyT6, MyT7, MyT8, MyT9,
MyT10, policy_type, Mixin,
allocator_type>::type
type;
};
template<typename Allocator>
struct allocator
{
typedef typename function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4,
MyT5, MyT6, MyT7, MyT8, MyT9,
MyT10, policy_type, mixin_type,
Allocator>::type
type;
};
#endif // ndef NO_DEPENDENT_NESTED_DERIVATIONS
};
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
} // end namespace function
} // end namespace detail
template<
typename R,
typename T1 = detail::function::unusable,
typename T2 = detail::function::unusable,
typename T3 = detail::function::unusable,
typename T4 = detail::function::unusable,
typename T5 = detail::function::unusable,
typename T6 = detail::function::unusable,
typename T7 = detail::function::unusable,
typename T8 = detail::function::unusable,
typename T9 = detail::function::unusable,
typename T10 = detail::function::unusable
>
class function :
public detail::function::get_function_impl<R, T1, T2, T3, T4, T5, T6, T7,
T8, T9, T10>::type
#ifndef BOOST_FUNCTION_NO_DEPRECATED
, public detail::function::function_traits_builder<R, T1, T2, T3, T4, T5,
T6, T7, T8, T9, T10>
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
{
typedef typename detail::function::get_function_impl<R, T1, T2, T3, T4, T5,
T6, T7, T8, T9, T10
>::type
base_type;
public:
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typedef typename base_type::policy_type policy_type;
typedef typename base_type::mixin_type mixin_type;
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typedef typename base_type::allocator_type allocator_type;
typedef function self_type;
function() : base_type() {}
template<typename Functor>
function(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) : base_type(f) {}
function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
template<typename Functor>
self_type& operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
{
self_type(f).swap(*this);
return *this;
}
self_type& operator=(const base_type& f)
{
self_type(f).swap(*this);
return *this;
}
self_type& operator=(const self_type& f)
{
self_type(f).swap(*this);
return *this;
}
#ifndef BOOST_FUNCTION_NO_DEPRECATED
template<typename Functor>
BOOST_FUNCTION_DEPRECATED_PRE
void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
{
BOOST_FUNCTION_DEPRECATED_INNER
self_type(f).swap(*this);
}
BOOST_FUNCTION_DEPRECATED_PRE
void set(const base_type& f)
{
BOOST_FUNCTION_DEPRECATED_INNER
self_type(f).swap(*this);
}
BOOST_FUNCTION_DEPRECATED_PRE
void set(const self_type& f)
{
BOOST_FUNCTION_DEPRECATED_INNER
self_type(f).swap(*this);
}
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
};
template<typename R,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
typename T10>
inline void swap(function<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& f1,
function<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& f2)
{
f1.swap(f2);
}
} // end namespace boost
#endif // !no deprecated || !no partial specialization
#endif

8
include/boost/function/detail/function_iterate.hpp Normal file
View File

@ -0,0 +1,8 @@
#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

22
include/boost/function/detail/gen_maybe_include.pl Normal file
View File

@ -0,0 +1,22 @@
#!/usr/bin/perl -w
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";

258
include/boost/function/detail/maybe_include.hpp Normal file
View File

@ -0,0 +1,258 @@
#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

12
include/boost/function/detail/prologue.hpp Normal file
View File

@ -0,0 +1,12 @@
#ifndef BOOST_FUNCTION_PROLOGUE_HPP
#define BOOST_FUNCTION_PROLOGUE_HPP
# include <cassert>
# include <algorithm>
# include <boost/config.hpp>
# include <boost/function/function_base.hpp>
# include <boost/mem_fn.hpp>
# include <boost/preprocessor/enum.hpp>
# include <boost/preprocessor/enum_params.hpp>
# include <boost/preprocessor/cat.hpp>
# include <boost/preprocessor/repeat.hpp>
#endif // BOOST_FUNCTION_PROLOGUE_HPP

38
include/boost/function/function0.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION0_HEADER
#define BOOST_FUNCTION_FUNCTION0_HEADER
#define BOOST_FUNCTION_NUM_ARGS 0
#define BOOST_FUNCTION_TEMPLATE_PARMS
#define BOOST_FUNCTION_TEMPLATE_ARGS
#define BOOST_FUNCTION_PARMS
#define BOOST_FUNCTION_ARGS
#define BOOST_FUNCTION_NOT_0_PARMS
#define BOOST_FUNCTION_NOT_0_ARGS
#define BOOST_FUNCTION_ARG_TYPES
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION0_HEADER

38
include/boost/function/function1.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION1_HEADER
#define BOOST_FUNCTION_FUNCTION1_HEADER
#define BOOST_FUNCTION_NUM_ARGS 1
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0
#define BOOST_FUNCTION_TEMPLATE_ARGS T0
#define BOOST_FUNCTION_PARMS T0 a0
#define BOOST_FUNCTION_ARGS a0
#define BOOST_FUNCTION_NOT_0_PARMS
#define BOOST_FUNCTION_NOT_0_ARGS
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION1_HEADER

38
include/boost/function/function10.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION10_HEADER
#define BOOST_FUNCTION_FUNCTION10_HEADER
#define BOOST_FUNCTION_NUM_ARGS 10
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9
#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9
#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6, a7, a8, a9
#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9
#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type; typedef T9 arg10_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION10_HEADER

38
include/boost/function/function2.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION2_HEADER
#define BOOST_FUNCTION_FUNCTION2_HEADER
#define BOOST_FUNCTION_NUM_ARGS 2
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1
#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1
#define BOOST_FUNCTION_PARMS T0 a0, T1 a1
#define BOOST_FUNCTION_ARGS a0, a1
#define BOOST_FUNCTION_NOT_0_PARMS T1 a1
#define BOOST_FUNCTION_NOT_0_ARGS a1
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type; typedef T1 arg2_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION2_HEADER

37
include/boost/function/function3.hpp
View File

@ -1,38 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION3_HEADER
#define BOOST_FUNCTION_FUNCTION3_HEADER
#define BOOST_FUNCTION_NUM_ARGS 3
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2
#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2
#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2
#define BOOST_FUNCTION_ARGS a0, a1, a2
#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2
#define BOOST_FUNCTION_NOT_0_ARGS a1, a2
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION3_HEADER

38
include/boost/function/function4.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION4_HEADER
#define BOOST_FUNCTION_FUNCTION4_HEADER
#define BOOST_FUNCTION_NUM_ARGS 4
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3
#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3
#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3
#define BOOST_FUNCTION_ARGS a0, a1, a2, a3
#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3
#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION4_HEADER

38
include/boost/function/function5.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION5_HEADER
#define BOOST_FUNCTION_FUNCTION5_HEADER
#define BOOST_FUNCTION_NUM_ARGS 5
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4
#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4
#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4
#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4
#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4
#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION5_HEADER

38
include/boost/function/function6.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION6_HEADER
#define BOOST_FUNCTION_FUNCTION6_HEADER
#define BOOST_FUNCTION_NUM_ARGS 6
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5
#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5
#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5
#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION6_HEADER

38
include/boost/function/function7.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION7_HEADER
#define BOOST_FUNCTION_FUNCTION7_HEADER
#define BOOST_FUNCTION_NUM_ARGS 7
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6
#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6
#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION7_HEADER

38
include/boost/function/function8.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION8_HEADER
#define BOOST_FUNCTION_FUNCTION8_HEADER
#define BOOST_FUNCTION_NUM_ARGS 8
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7
#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6, T7
#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7
#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6, a7
#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7
#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION8_HEADER

38
include/boost/function/function9.hpp
View File

@ -1,39 +1,3 @@
// Boost.Function library
//
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#ifndef BOOST_FUNCTION_FUNCTION9_HEADER
#define BOOST_FUNCTION_FUNCTION9_HEADER
#define BOOST_FUNCTION_NUM_ARGS 9
#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8
#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6, T7, T8
#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8
#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6, a7, a8
#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8
#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7, a8
#define BOOST_FUNCTION_ARG_TYPES typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type;
#include <boost/function/function_template.hpp>
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_NOT_0_ARGS
#undef BOOST_FUNCTION_NOT_0_PARMS
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
#endif // BOOST_FUNCTION_FUNCTION9_HEADER

127
include/boost/function/function_base.hpp
View File

@ -16,13 +16,13 @@
#ifndef BOOST_FUNCTION_BASE_HEADER
#define BOOST_FUNCTION_BASE_HEADER
#include <string>
#include <stdexcept>
#include <memory>
#include <new>
#include <typeinfo>
#include <boost/config.hpp>
#include <boost/type_traits.hpp>
#include <boost/type_traits/arithmetic_traits.hpp>
#include <boost/type_traits/composite_traits.hpp>
#include <boost/type_traits/is_stateless.hpp>
#include <boost/ref.hpp>
#include <boost/pending/ct_if.hpp>
@ -32,18 +32,21 @@
# define BOOST_FUNCTION_TARGET_FIX(x)
#endif // not MSVC
#ifdef BOOST_FUNCTION_SILENT_DEPRECATED
# define BOOST_FUNCTION_DEPRECATED_PRE
# define BOOST_FUNCTION_DEPRECATED_INNER
#else
# if defined (BOOST_MSVC) && (BOOST_MSVC >= 1300)
# define BOOST_FUNCTION_DEPRECATED_PRE __declspec(deprecated)
# define BOOST_FUNCTION_DEPRECATED_INNER
# else
# define BOOST_FUNCTION_DEPRECATED_PRE
# define BOOST_FUNCTION_DEPRECATED_INNER int deprecated;
# endif
#endif
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
namespace boost {
template<typename Signature, typename Allocator = std::allocator<void> >
class function;
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 {
@ -60,12 +63,30 @@ namespace boost {
void* obj_ptr;
const void* const_obj_ptr;
void (*func_ptr)();
explicit any_pointer(void* p) : obj_ptr(p) {}
explicit any_pointer(const void* p) : const_obj_ptr(p) {}
explicit any_pointer(void (*p)()) : func_ptr(p) {}
char data[1];
};
any_pointer make_any_pointer(void* o)
{
any_pointer p;
p.obj_ptr = o;
return p;
}
any_pointer make_any_pointer(const void* o)
{
any_pointer p;
p.const_obj_ptr = o;
return p;
}
any_pointer make_any_pointer(void (*f)())
{
any_pointer p;
p.obj_ptr = f;
return p;
}
/**
* The unusable class is a placeholder for unused function arguments
* It is also completely unusable except that it constructable from
@ -132,7 +153,7 @@ namespace boost {
if (op == clone_functor_tag)
return f;
else
return any_pointer(reinterpret_cast<void*>(0));
return make_any_pointer(reinterpret_cast<void*>(0));
}
/**
@ -154,7 +175,7 @@ namespace boost {
if (op == clone_functor_tag)
return function_ptr;
else
return any_pointer(static_cast<void (*)()>(0));
return make_any_pointer(static_cast<void (*)()>(0));
}
// For function object pointers, we clone the pointer to each
@ -190,7 +211,7 @@ namespace boost {
# else
functor_type* new_f = new functor_type(*f);
# endif // BOOST_NO_STD_ALLOCATOR
return any_pointer(static_cast<void*>(new_f));
return make_any_pointer(static_cast<void*>(new_f));
}
else {
/* Cast from the void pointer to the functor pointer type */
@ -209,7 +230,7 @@ namespace boost {
delete f;
# endif // BOOST_NO_STD_ALLOCATOR
return any_pointer(static_cast<void*>(0));
return make_any_pointer(static_cast<void*>(0));
}
}
public:
@ -222,40 +243,6 @@ namespace boost {
return manager(functor_ptr, op, tag_type());
}
};
// value=1 if the given type is not "unusable"
template<typename T>
struct count_if_used
{
BOOST_STATIC_CONSTANT(int, value = 1);
};
// value=0 for unusable types
template<>
struct count_if_used<unusable>
{
BOOST_STATIC_CONSTANT(int, value = 0);
};
// Count the number of arguments (from the given set) which are not
// "unusable" (therefore, count those arguments that are used).
template<typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8,
typename T9, typename T10>
struct count_used_args
{
BOOST_STATIC_CONSTANT(int, value =
(count_if_used<T1>::value +
count_if_used<T2>::value +
count_if_used<T3>::value +
count_if_used<T4>::value +
count_if_used<T5>::value +
count_if_used<T6>::value +
count_if_used<T7>::value +
count_if_used<T8>::value +
count_if_used<T9>::value +
count_if_used<T10>::value));
};
} // end namespace function
} // end namespace detail
@ -268,7 +255,10 @@ namespace boost {
class function_base
{
public:
function_base() : manager(0), functor(static_cast<void*>(0)) {}
function_base() : manager(0)
{
functor.obj_ptr = 0;
}
// Is this function empty?
bool empty() const { return !manager; }
@ -302,27 +292,6 @@ namespace boost {
}
} // end namespace function
} // end namespace detail
// The default function policy is to do nothing before and after the call.
struct empty_function_policy
{
inline void precall(const function_base*) {}
inline void postcall(const function_base*) {}
};
// The default function mixin does nothing. The assignment and
// copy-construction operators are all defined because MSVC defines broken
// versions.
struct empty_function_mixin
{
empty_function_mixin() {}
empty_function_mixin(const empty_function_mixin&) {}
empty_function_mixin& operator=(const empty_function_mixin&)
{
return *this;
}
};
}
#endif // BOOST_FUNCTION_BASE_HEADER

186
include/boost/function/function_template.hpp
View File

@ -1,6 +1,6 @@
// Boost.Function library
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
@ -15,15 +15,23 @@
// Note: this header is a header template and must NOT have multiple-inclusion
// protection.
#include <boost/function/detail/prologue.hpp>
#ifndef BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP
#define BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP
# include <cassert>
# include <algorithm>
# include <boost/config.hpp>
# include <boost/function/function_base.hpp>
# include <boost/mem_fn.hpp>
#endif // BOOST_FUNCTION_FUNCTION_TEMPLATE_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,)
#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,)
// Type of the default allocator
#ifndef BOOST_NO_STD_ALLOCATOR
@ -229,16 +237,9 @@ namespace boost {
template<
typename R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_PARMS,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy = empty_function_policy,
typename Mixin = empty_function_mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
>
class BOOST_FUNCTION_FUNCTION : public function_base
#ifndef BOOST_FUNCTION_NO_DEPRECATED
, public Mixin
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
{
typedef typename detail::function::function_return_type<R>::type
internal_result_type;
@ -261,57 +262,24 @@ namespace boost {
#else
typedef internal_result_type result_type;
#endif // BOOST_NO_VOID_RETURNS
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typedef Policy policy_type;
typedef Mixin mixin_type;
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typedef Allocator allocator_type;
typedef BOOST_FUNCTION_FUNCTION self_type;
BOOST_FUNCTION_FUNCTION() : function_base()
#ifndef BOOST_FUNCTION_NO_DEPRECATED
, Mixin()
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
, invoker(0) {}
#ifndef BOOST_FUNCTION_NO_DEPRECATED
explicit BOOST_FUNCTION_FUNCTION(const Mixin& m) :
function_base(),
Mixin(m),
invoker(0)
{
}
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
// 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) :
function_base(),
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Mixin(),
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
invoker(0)
{
this->assign_to(f);
}
#ifndef BOOST_FUNCTION_NO_DEPRECATED
template<typename Functor>
BOOST_FUNCTION_FUNCTION(Functor f, const Mixin& m) :
function_base(),
Mixin(m),
invoker(0)
{
this->assign_to(f);
}
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) :
function_base(),
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Mixin(static_cast<const Mixin&>(f)),
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
invoker(0)
{
this->assign_to_own(f);
@ -323,19 +291,10 @@ namespace boost {
{
assert(!this->empty());
#ifndef BOOST_FUNCTION_NO_DEPRECATED
policy_type policy;
policy.precall(this);
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
internal_result_type result = invoker(function_base::functor
BOOST_FUNCTION_COMMA
BOOST_FUNCTION_ARGS);
#ifndef BOOST_FUNCTION_NO_DEPRECATED
policy.postcall(this);
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
#ifndef BOOST_NO_VOID_RETURNS
return static_cast<result_type>(result);
#else
@ -352,24 +311,10 @@ namespace boost {
BOOST_FUNCTION_FUNCTION&
operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
{
#ifndef BOOST_FUNCTION_NO_DEPRECATED
self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
#else
self_type(f).swap(*this);
#endif // BOOST_FUNCTION_NO_DEPRECATED
return *this;
}
#ifndef BOOST_FUNCTION_NO_DEPRECATED
template<typename Functor>
BOOST_FUNCTION_DEPRECATED_PRE
void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
{
BOOST_FUNCTION_DEPRECATED_INNER
self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
}
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
// Assignment from another BOOST_FUNCTION_FUNCTION
BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
{
@ -380,19 +325,6 @@ namespace boost {
return *this;
}
#ifndef BOOST_FUNCTION_NO_DEPRECATED
// Assignment from another BOOST_FUNCTION_FUNCTION
BOOST_FUNCTION_DEPRECATED_PRE
void set(const BOOST_FUNCTION_FUNCTION& f)
{
BOOST_FUNCTION_DEPRECATED_INNER
if (&f == this)
return;
self_type(f).swap(*this);
}
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
void swap(BOOST_FUNCTION_FUNCTION& other)
{
if (&other == this)
@ -401,9 +333,6 @@ namespace boost {
std::swap(function_base::manager, other.manager);
std::swap(function_base::functor, other.functor);
std::swap(invoker, other.invoker);
#ifndef BOOST_FUNCTION_NO_DEPRECATED
std::swap(static_cast<Mixin&>(*this), static_cast<Mixin&>(other));
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
}
// Clear out a target, if there is one
@ -473,7 +402,7 @@ namespace boost {
function_base::manager =
&detail::function::functor_manager<FunctionPtr, Allocator>::manage;
function_base::functor =
function_base::manager(detail::function::any_pointer(
function_base::manager(detail::function::make_any_pointer(
// should be a reinterpret cast, but some compilers
// insist on giving cv-qualifiers to free functions
(void (*)())(f)
@ -519,7 +448,7 @@ namespace boost {
FunctionObj* new_f = new FunctionObj(f);
#endif // BOOST_NO_STD_ALLOCATOR
function_base::functor =
detail::function::any_pointer(static_cast<void*>(new_f));
detail::function::make_any_pointer(static_cast<void*>(new_f));
}
}
@ -540,7 +469,7 @@ namespace boost {
function_base::manager = &detail::function::trivial_manager;
function_base::functor =
function_base::manager(
detail::function::any_pointer(
detail::function::make_any_pointer(
const_cast<FunctionObj*>(f.get_pointer())),
detail::function::clone_functor_tag);
}
@ -559,7 +488,7 @@ namespace boost {
invoker_type;
invoker = &invoker_type::invoke;
function_base::manager = &detail::function::trivial_manager;
function_base::functor = detail::function::any_pointer(this);
function_base::functor = detail::function::make_any_pointer(this);
}
typedef internal_result_type (*invoker_type)(detail::function::any_pointer
@ -570,32 +499,74 @@ namespace boost {
};
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
typename Policy, typename Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
typename Allocator>
inline void swap(BOOST_FUNCTION_FUNCTION<
R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS ,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy,
Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator
>& f1,
BOOST_FUNCTION_FUNCTION<
R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS,
#ifndef BOOST_FUNCTION_NO_DEPRECATED
Policy,
Mixin,
#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
Allocator
>& f2)
{
f1.swap(f2);
}
}
#if !defined (BOOST_NO_PARTIAL_SPECIALIZATION)
#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;
public:
typedef typename base_type::allocator_type allocator_type;
function() : base_type() {}
template<typename Functor>
function(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) : base_type(f) {}
function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
template<typename Functor>
self_type& operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
{
self_type(f).swap(*this);
return *this;
}
self_type& operator=(const base_type& f)
{
self_type(f).swap(*this);
return *this;
}
self_type& operator=(const self_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
@ -611,3 +582,10 @@ namespace boost {
#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

83
include/boost/function/gen_function_N.pl
View File

@ -2,7 +2,7 @@
#
# Boost.Function library
#
# Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
# Copyright (C) 2001,2002 Doug Gregor (gregod@cs.rpi.edu)
#
# Permission to copy, use, sell and distribute this software is granted
# provided this copyright notice appears in all copies.
@ -25,87 +25,8 @@ if ($#ARGV < 0) {
$totalNumArgs = $ARGV[0];
for ($numArgs = 0; $numArgs <= $totalNumArgs; ++$numArgs) {
open OUT, ">function$numArgs.hpp";
print OUT "// Boost.Function library\n";
print OUT "//\n";
print OUT "// Copyright (C) 2001 Doug Gregor (gregod\@cs.rpi.edu)\n";
print OUT "//\n";
print OUT "// Permission to copy, use, sell and distribute this software is granted\n";
print OUT "// provided this copyright notice appears in all copies.\n";
print OUT "// Permission to modify the code and to distribute modified code is granted\n";
print OUT "// provided this copyright notice appears in all copies, and a notice\n";
print OUT "// that the code was modified is included with the copyright notice.\n";
print OUT "//\n";
print OUT "// This software is provided \"as is\" without express or implied warranty,\n";
print OUT "// and with no claim as to its suitability for any purpose.\n";
print OUT " \n";
print OUT "// For more information, see http://www.boost.org\n";
print OUT "\n";
print OUT "#ifndef BOOST_FUNCTION_FUNCTION" . $numArgs . "_HEADER\n";
print OUT "#define BOOST_FUNCTION_FUNCTION" , $numArgs . "_HEADER\n";
print OUT "\n";
print OUT "#define BOOST_FUNCTION_NUM_ARGS $numArgs\n";
$templateParms = "";
for ($i = 0; $i < $numArgs; ++$i) {
if ($i > 0) {
$templateParms .= ", ";
}
$templateParms .= "typename T$i";
}
print OUT "#define BOOST_FUNCTION_TEMPLATE_PARMS $templateParms\n";
$_ = $templateParms;
s/typename //g;
$templateArgs = $_;
print OUT "#define BOOST_FUNCTION_TEMPLATE_ARGS $templateArgs\n";
$parms = "";
for ($i = 0; $i < $numArgs; ++$i) {
if ($i > 0) {
$parms .= ", ";
}
$parms .= "T$i a$i";
}
print OUT "#define BOOST_FUNCTION_PARMS $parms\n";
$args = "";
for ($i = 0; $i < $numArgs; ++$i) {
if ($i > 0) {
$args .= ", ";
}
$args .= "a$i";
}
print OUT "#define BOOST_FUNCTION_ARGS $args\n";
$not0Parms = "";
for ($i = 1; $i < $numArgs; ++$i) {
if ($i > 1) {
$not0Parms .= ", ";
}
$not0Parms .= "T$i a$i";
}
print OUT "#define BOOST_FUNCTION_NOT_0_PARMS $not0Parms\n";
$not0Args = "";
for ($i = 1; $i < $numArgs; ++$i) {
if ($i > 1) {
$not0Args .= ", ";
}
$not0Args .= "a$i";
}
print OUT "#define BOOST_FUNCTION_NOT_0_ARGS $not0Args\n";
print OUT "\n";
print OUT "#include <boost/function/function_template.hpp>\n";
print OUT "\n";
print OUT "#undef BOOST_FUNCTION_NOT_0_ARGS\n";
print OUT "#undef BOOST_FUNCTION_NOT_0_PARMS\n";
print OUT "#undef BOOST_FUNCTION_ARGS\n";
print OUT "#undef BOOST_FUNCTION_PARMS\n";
print OUT "#undef BOOST_FUNCTION_TEMPLATE_ARGS\n";
print OUT "#undef BOOST_FUNCTION_TEMPLATE_PARMS\n";
print OUT "#include <boost/function/detail/maybe_include.hpp>\n";
print OUT "#undef BOOST_FUNCTION_NUM_ARGS\n";
print OUT "\n";
print OUT "#endif // BOOST_FUNCTION_FUNCTION" . $numArgs . "_HEADER\n";
close OUT;
}

5
index.html
View File

@ -25,7 +25,10 @@
</ul>
<a name="compatibility"><h2>Compatibility Note</h2></a>
<p> Boost.Function has been partially redesigned to minimize the interface and make it cleaner. Several seldom- or never-used features of the older Boost.Function have been deprecated and will be removed in the near future. Here is a list of features that have been deprecated, the likely impact of the deprecations, and how to adjust your code:
<p> <b>Version 1.30.0</b>: All deprecated features have been removed
from Boost.Function.
<p> <b>Version 1.29.0</b>: Boost.Function has been partially redesigned to minimize the interface and make it cleaner. Several seldom- or never-used features of the older Boost.Function have been deprecated and will be removed in the near future. Here is a list of features that have been deprecated, the likely impact of the deprecations, and how to adjust your code:
<ul>
<li>The <code>boost::function</code> class template syntax has
changed. The old syntax, e.g., <code>boost::function&lt;int, float,

4
test/allocator_test.cpp
View File

@ -60,7 +60,7 @@ static void do_nothing() {}
int
test_main(int, char*[])
{
function<int, int, int>::allocator< counting_allocator<int> >::type f;
function2<int, int, int, counting_allocator<int> > f;
f = plus<int>();
f.clear();
BOOST_TEST(alloc_count == 1);
@ -71,7 +71,7 @@ test_main(int, char*[])
f = &do_minus;
f.clear();
function<void>::allocator< counting_allocator<int> >::type fv;
function0<void, counting_allocator<int> > fv;
alloc_count = 0;
dealloc_count = 0;
fv = DoNothing();

645
test/deprecated_syntax_test.cpp
View File

@ -1,645 +0,0 @@
// Boost.Function library
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#define BOOST_INCLUDE_MAIN
#include <boost/test/test_tools.hpp>
#include <boost/function.hpp>
#include <functional>
#include <cassert>
#include <string>
using namespace boost;
using std::string;
using std::negate;
int global_int;
struct write_five_obj { void operator()() const { global_int = 5; } };
struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
static void write_five() { global_int = 5; }
static void write_three() { global_int = 3; }
struct generate_five_obj { int operator()() const { return 5; } };
struct generate_three_obj { int operator()() const { return 3; } };
static int generate_five() { return 5; }
static int generate_three() { return 3; }
static string identity_str(const string& s) { return s; }
static string string_cat(const string& s1, const string& s2) { return s1+s2; }
static int sum_ints(int x, int y) { return x+y; }
struct write_const_1_nonconst_2
{
void operator()() { global_int = 2; }
void operator()() const { global_int = 1; }
};
struct add_to_obj
{
add_to_obj(int v) : value(v) {}
int operator()(int x) const { return value + x; }
int value;
};
static void
test_zero_args()
{
typedef function<void> func_void_type;
write_five_obj five;
write_three_obj three;
// Default construction
func_void_type v1;
BOOST_TEST(v1.empty());
// Assignment to an empty function
v1 = five;
BOOST_TEST(!v1.empty());
// Invocation of a function
global_int = 0;
v1();
BOOST_TEST(global_int == 5);
// clear() method
v1.clear();
BOOST_TEST(v1.empty());
// Assignment to an empty function
v1 = three;
BOOST_TEST(!v1.empty());
// Invocation and self-assignment
global_int = 0;
v1 = v1;
v1();
BOOST_TEST(global_int == 3);
// Assignment to a non-empty function
v1 = five;
// Invocation and self-assignment
global_int = 0;
v1 = (v1);
v1();
BOOST_TEST(global_int == 5);
// clear()
v1.clear();
BOOST_TEST(v1.empty());
// Assignment to an empty function from a free function
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
BOOST_TEST(!v1.empty());
// Invocation
global_int = 0;
v1();
BOOST_TEST(global_int == 5);
// Assignment to a non-empty function from a free function
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
BOOST_TEST(!v1.empty());
// Invocation
global_int = 0;
v1();
BOOST_TEST(global_int == 3);
// Assignment
v1 = five;
BOOST_TEST(!v1.empty());
// Invocation
global_int = 0;
v1();
BOOST_TEST(global_int == 5);
// Assignment to a non-empty function from a free function
v1 = &write_three;
BOOST_TEST(!v1.empty());
// Invocation
global_int = 0;
v1();
BOOST_TEST(global_int == 3);
// Construction from another function (that is empty)
v1.clear();
func_void_type v2(v1);
BOOST_TEST(!v2? true : false);
// Assignment to an empty function
v2 = three;
BOOST_TEST(!v2.empty());
// Invocation
global_int = 0;
v2();
BOOST_TEST(global_int == 3);
// Assignment to a non-empty function
v2 = (five);
// Invocation
global_int = 0;
v2();
BOOST_TEST(global_int == 5);
v2.clear();
BOOST_TEST(v2.empty());
// Assignment to an empty function from a free function
v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
BOOST_TEST(v2? true : false);
// Invocation
global_int = 0;
v2();
BOOST_TEST(global_int == 5);
// Assignment to a non-empty function from a free function
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
BOOST_TEST(!v2.empty());
// Invocation
global_int = 0;
v2();
BOOST_TEST(global_int == 3);
// Swapping
v1 = five;
swap(v1, v2);
v2();
BOOST_TEST(global_int == 5);
v1();
BOOST_TEST(global_int == 3);
swap(v1, v2);
v1.clear();
// Assignment
v2 = five;
BOOST_TEST(!v2.empty());
// Invocation
global_int = 0;
v2();
BOOST_TEST(global_int == 5);
// Assignment to a non-empty function from a free function
v2 = &write_three;
BOOST_TEST(!v2.empty());
// Invocation
global_int = 0;
v2();
BOOST_TEST(global_int == 3);
// Assignment to a function from an empty function
v2 = v1;
BOOST_TEST(v2.empty());
// Assignment to a function from a function with a functor
v1 = three;
v2 = v1;
BOOST_TEST(!v1.empty());
BOOST_TEST(!v2.empty());
// Invocation
global_int = 0;
v1();
BOOST_TEST(global_int == 3);
global_int = 0;
v2();
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_TEST(!v1.empty());
BOOST_TEST(!v2.empty());
global_int = 0;
v1();
BOOST_TEST(global_int == 5);
global_int = 0;
v2();
BOOST_TEST(global_int == 5);
// Construct a function given another function containing a function
func_void_type v3(v1);
// Invocation of a function
global_int = 0;
v3();
BOOST_TEST(global_int == 5);
// clear() method
v3.clear();
BOOST_TEST(!v3? true : false);
// Assignment to an empty function
v3 = three;
BOOST_TEST(!v3.empty());
// Invocation
global_int = 0;
v3();
BOOST_TEST(global_int == 3);
// Assignment to a non-empty function
v3 = five;
// Invocation
global_int = 0;
v3();
BOOST_TEST(global_int == 5);
// clear()
v3.clear();
BOOST_TEST(v3.empty());
// Assignment to an empty function from a free function
v3 = &write_five;
BOOST_TEST(!v3.empty());
// Invocation
global_int = 0;
v3();
BOOST_TEST(global_int == 5);
// Assignment to a non-empty function from a free function
v3 = &write_three;
BOOST_TEST(!v3.empty());
// Invocation
global_int = 0;
v3();
BOOST_TEST(global_int == 3);
// Assignment
v3 = five;
BOOST_TEST(!v3.empty());
// Invocation
global_int = 0;
v3();
BOOST_TEST(global_int == 5);
// Construction of a function from a function containing a functor
func_void_type v4(v3);
// Invocation of a function
global_int = 0;
v4();
BOOST_TEST(global_int == 5);
// clear() method
v4.clear();
BOOST_TEST(v4.empty());
// Assignment to an empty function
v4 = three;
BOOST_TEST(!v4.empty());
// Invocation
global_int = 0;
v4();
BOOST_TEST(global_int == 3);
// Assignment to a non-empty function
v4 = five;
// Invocation
global_int = 0;
v4();
BOOST_TEST(global_int == 5);
// clear()
v4.clear();
BOOST_TEST(v4.empty());
// Assignment to an empty function from a free function
v4 = &write_five;
BOOST_TEST(!v4.empty());
// Invocation
global_int = 0;
v4();
BOOST_TEST(global_int == 5);
// Assignment to a non-empty function from a free function
v4 = &write_three;
BOOST_TEST(!v4.empty());
// Invocation
global_int = 0;
v4();
BOOST_TEST(global_int == 3);
// Assignment
v4 = five;
BOOST_TEST(!v4.empty());
// Invocation
global_int = 0;
v4();
BOOST_TEST(global_int == 5);
// Construction of a function from a functor
func_void_type v5(five);
// Invocation of a function
global_int = 0;
v5();
BOOST_TEST(global_int == 5);
// clear() method
v5.clear();
BOOST_TEST(v5.empty());
// Assignment to an empty function
v5 = three;
BOOST_TEST(!v5.empty());
// Invocation
global_int = 0;
v5();
BOOST_TEST(global_int == 3);
// Assignment to a non-empty function
v5 = five;
// Invocation
global_int = 0;
v5();
BOOST_TEST(global_int == 5);
// clear()
v5.clear();
BOOST_TEST(v5.empty());
// Assignment to an empty function from a free function
v5 = &write_five;
BOOST_TEST(!v5.empty());
// Invocation
global_int = 0;
v5();
BOOST_TEST(global_int == 5);
// Assignment to a non-empty function from a free function
v5 = &write_three;
BOOST_TEST(!v5.empty());
// Invocation
global_int = 0;
v5();
BOOST_TEST(global_int == 3);
// Assignment
v5 = five;
BOOST_TEST(!v5.empty());
// Invocation
global_int = 0;
v5();
BOOST_TEST(global_int == 5);
// Construction of a function from a function
func_void_type v6(&write_five);
// Invocation of a function
global_int = 0;
v6();
BOOST_TEST(global_int == 5);
// clear() method
v6.clear();
BOOST_TEST(v6.empty());
// Assignment to an empty function
v6 = three;
BOOST_TEST(!v6.empty());
// Invocation
global_int = 0;
v6();
BOOST_TEST(global_int == 3);
// Assignment to a non-empty function
v6 = five;
// Invocation
global_int = 0;
v6();
BOOST_TEST(global_int == 5);
// clear()
v6.clear();
BOOST_TEST(v6.empty());
// Assignment to an empty function from a free function
v6 = &write_five;
BOOST_TEST(!v6.empty());
// Invocation
global_int = 0;
v6();
BOOST_TEST(global_int == 5);
// Assignment to a non-empty function from a free function
v6 = &write_three;
BOOST_TEST(!v6.empty());
// Invocation
global_int = 0;
v6();
BOOST_TEST(global_int == 3);
// Assignment
v6 = five;
BOOST_TEST(!v6.empty());
// Invocation
global_int = 0;
v6();
BOOST_TEST(global_int == 5);
// Const vs. non-const
write_const_1_nonconst_2 one_or_two;
const function<void> v7(one_or_two);
function <void> v8(one_or_two);
global_int = 0;
v7();
BOOST_TEST(global_int == 2);
global_int = 0;
v8();
BOOST_TEST(global_int == 2);
// Test return values
typedef function<int> func_int_type;
generate_five_obj gen_five;
generate_three_obj gen_three;
func_int_type i0(gen_five);
BOOST_TEST(i0() == 5);
i0 = gen_three;
BOOST_TEST(i0() == 3);
i0 = &generate_five;
BOOST_TEST(i0() == 5);
i0 = &generate_three;
BOOST_TEST(i0() == 3);
BOOST_TEST(i0? true : false);
i0.clear();
BOOST_TEST(!i0? true : false);
// Test return values with compatible types
typedef function<long> func_long_type;
func_long_type i1(gen_five);
BOOST_TEST(i1() == 5);
i1 = gen_three;
BOOST_TEST(i1() == 3);
i1 = &generate_five;
BOOST_TEST(i1() == 5);
i1 = &generate_three;
BOOST_TEST(i1() == 3);
BOOST_TEST(i1? true : false);
i1.clear();
BOOST_TEST(!i1? true : false);
}
static void
test_one_arg()
{
negate<int> neg;
function<int, int> f1(neg);
BOOST_TEST(f1(5) == -5);
function<string, string> id(&identity_str);
BOOST_TEST(id("str") == "str");
function<std::string, const char*> id2(&identity_str);
BOOST_TEST(id2("foo") == "foo");
add_to_obj add_to(5);
function<int, int> f2(add_to);
BOOST_TEST(f2(3) == 8);
const function<int, int> cf2(add_to);
BOOST_TEST(cf2(3) == 8);
}
static void
test_two_args()
{
function<string, const string&, const string&> cat(&string_cat);
BOOST_TEST(cat("str", "ing") == "string");
function<int, short, short> sum(&sum_ints);
BOOST_TEST(sum(2, 3) == 5);
}
static void
test_emptiness()
{
function<float> f1;
BOOST_TEST(f1.empty());
function<float> f2;
f2 = f1;
BOOST_TEST(f2.empty());
function<double> f3;
f3 = f2;
BOOST_TEST(f3.empty());
}
struct X {
X(int v) : value(v) {}
int twice() const { return 2*value; }
int plus(int v) { return value + v; }
int value;
};
static void
test_member_functions()
{
boost::function<int, X*> f1(&X::twice);
X one(1);
X five(5);
BOOST_TEST(f1(&one) == 2);
BOOST_TEST(f1(&five) == 10);
boost::function<int, X*> f1_2;
f1_2 = &X::twice;
BOOST_TEST(f1_2(&one) == 2);
BOOST_TEST(f1_2(&five) == 10);
boost::function<int, X&, int> f2(&X::plus);
BOOST_TEST(f2(one, 3) == 4);
BOOST_TEST(f2(five, 4) == 9);
}
struct add_with_throw_on_copy {
int operator()(int x, int y) const { return x+y; }
add_with_throw_on_copy() {}
add_with_throw_on_copy(const add_with_throw_on_copy&)
{
throw std::runtime_error("But this CAN'T throw");
}
add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
{
throw std::runtime_error("But this CAN'T throw");
}
};
static void
test_ref()
{
add_with_throw_on_copy atc;
try {
boost::function<int, int, int> f(ref(atc));
BOOST_TEST(f(1, 3) == 4);
}
catch(std::runtime_error e) {
BOOST_ERROR("Nonthrowing constructor threw an exception");
}
}
int test_main(int, char* [])
{
test_zero_args();
test_one_arg();
test_two_args();
test_emptiness();
test_member_functions();
test_ref();
return 0;
}

16
test/function_30.cpp Normal file
View File

@ -0,0 +1,16 @@
// Make sure we don't try to redefine function2
#include <boost/function/function2.hpp>
// Define all Boost.Function class templates up to 30 arguments
#define BOOST_FUNCTION_MAX_ARGS 30
#include <boost/function.hpp>
int main()
{
boost::function0<float> f0;
boost::function30<float, int, int, int, int, int, int, int, int, int, int,
int, int, int, int, int, int, int, int, int, int,
int, int, int, int, int, int, int, int, int, int> f30;
return 0;
}

2
test/function_n_test.cpp
View File

@ -481,7 +481,7 @@ test_zero_args()
// Const vs. non-const
write_const_1_nonconst_2 one_or_two;
const function0<void> v7(one_or_two);
function <void> v8(one_or_two);
function0<void> v8(one_or_two);
global_int = 0;
v7();

60
test/mixin_test.cpp
View File

@ -1,60 +0,0 @@
// Boost.Function library
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#define BOOST_INCLUDE_MAIN
#include <boost/test/test_tools.hpp>
#include <cassert>
#include <functional>
#include <boost/function.hpp>
struct id_mixin
{
id_mixin(const id_mixin& rhs) : id(rhs.id) {}
id_mixin& operator=(const id_mixin& rhs){id = rhs.id; return *this;}
id_mixin(int i = 0){ id = i;}
int id;
};
static int do_plus(int x, int y) { return x+y; }
typedef boost::function<int,int,int>::mixin<id_mixin>::type func;
int test_main(int, char*[])
{
func f(id_mixin(3));
f = std::plus<int>();
BOOST_TEST(f.id == 3);
f = &do_plus;
BOOST_TEST(f.id == 3);
f.clear();
f.id = 7;
BOOST_TEST(f.id == 7);
func g(f);
BOOST_TEST(g.id == 7);
f.id = 21;
BOOST_TEST(f.id == 21);
boost::swap(f,g);
BOOST_TEST(f.id == 7);
BOOST_TEST(g.id == 21);
g = f;
BOOST_TEST(g.id == 7);
return 0;
}

47
test/policy_test.cpp
View File

@ -1,47 +0,0 @@
// Boost.Function library
// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
// For more information, see http://www.boost.org
#define BOOST_INCLUDE_MAIN
#include <boost/test/test_tools.hpp>
#include <cassert>
#include <iostream>
#include <functional>
#include <boost/function.hpp>
using namespace std;
using namespace boost;
struct counting_policy
{
static int count;
void precall(const function_base*) { count++; }
void postcall(const function_base*) { count+=2; }
};
int counting_policy::count = 0;
int
test_main(int, char*[])
{
function<int, int, int>::policy<counting_policy>::type f;
f = plus<int>();
BOOST_TEST(5 == f(2,3));
BOOST_TEST(counting_policy::count==3);
return 0;
}